-// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2014-2015 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
use clone::Clone;
use cmp::{max, Eq, PartialEq};
use default::Default;
-use fmt::{self, Show};
+use fmt::{self, Debug};
use hash::{self, Hash, SipHasher};
use iter::{self, Iterator, ExactSizeIterator, IteratorExt, FromIterator, Extend, Map};
use marker::Sized;
// min_capacity(size) must be smaller than the internal capacity,
// so that the map is not resized:
// `min_capacity(usable_capacity(x)) <= x`.
- // The lef-hand side can only be smaller due to flooring by integer
+ // The left-hand side can only be smaller due to flooring by integer
// division.
//
// This doesn't have to be checked for overflow since allocation size
/// ```
/// use std::collections::HashMap;
///
-/// #[derive(Hash, Eq, PartialEq, Show)]
+/// #[derive(Hash, Eq, PartialEq, Debug)]
/// struct Viking {
/// name: String,
/// country: String,
/// map.insert("b", 2);
/// map.insert("c", 3);
///
- /// for key in map.values() {
- /// println!("{}", key);
+ /// for val in map.values() {
+ /// println!("{}", val);
/// }
/// ```
#[stable]
search_entry_hashed(&mut self.table, hash, key)
}
- /// Return the number of elements in the map.
+ /// Returns the number of elements in the map.
///
/// # Example
///
#[stable]
pub fn len(&self) -> uint { self.table.size() }
- /// Return true if the map contains no elements.
+ /// Returns true if the map contains no elements.
///
/// # Example
///
{}
#[stable]
-impl<K, V, S, H> Show for HashMap<K, V, S>
- where K: Eq + Hash<H> + Show, V: Show,
+impl<K, V, S, H> Debug for HashMap<K, V, S>
+ where K: Eq + Hash<H> + Debug, V: Debug,
S: HashState<Hasher=H>,
H: hash::Hasher<Output=u64>
{
}
}
-/// HashMap iterator
+/// HashMap iterator.
#[stable]
pub struct Iter<'a, K: 'a, V: 'a> {
inner: table::Iter<'a, K, V>
}
}
-/// HashMap mutable values iterator
+/// HashMap mutable values iterator.
#[stable]
pub struct IterMut<'a, K: 'a, V: 'a> {
inner: table::IterMut<'a, K, V>
}
-/// HashMap move iterator
+/// HashMap move iterator.
#[stable]
pub struct IntoIter<K, V> {
inner: iter::Map<
>
}
-/// HashMap keys iterator
+/// HashMap keys iterator.
#[stable]
pub struct Keys<'a, K: 'a, V: 'a> {
inner: Map<(&'a K, &'a V), &'a K, Iter<'a, K, V>, fn((&'a K, &'a V)) -> &'a K>
}
}
-/// HashMap values iterator
+/// HashMap values iterator.
#[stable]
pub struct Values<'a, K: 'a, V: 'a> {
inner: Map<(&'a K, &'a V), &'a V, Iter<'a, K, V>, fn((&'a K, &'a V)) -> &'a V>
}
}
-/// HashMap drain iterator
+/// HashMap drain iterator.
#[unstable = "matches collection reform specification, waiting for dust to settle"]
pub struct Drain<'a, K: 'a, V: 'a> {
inner: iter::Map<
>
}
-/// A view into a single occupied location in a HashMap
+/// A view into a single occupied location in a HashMap.
#[unstable = "precise API still being fleshed out"]
pub struct OccupiedEntry<'a, K: 'a, V: 'a> {
elem: FullBucket<K, V, &'a mut RawTable<K, V>>,
}
-/// A view into a single empty location in a HashMap
+/// A view into a single empty location in a HashMap.
#[unstable = "precise API still being fleshed out"]
pub struct VacantEntry<'a, K: 'a, V: 'a> {
hash: SafeHash,
elem: VacantEntryState<K, V, &'a mut RawTable<K, V>>,
}
-/// A view into a single location in a map, which may be vacant or occupied
+/// A view into a single location in a map, which may be vacant or occupied.
#[unstable = "precise API still being fleshed out"]
pub enum Entry<'a, K: 'a, V: 'a> {
- /// An occupied Entry
+ /// An occupied Entry.
Occupied(OccupiedEntry<'a, K, V>),
- /// A vacant Entry
+ /// A vacant Entry.
Vacant(VacantEntry<'a, K, V>),
}
-/// Possible states of a VacantEntry
+/// Possible states of a VacantEntry.
enum VacantEntryState<K, V, M> {
/// The index is occupied, but the key to insert has precedence,
- /// and will kick the current one out on insertion
+ /// and will kick the current one out on insertion.
NeqElem(FullBucket<K, V, M>, uint),
- /// The index is genuinely vacant
+ /// The index is genuinely vacant.
NoElem(EmptyBucket<K, V, M>),
}
#[unstable = "matches collection reform v2 specification, waiting for dust to settle"]
impl<'a, K, V> Entry<'a, K, V> {
- /// Returns a mutable reference to the entry if occupied, or the VacantEntry if vacant
+ /// Returns a mutable reference to the entry if occupied, or the VacantEntry if vacant.
pub fn get(self) -> Result<&'a mut V, VacantEntry<'a, K, V>> {
match self {
Occupied(entry) => Ok(entry.into_mut()),
#[unstable = "matches collection reform v2 specification, waiting for dust to settle"]
impl<'a, K, V> OccupiedEntry<'a, K, V> {
- /// Gets a reference to the value in the entry
+ /// Gets a reference to the value in the entry.
pub fn get(&self) -> &V {
self.elem.read().1
}
- /// Gets a mutable reference to the value in the entry
+ /// Gets a mutable reference to the value in the entry.
pub fn get_mut(&mut self) -> &mut V {
self.elem.read_mut().1
}
let map_str = format!("{:?}", map);
- assert!(map_str == "HashMap {1i: 2i, 3i: 4i}" ||
- map_str == "HashMap {3i: 4i, 1i: 2i}");
+ assert!(map_str == "HashMap {1: 2, 3: 4}" ||
+ map_str == "HashMap {3: 4, 1: 2}");
assert_eq!(format!("{:?}", empty), "HashMap {}");
}
assert_eq!(m.remove(&0), Some(0));
}
- #[test]
- fn test_find_equiv() {
- let mut m = HashMap::new();
-
- let (foo, bar, baz) = (1i,2i,3i);
- m.insert("foo".to_string(), foo);
- m.insert("bar".to_string(), bar);
- m.insert("baz".to_string(), baz);
-
-
- assert_eq!(m.get("foo"), Some(&foo));
- assert_eq!(m.get("bar"), Some(&bar));
- assert_eq!(m.get("baz"), Some(&baz));
-
- assert_eq!(m.get("qux"), None);
- }
-
#[test]
fn test_from_iter() {
let xs = [(1i, 1i), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];