-// 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, IteratorExt, FromIterator, Extend, Map};
+use iter::{self, Iterator, ExactSizeIterator, IteratorExt, FromIterator, Extend, Map};
use marker::Sized;
use mem::{self, replace};
use num::{Int, UnsignedInt};
// 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>),
}
type Item = (&'a K, &'a V);
#[inline] fn next(&mut self) -> Option<(&'a K, &'a V)> { self.inner.next() }
- #[inline] fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
+ #[inline] fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
+}
+#[stable]
+impl<'a, K, V> ExactSizeIterator for Iter<'a, K, V> {
+ #[inline] fn len(&self) -> usize { self.inner.len() }
}
#[stable]
type Item = (&'a K, &'a mut V);
#[inline] fn next(&mut self) -> Option<(&'a K, &'a mut V)> { self.inner.next() }
- #[inline] fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
+ #[inline] fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
+}
+#[stable]
+impl<'a, K, V> ExactSizeIterator for IterMut<'a, K, V> {
+ #[inline] fn len(&self) -> usize { self.inner.len() }
}
#[stable]
type Item = (K, V);
#[inline] fn next(&mut self) -> Option<(K, V)> { self.inner.next() }
- #[inline] fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
+ #[inline] fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
+}
+#[stable]
+impl<K, V> ExactSizeIterator for IntoIter<K, V> {
+ #[inline] fn len(&self) -> usize { self.inner.len() }
}
#[stable]
type Item = &'a K;
#[inline] fn next(&mut self) -> Option<(&'a K)> { self.inner.next() }
- #[inline] fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
+ #[inline] fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
+}
+#[stable]
+impl<'a, K, V> ExactSizeIterator for Keys<'a, K, V> {
+ #[inline] fn len(&self) -> usize { self.inner.len() }
}
#[stable]
type Item = &'a V;
#[inline] fn next(&mut self) -> Option<(&'a V)> { self.inner.next() }
- #[inline] fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
+ #[inline] fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
+}
+#[stable]
+impl<'a, K, V> ExactSizeIterator for Values<'a, K, V> {
+ #[inline] fn len(&self) -> usize { self.inner.len() }
}
#[stable]
-impl<'a, K: 'a, V: 'a> Iterator for Drain<'a, K, V> {
+impl<'a, K, V> Iterator for Drain<'a, K, V> {
type Item = (K, V);
- #[inline]
- fn next(&mut self) -> Option<(K, V)> {
- self.inner.next()
- }
- #[inline]
- fn size_hint(&self) -> (uint, Option<uint>) {
- self.inner.size_hint()
- }
+ #[inline] fn next(&mut self) -> Option<(K, V)> { self.inner.next() }
+ #[inline] fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
+}
+#[stable]
+impl<'a, K, V> ExactSizeIterator for Drain<'a, K, V> {
+ #[inline] fn len(&self) -> usize { self.inner.len() }
}
#[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)];
assert_eq!(iter.size_hint(), (3, Some(3)));
}
+ #[test]
+ fn test_iter_len() {
+ let xs = [(1i, 1i), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
+
+ let map: HashMap<int, int> = xs.iter().map(|&x| x).collect();
+
+ let mut iter = map.iter();
+
+ for _ in iter.by_ref().take(3) {}
+
+ assert_eq!(iter.len(), 3);
+ }
+
#[test]
fn test_mut_size_hint() {
let xs = [(1i, 1i), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
assert_eq!(iter.size_hint(), (3, Some(3)));
}
+ #[test]
+ fn test_iter_mut_len() {
+ let xs = [(1i, 1i), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
+
+ let mut map: HashMap<int, int> = xs.iter().map(|&x| x).collect();
+
+ let mut iter = map.iter_mut();
+
+ for _ in iter.by_ref().take(3) {}
+
+ assert_eq!(iter.len(), 3);
+ }
+
#[test]
fn test_index() {
let mut map: HashMap<int, int> = HashMap::new();