X-Git-Url: https://git.chrismorgan.info/anymap/blobdiff_plain/839a6bc6e842b2ae6bbaf4b945ff6f2fbbca1785..f5e887ef634cfcd5c354307ba105c616f4222c3d:/src/lib.rs diff --git a/src/lib.rs b/src/lib.rs index 5f21a94..bcd5c23 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,11 +1,7 @@ //! This crate provides the `AnyMap` type, a safe and convenient store for one value of each type. -#![cfg_attr(all(feature = "bench", test), feature(test))] #![warn(missing_docs, unused_results)] -#[cfg(all(feature = "bench", test))] -extern crate test; - use std::any::TypeId; use std::marker::PhantomData; @@ -123,6 +119,7 @@ pub struct Map { // #[derive(Clone)] would want A to implement Clone, but in reality it’s only Box that can. impl Clone for Map where Box: Clone { + #[inline] fn clone(&self) -> Map { Map { raw: self.raw.clone(), @@ -145,6 +142,7 @@ impl_common_methods! { impl Map { /// Returns a reference to the value stored in the collection for the type `T`, if it exists. + #[inline] pub fn get>(&self) -> Option<&T> { self.raw.get(&TypeId::of::()) .map(|any| unsafe { any.downcast_ref_unchecked::() }) @@ -152,6 +150,7 @@ impl Map { /// Returns a mutable reference to the value stored in the collection for the type `T`, /// if it exists. + #[inline] pub fn get_mut>(&mut self) -> Option<&mut T> { self.raw.get_mut(&TypeId::of::()) .map(|any| unsafe { any.downcast_mut_unchecked::() }) @@ -160,6 +159,7 @@ impl Map { /// Sets the value stored in the collection for the type `T`. /// If the collection already had a value of type `T`, that value is returned. /// Otherwise, `None` is returned. + #[inline] pub fn insert>(&mut self, value: T) -> Option { unsafe { self.raw.insert(TypeId::of::(), value.into_box()) @@ -169,6 +169,7 @@ impl Map { /// Removes the `T` value from the collection, /// returning it if there was one or `None` if there was not. + #[inline] pub fn remove>(&mut self) -> Option { self.raw.remove(&TypeId::of::()) .map(|any| *unsafe { any.downcast_unchecked::() }) @@ -181,6 +182,7 @@ impl Map { } /// Gets the entry for the given type in the collection for in-place manipulation + #[inline] pub fn entry>(&mut self) -> Entry { match self.raw.entry(TypeId::of::()) { raw::Entry::Occupied(e) => Entry::Occupied(OccupiedEntry { @@ -196,18 +198,21 @@ impl Map { } impl AsRef> for Map { + #[inline] fn as_ref(&self) -> &RawMap { &self.raw } } impl AsMut> for Map { + #[inline] fn as_mut(&mut self) -> &mut RawMap { &mut self.raw } } impl Into> for Map { + #[inline] fn into(self) -> RawMap { self.raw } @@ -236,6 +241,7 @@ pub enum Entry<'a, A: ?Sized + UncheckedAnyExt, V: 'a> { impl<'a, A: ?Sized + UncheckedAnyExt, V: IntoBox> Entry<'a, A, V> { /// Ensures a value is in the entry by inserting the default if empty, and returns /// a mutable reference to the value in the entry. + #[inline] pub fn or_insert(self, default: V) -> &'a mut V { match self { Entry::Occupied(inner) => inner.into_mut(), @@ -245,6 +251,7 @@ impl<'a, A: ?Sized + UncheckedAnyExt, V: IntoBox> Entry<'a, A, V> { /// Ensures a value is in the entry by inserting the result of the default function if empty, /// and returns a mutable reference to the value in the entry. + #[inline] pub fn or_insert_with V>(self, default: F) -> &'a mut V { match self { Entry::Occupied(inner) => inner.into_mut(), @@ -255,27 +262,32 @@ impl<'a, A: ?Sized + UncheckedAnyExt, V: IntoBox> Entry<'a, A, V> { impl<'a, A: ?Sized + UncheckedAnyExt, V: IntoBox> OccupiedEntry<'a, A, V> { /// Gets a reference to the value in the entry + #[inline] pub fn get(&self) -> &V { unsafe { self.inner.get().downcast_ref_unchecked() } } /// Gets a mutable reference to the value in the entry + #[inline] pub fn get_mut(&mut self) -> &mut V { unsafe { self.inner.get_mut().downcast_mut_unchecked() } } /// 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 V { unsafe { self.inner.into_mut().downcast_mut_unchecked() } } /// Sets the value of the entry, and returns the entry's old value + #[inline] pub fn insert(&mut self, value: V) -> V { unsafe { *self.inner.insert(value.into_box()).downcast_unchecked() } } /// Takes the value out of the entry, and returns it + #[inline] pub fn remove(self) -> V { unsafe { *self.inner.remove().downcast_unchecked() } } @@ -284,46 +296,12 @@ impl<'a, A: ?Sized + UncheckedAnyExt, V: IntoBox> OccupiedEntry<'a, A, V> { impl<'a, A: ?Sized + UncheckedAnyExt, V: IntoBox> VacantEntry<'a, A, V> { /// Sets the value of the entry with the VacantEntry's key, /// and returns a mutable reference to it + #[inline] pub fn insert(self, value: V) -> &'a mut V { unsafe { self.inner.insert(value.into_box()).downcast_mut_unchecked() } } } -#[cfg(feature = "bench")] -#[bench] -fn bench_insertion(b: &mut ::test::Bencher) { - b.iter(|| { - let mut data = AnyMap::new(); - for _ in 0..100 { - let _ = data.insert(42); - } - }) -} - -#[cfg(feature = "bench")] -#[bench] -fn bench_get_missing(b: &mut ::test::Bencher) { - b.iter(|| { - let data = AnyMap::new(); - for _ in 0..100 { - assert_eq!(data.get(), None::<&i32>); - } - }) -} - -#[cfg(feature = "bench")] -#[bench] -fn bench_get_present(b: &mut ::test::Bencher) { - b.iter(|| { - let mut data = AnyMap::new(); - let _ = data.insert(42); - // These inner loops are a feeble attempt to drown the other factors. - for _ in 0..100 { - assert_eq!(data.get(), Some(&42)); - } - }) -} - #[cfg(test)] mod tests { use {Map, AnyMap, Entry};