X-Git-Url: https://git.chrismorgan.info/anymap/blobdiff_plain/82f41caeb9424c7111f670618f140a938c82604e..8ebb2d7e04d86d09614f578342e4765276372e7b:/src/raw.rs diff --git a/src/raw.rs b/src/raw.rs index 3d1be50..07dccf8 100644 --- a/src/raw.rs +++ b/src/raw.rs @@ -5,52 +5,48 @@ use std::any::TypeId; use std::borrow::Borrow; use std::collections::hash_map::{self, HashMap}; -#[cfg(feature = "unstable")] -use std::collections::hash_state::HashState; use std::hash::Hash; -#[cfg(feature = "unstable")] -use std::hash::Hasher; -#[cfg(feature = "unstable")] +use std::hash::{Hasher, BuildHasherDefault}; +#[cfg(test)] use std::mem; use std::ops::{Index, IndexMut}; -#[cfg(feature = "unstable")] use std::ptr; use any::{Any, UncheckedAnyExt}; -#[cfg(feature = "unstable")] +#[derive(Default)] struct TypeIdHasher { value: u64, } -#[derive(Clone)] -#[cfg(feature = "unstable")] -struct TypeIdState; - -#[cfg(feature = "unstable")] -impl HashState for TypeIdState { - type Hasher = TypeIdHasher; - - fn hasher(&self) -> TypeIdHasher { - TypeIdHasher { value: 0 } - } -} - -#[cfg(feature = "unstable")] 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(&bytes[0] as *const u8 as *const u64, &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::(type_id) }); + } + // Pick a variety of types, just to demonstrate it’s all sane. Normal, zero-sized, unsized, &c. + verify_hashing_with(TypeId::of::()); + verify_hashing_with(TypeId::of::<()>()); + verify_hashing_with(TypeId::of::()); + verify_hashing_with(TypeId::of::<&str>()); + verify_hashing_with(TypeId::of::>()); +} /// The raw, underlying form of a `Map`. /// @@ -61,15 +57,12 @@ impl Hasher for TypeIdHasher { /// doesn’t tend to be so very useful. Still, if you need it, it’s here. #[derive(Debug)] pub struct RawMap { - #[cfg(feature = "unstable")] - inner: HashMap, TypeIdState>, - - #[cfg(not(feature = "unstable"))] - inner: HashMap>, + inner: HashMap, BuildHasherDefault>, } // #[derive(Clone)] would want A to implement Clone, but in reality it’s only Box that can. impl Clone for RawMap where Box: Clone { + #[inline] fn clone(&self) -> RawMap { RawMap { inner: self.inner.clone(), @@ -77,27 +70,13 @@ impl Clone for RawMap where Box: Clone { } } -impl Default for RawMap { - fn default() -> RawMap { - RawMap::new() - } -} - -#[cfg(feature = "unstable")] -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 = "unstable"))] 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>, @@ -111,7 +90,7 @@ impl<'a, A: ?Sized + UncheckedAnyExt> ExactSizeIterator for Iter<'a, 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>, } @@ -124,7 +103,7 @@ impl<'a, A: ?Sized + UncheckedAnyExt> ExactSizeIterator for IterMut<'a, A> { #[inline] fn len(&self) -> usize { self.inner.len() } } -/// RawMap move iterator. +/// `RawMap` move iterator. pub struct IntoIter { inner: hash_map::IntoIter>, } @@ -137,18 +116,15 @@ impl ExactSizeIterator for IntoIter { #[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>, } -#[cfg(feature = "unstable")] impl<'a, A: ?Sized + UncheckedAnyExt> Iterator for Drain<'a, A> { type Item = Box; #[inline] fn next(&mut self) -> Option> { self.inner.next().map(|x| x.1) } #[inline] fn size_hint(&self) -> (usize, Option) { 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() } } @@ -180,7 +156,6 @@ impl RawMap { /// /// Keeps the allocated memory for reuse. #[inline] - #[cfg(feature = "unstable")] pub fn drain(&mut self) -> Drain { Drain { inner: self.inner.drain(), @@ -188,6 +163,7 @@ impl RawMap { } /// Gets the entry for the given type in the collection for in-place manipulation. + #[inline] pub fn entry(&mut self, key: TypeId) -> Entry { match self.inner.entry(key) { hash_map::Entry::Occupied(e) => Entry::Occupied(OccupiedEntry { @@ -203,6 +179,7 @@ impl RawMap { /// /// The key may be any borrowed form of the map's key type, but `Hash` and `Eq` on the borrowed /// form *must* match those for the key type. + #[inline] pub fn get(&self, k: &Q) -> Option<&A> where TypeId: Borrow, Q: Hash + Eq { self.inner.get(k).map(|x| &**x) @@ -212,6 +189,7 @@ impl RawMap { /// /// The key may be any borrowed form of the map's key type, but `Hash` and `Eq` on the borrowed /// form *must* match those for the key type. + #[inline] pub fn contains_key(&self, k: &Q) -> bool where TypeId: Borrow, Q: Hash + Eq { self.inner.contains_key(k) @@ -221,6 +199,7 @@ impl RawMap { /// /// The key may be any borrowed form of the map's key type, but `Hash` and `Eq` on the borrowed /// form *must* match those for the key type. + #[inline] pub fn get_mut(&mut self, k: &Q) -> Option<&mut A> where TypeId: Borrow, Q: Hash + Eq { self.inner.get_mut(k).map(|x| &mut **x) @@ -231,6 +210,7 @@ impl RawMap { /// /// It is the caller’s responsibility to ensure that the key corresponds with the type ID of /// the value. If they do not, memory safety may be violated. + #[inline] pub unsafe fn insert(&mut self, key: TypeId, value: Box) -> Option> { self.inner.insert(key, value) } @@ -240,6 +220,7 @@ impl RawMap { /// /// The key may be any borrowed form of the map's key type, but `Hash` and `Eq` on the borrowed /// form *must* match those for the key type. + #[inline] pub fn remove(&mut self, k: &Q) -> Option> where TypeId: Borrow, Q: Hash + Eq { self.inner.remove(k) @@ -250,13 +231,15 @@ impl RawMap { impl Index for RawMap where TypeId: Borrow, Q: Eq + Hash { type Output = A; - fn index<'a>(&'a self, index: Q) -> &'a A { + #[inline] + fn index(&self, index: Q) -> &A { self.get(&index).expect("no entry found for key") } } impl IndexMut for RawMap where TypeId: Borrow, Q: Eq + Hash { - fn index_mut<'a>(&'a mut self, index: Q) -> &'a mut A { + #[inline] + fn index_mut(&mut self, index: Q) -> &mut A { self.get_mut(&index).expect("no entry found for key") } } @@ -265,6 +248,7 @@ impl IntoIterator for RawMap { type Item = Box; type IntoIter = IntoIter; + #[inline] fn into_iter(self) -> IntoIter { IntoIter { inner: self.inner.into_iter(), @@ -296,6 +280,7 @@ impl<'a, A: ?Sized + UncheckedAnyExt> Entry<'a, A> { /// /// It is the caller’s responsibility to ensure that the key of the entry corresponds with /// the type ID of `value`. If they do not, memory safety may be violated. + #[inline] pub unsafe fn or_insert(self, default: Box) -> &'a mut A { match self { Entry::Occupied(inner) => inner.into_mut(), @@ -308,6 +293,7 @@ impl<'a, A: ?Sized + UncheckedAnyExt> Entry<'a, A> { /// /// It is the caller’s responsibility to ensure that the key of the entry corresponds with /// the type ID of `value`. If they do not, memory safety may be violated. + #[inline] pub unsafe fn or_insert_with Box>(self, default: F) -> &'a mut A { match self { Entry::Occupied(inner) => inner.into_mut(), @@ -318,17 +304,20 @@ impl<'a, A: ?Sized + UncheckedAnyExt> Entry<'a, A> { impl<'a, A: ?Sized + UncheckedAnyExt> OccupiedEntry<'a, A> { /// Gets a reference to the value in the entry. + #[inline] pub fn get(&self) -> &A { &**self.inner.get() } /// Gets a mutable reference to the value in the entry. + #[inline] pub fn get_mut(&mut self) -> &mut A { &mut **self.inner.get_mut() } /// Converts the OccupiedEntry into a mutable reference to the value in the entry /// with a lifetime bound to the collection itself. + #[inline] pub fn into_mut(self) -> &'a mut A { &mut **self.inner.into_mut() } @@ -337,11 +326,13 @@ impl<'a, A: ?Sized + UncheckedAnyExt> OccupiedEntry<'a, A> { /// /// It is the caller’s responsibility to ensure that the key of the entry corresponds with /// the type ID of `value`. If they do not, memory safety may be violated. + #[inline] pub unsafe fn insert(&mut self, value: Box) -> Box { self.inner.insert(value) } /// Takes the value out of the entry, and returns it. + #[inline] pub fn remove(self) -> Box { self.inner.remove() } @@ -353,6 +344,7 @@ impl<'a, A: ?Sized + UncheckedAnyExt> VacantEntry<'a, A> { /// /// It is the caller’s responsibility to ensure that the key of the entry corresponds with /// the type ID of `value`. If they do not, memory safety may be violated. + #[inline] pub unsafe fn insert(self, value: Box) -> &'a mut A { &mut **self.inner.insert(value) }