}
impl Hasher for TypeIdHasher {
- #[inline(always)]
+ #[inline]
fn write(&mut self, bytes: &[u8]) {
// This expects to receive one and exactly one 64-bit value
debug_assert!(bytes.len() == 8);
unsafe {
- ptr::copy_nonoverlapping(&mut self.value, mem::transmute(&bytes[0]), 1)
+ ptr::copy_nonoverlapping(mem::transmute(&bytes[0]), &mut self.value, 1)
}
}
- #[inline(always)]
+ #[inline]
fn finish(&self) -> u64 { self.value }
}
+#[test]
+fn type_id_hasher() {
+ fn verify_hashing_with(type_id: TypeId) {
+ let mut hasher = TypeIdHasher::default();
+ type_id.hash(&mut hasher);
+ assert_eq!(hasher.finish(), unsafe { mem::transmute::<TypeId, u64>(type_id) });
+ }
+ // Pick a variety of types, just to demonstrate it’s all sane. Normal, zero-sized, unsized, &c.
+ verify_hashing_with(TypeId::of::<usize>());
+ verify_hashing_with(TypeId::of::<()>());
+ verify_hashing_with(TypeId::of::<str>());
+ verify_hashing_with(TypeId::of::<&str>());
+ verify_hashing_with(TypeId::of::<Vec<u8>>());
+}
+
/// The raw, underlying form of a `Map`.
///
/// At its essence, this is a wrapper around `HashMap<TypeId, Box<Any>>`, with the portions that
with_capacity(capacity) => HashMap::with_capacity_and_hasher(capacity, Default::default());
}
-/// RawMap iterator.
+/// `RawMap` iterator.
#[derive(Clone)]
pub struct Iter<'a, A: ?Sized + UncheckedAnyExt> {
inner: hash_map::Iter<'a, TypeId, Box<A>>,
#[inline] fn len(&self) -> usize { self.inner.len() }
}
-/// RawMap mutable iterator.
+/// `RawMap` mutable iterator.
pub struct IterMut<'a, A: ?Sized + UncheckedAnyExt> {
inner: hash_map::IterMut<'a, TypeId, Box<A>>,
}
#[inline] fn len(&self) -> usize { self.inner.len() }
}
-/// RawMap move iterator.
+/// `RawMap` move iterator.
pub struct IntoIter<A: ?Sized + UncheckedAnyExt> {
inner: hash_map::IntoIter<TypeId, Box<A>>,
}
#[inline] fn len(&self) -> usize { self.inner.len() }
}
-/// RawMap drain iterator.
-#[cfg(feature = "unstable")]
+/// `RawMap` drain iterator.
pub struct Drain<'a, A: ?Sized + UncheckedAnyExt> {
inner: hash_map::Drain<'a, TypeId, Box<A>>,
}
-#[cfg(feature = "unstable")]
impl<'a, A: ?Sized + UncheckedAnyExt> Iterator for Drain<'a, A> {
type Item = Box<A>;
#[inline] fn next(&mut self) -> Option<Box<A>> { self.inner.next().map(|x| x.1) }
#[inline] fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
}
-#[cfg(feature = "unstable")]
impl<'a, A: ?Sized + UncheckedAnyExt> ExactSizeIterator for Drain<'a, A> {
#[inline] fn len(&self) -> usize { self.inner.len() }
}
///
/// Keeps the allocated memory for reuse.
#[inline]
- #[cfg(feature = "unstable")]
pub fn drain(&mut self) -> Drain<A> {
Drain {
inner: self.inner.drain(),
impl<A: ?Sized + UncheckedAnyExt, Q> Index<Q> for RawMap<A> where TypeId: Borrow<Q>, Q: Eq + Hash {
type Output = A;
- fn index<'a>(&'a self, index: Q) -> &'a A {
+ fn index(&self, index: Q) -> &A {
self.get(&index).expect("no entry found for key")
}
}
impl<A: ?Sized + UncheckedAnyExt, Q> IndexMut<Q> for RawMap<A> where TypeId: Borrow<Q>, Q: Eq + Hash {
- fn index_mut<'a>(&'a mut self, index: Q) -> &'a mut A {
+ fn index_mut(&mut self, index: Q) -> &mut A {
self.get_mut(&index).expect("no entry found for key")
}
}