X-Git-Url: https://git.chrismorgan.info/anymap/blobdiff_plain/f38113a9cfc9aa6f29224ae0020f0fd3bffe2818..bf29e608d91175d0fca2108fd1b5d75596a4a796:/src/raw.rs?ds=sidebyside diff --git a/src/raw.rs b/src/raw.rs index 3645429..aa3d6dc 100644 --- a/src/raw.rs +++ b/src/raw.rs @@ -7,6 +7,7 @@ use std::borrow::Borrow; use std::collections::hash_map::{self, HashMap}; use std::hash::Hash; use std::hash::{Hasher, BuildHasherDefault}; +#[cfg(test)] use std::mem; use std::ops::{Index, IndexMut}; use std::ptr; @@ -24,7 +25,7 @@ impl Hasher for TypeIdHasher { // This expects to receive one and exactly one 64-bit value debug_assert!(bytes.len() == 8); unsafe { - ptr::copy_nonoverlapping(mem::transmute(&bytes[0]), &mut self.value, 1) + ptr::copy_nonoverlapping(&bytes[0] as *const u8 as *const u64, &mut self.value, 1) } } @@ -55,12 +56,13 @@ fn type_id_hasher() { /// contents of an `Map`. However, because you will then be dealing with `Any` trait objects, it /// doesn’t tend to be so very useful. Still, if you need it, it’s here. #[derive(Debug)] -pub struct RawMap { +pub struct RawMap { 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(), @@ -68,12 +70,6 @@ impl Clone for RawMap where Box: Clone { } } -impl Default for RawMap { - fn default() -> RawMap { - RawMap::new() - } -} - impl_common_methods! { field: RawMap.inner; new() => HashMap::with_hasher(Default::default()); @@ -167,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 { @@ -182,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) @@ -191,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) @@ -200,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) @@ -210,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) } @@ -219,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) @@ -229,12 +231,14 @@ impl RawMap { impl Index for RawMap where TypeId: Borrow, Q: Eq + Hash { type Output = 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 { + #[inline] fn index_mut(&mut self, index: Q) -> &mut A { self.get_mut(&index).expect("no entry found for key") } @@ -244,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(), @@ -275,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(), @@ -287,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(), @@ -297,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() } @@ -316,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() } @@ -332,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) }