use std::any::TypeId;
use std::borrow::Borrow;
use std::collections::hash_map::{self, HashMap};
-#[cfg(feature = "nightly")]
-use std::collections::hash_state::HashState;
-use std::default::Default;
use std::hash::Hash;
-#[cfg(feature = "nightly")]
-use std::hash::Hasher;
-use std::iter::IntoIterator;
-#[cfg(feature = "nightly")]
+use std::hash::{Hasher, BuildHasherDefault};
use std::mem;
use std::ops::{Index, IndexMut};
-#[cfg(feature = "nightly")]
use std::ptr;
use any::{Any, UncheckedAnyExt};
-#[cfg(feature = "nightly")]
+#[derive(Default)]
struct TypeIdHasher {
value: u64,
}
-#[derive(Clone)]
-#[cfg(feature = "nightly")]
-struct TypeIdState;
-
-#[cfg(feature = "nightly")]
-impl HashState for TypeIdState {
- type Hasher = TypeIdHasher;
-
- fn hasher(&self) -> TypeIdHasher {
- TypeIdHasher { value: 0 }
- }
-}
-
-#[cfg(feature = "nightly")]
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`.
///
/// doesn’t tend to be so very useful. Still, if you need it, it’s here.
#[derive(Debug)]
pub struct RawMap<A: ?Sized + UncheckedAnyExt = Any> {
- #[cfg(feature = "nightly")]
- inner: HashMap<TypeId, Box<A>, TypeIdState>,
-
- #[cfg(not(feature = "nightly"))]
- inner: HashMap<TypeId, Box<A>>,
+ inner: HashMap<TypeId, Box<A>, BuildHasherDefault<TypeIdHasher>>,
}
// #[derive(Clone)] would want A to implement Clone, but in reality it’s only Box<A> that can.
}
}
-#[cfg(feature = "nightly")]
-impl_common_methods! {
- field: RawMap.inner;
- new() => HashMap::with_hash_state(TypeIdState);
- with_capacity(capacity) => HashMap::with_capacity_and_hash_state(capacity, TypeIdState);
-}
-
-#[cfg(not(feature = "nightly"))]
impl_common_methods! {
field: RawMap.inner;
- new() => HashMap::new();
- with_capacity(capacity) => HashMap::with_capacity(capacity);
+ new() => HashMap::with_hasher(Default::default());
+ 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 = "nightly")]
+/// `RawMap` drain iterator.
pub struct Drain<'a, A: ?Sized + UncheckedAnyExt> {
inner: hash_map::Drain<'a, TypeId, Box<A>>,
}
-#[cfg(feature = "nightly")]
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 = "nightly")]
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 = "nightly")]
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")
}
}