+#[derive(Debug)]
+pub struct Map<A: ?Sized + Downcast = dyn Any> {
+ raw: RawMap<A>,
+}
+
+// #[derive(Clone)] would want A to implement Clone, but in reality it’s only Box<A> that can.
+impl<A: ?Sized + Downcast> Clone for Map<A> where Box<A>: Clone {
+ #[inline]
+ fn clone(&self) -> Map<A> {
+ Map {
+ raw: self.raw.clone(),
+ }
+ }
+}
+
+/// The most common type of `Map`: just using `Any`; <code>[Map]<dyn [Any]></code>.
+///
+/// Why is this a separate type alias rather than a default value for `Map<A>`? `Map::new()`
+/// doesn’t seem to be happy to infer that it should go with the default value.
+/// It’s a bit sad, really. Ah well, I guess this approach will do.
+pub type AnyMap = Map<dyn Any>;
+
+impl<A: ?Sized + Downcast> Default for Map<A> {
+ #[inline]
+ fn default() -> Map<A> {
+ Map::new()
+ }
+}
+
+impl<A: ?Sized + Downcast> Map<A> {
+ /// Create an empty collection.
+ #[inline]
+ pub fn new() -> Map<A> {
+ Map {
+ raw: RawMap::with_hasher(Default::default()),
+ }
+ }
+
+ /// Creates an empty collection with the given initial capacity.
+ #[inline]
+ pub fn with_capacity(capacity: usize) -> Map<A> {
+ Map {
+ raw: RawMap::with_capacity_and_hasher(capacity, Default::default()),
+ }
+ }
+
+ /// Returns the number of elements the collection can hold without reallocating.
+ #[inline]
+ pub fn capacity(&self) -> usize {
+ self.raw.capacity()
+ }
+
+ /// Reserves capacity for at least `additional` more elements to be inserted
+ /// in the collection. The collection may reserve more space to avoid
+ /// frequent reallocations.
+ ///
+ /// # Panics
+ ///
+ /// Panics if the new allocation size overflows `usize`.
+ #[inline]
+ pub fn reserve(&mut self, additional: usize) {
+ self.raw.reserve(additional)
+ }
+
+ /// Shrinks the capacity of the collection as much as possible. It will drop
+ /// down as much as possible while maintaining the internal rules
+ /// and possibly leaving some space in accordance with the resize policy.
+ #[inline]
+ pub fn shrink_to_fit(&mut self) {
+ self.raw.shrink_to_fit()
+ }
+
+ // Additional stable methods (as of 1.60.0-nightly) that could be added:
+ // try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError> (1.57.0)
+ // shrink_to(&mut self, min_capacity: usize) (1.56.0)
+
+ /// Returns the number of items in the collection.
+ #[inline]
+ pub fn len(&self) -> usize {
+ self.raw.len()
+ }
+
+ /// Returns true if there are no items in the collection.
+ #[inline]
+ pub fn is_empty(&self) -> bool {
+ self.raw.is_empty()
+ }
+
+ /// Removes all items from the collection. Keeps the allocated memory for reuse.
+ #[inline]
+ pub fn clear(&mut self) {
+ self.raw.clear()
+ }
+
+ /// Returns a reference to the value stored in the collection for the type `T`, if it exists.
+ #[inline]
+ pub fn get<T: IntoBox<A>>(&self) -> Option<&T> {
+ self.raw.get(&TypeId::of::<T>())
+ .map(|any| unsafe { any.downcast_ref_unchecked::<T>() })
+ }
+
+ /// Returns a mutable reference to the value stored in the collection for the type `T`,
+ /// if it exists.
+ #[inline]
+ pub fn get_mut<T: IntoBox<A>>(&mut self) -> Option<&mut T> {
+ self.raw.get_mut(&TypeId::of::<T>())
+ .map(|any| unsafe { any.downcast_mut_unchecked::<T>() })
+ }
+
+ /// 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<T: IntoBox<A>>(&mut self, value: T) -> Option<T> {
+ self.raw.insert(TypeId::of::<T>(), value.into_box())
+ .map(|any| unsafe { *any.downcast_unchecked::<T>() })
+ }
+
+ // rustc 1.60.0-nightly has another method try_insert that would be nice to add when stable.
+
+ /// Removes the `T` value from the collection,
+ /// returning it if there was one or `None` if there was not.
+ #[inline]
+ pub fn remove<T: IntoBox<A>>(&mut self) -> Option<T> {
+ self.raw.remove(&TypeId::of::<T>())
+ .map(|any| *unsafe { any.downcast_unchecked::<T>() })
+ }
+
+ /// Returns true if the collection contains a value of type `T`.
+ #[inline]
+ pub fn contains<T: IntoBox<A>>(&self) -> bool {
+ self.raw.contains_key(&TypeId::of::<T>())
+ }
+
+ /// Gets the entry for the given type in the collection for in-place manipulation
+ #[inline]
+ pub fn entry<T: IntoBox<A>>(&mut self) -> Entry<A, T> {
+ match self.raw.entry(TypeId::of::<T>()) {
+ raw_hash_map::Entry::Occupied(e) => Entry::Occupied(OccupiedEntry {
+ inner: e,
+ type_: PhantomData,
+ }),
+ raw_hash_map::Entry::Vacant(e) => Entry::Vacant(VacantEntry {
+ inner: e,
+ type_: PhantomData,
+ }),
+ }
+ }
+
+ /// Get access to the raw hash map that backs this.
+ ///
+ /// This will seldom be useful, but it’s conceivable that you could wish to iterate over all
+ /// the items in the collection, and this lets you do that.
+ ///
+ /// To improve compatibility with Cargo features, interact with this map through the names
+ /// [`anymap::RawMap`][RawMap] and [`anymap::raw_hash_map`][raw_hash_map], rather than through
+ /// `std::collections::{HashMap, hash_map}` or `hashbrown::{HashMap, hash_map}`, for anything
+ /// beyond self methods. Otherwise, if you use std and another crate in the tree enables
+ /// hashbrown, your code will break.
+ #[inline]
+ pub fn as_raw(&self) -> &RawMap<A> {
+ &self.raw
+ }
+
+ /// Get mutable access to the raw hash map that backs this.
+ ///
+ /// This will seldom be useful, but it’s conceivable that you could wish to iterate over all
+ /// the items in the collection mutably, or drain or something, or *possibly* even batch
+ /// insert, and this lets you do that.
+ ///
+ /// To improve compatibility with Cargo features, interact with this map through the names
+ /// [`anymap::RawMap`][RawMap] and [`anymap::raw_hash_map`][raw_hash_map], rather than through
+ /// `std::collections::{HashMap, hash_map}` or `hashbrown::{HashMap, hash_map}`, for anything
+ /// beyond self methods. Otherwise, if you use std and another crate in the tree enables
+ /// hashbrown, your code will break.
+ ///
+ /// # Safety
+ ///
+ /// If you insert any values to the raw map, the key (a `TypeId`) must match the value’s type,
+ /// or *undefined behaviour* will occur when you access those values.
+ ///
+ /// (*Removing* entries is perfectly safe.)
+ #[inline]
+ pub unsafe fn as_raw_mut(&mut self) -> &mut RawMap<A> {
+ &mut self.raw
+ }
+
+ /// Convert this into the raw hash map that backs this.
+ ///
+ /// This will seldom be useful, but it’s conceivable that you could wish to consume all the
+ /// items in the collection and do *something* with some or all of them, and this lets you do
+ /// that, without the `unsafe` that `.as_raw_mut().drain()` would require.
+ ///
+ /// To improve compatibility with Cargo features, interact with this map through the names
+ /// [`anymap::RawMap`][RawMap] and [`anymap::raw_hash_map`][raw_hash_map], rather than through
+ /// `std::collections::{HashMap, hash_map}` or `hashbrown::{HashMap, hash_map}`, for anything
+ /// beyond self methods. Otherwise, if you use std and another crate in the tree enables
+ /// hashbrown, your code will break.
+ #[inline]
+ pub fn into_raw(self) -> RawMap<A> {
+ self.raw
+ }
+
+ /// Construct a map from a collection of raw values.
+ ///
+ /// You know what? I can’t immediately think of any legitimate use for this, especially because
+ /// of the requirement of the `BuildHasherDefault<TypeIdHasher>` generic in the map.
+ ///
+ /// Perhaps this will be most practical as `unsafe { Map::from_raw(iter.collect()) }`, iter
+ /// being an iterator over `(TypeId, Box<A>)` pairs. Eh, this method provides symmetry with
+ /// `into_raw`, so I don’t care if literally no one ever uses it. I’m not even going to write a
+ /// test for it, it’s so trivial.
+ ///
+ /// To improve compatibility with Cargo features, interact with this map through the names
+ /// [`anymap::RawMap`][RawMap] and [`anymap::raw_hash_map`][raw_hash_map], rather than through
+ /// `std::collections::{HashMap, hash_map}` or `hashbrown::{HashMap, hash_map}`, for anything
+ /// beyond self methods. Otherwise, if you use std and another crate in the tree enables
+ /// hashbrown, your code will break.
+ ///
+ /// # Safety
+ ///
+ /// For all entries in the raw map, the key (a `TypeId`) must match the value’s type,
+ /// or *undefined behaviour* will occur when you access that entry.
+ #[inline]
+ pub unsafe fn from_raw(raw: RawMap<A>) -> Map<A> {
+ Self { raw }
+ }
+}
+
+impl<A: ?Sized + Downcast> Extend<Box<A>> for Map<A> {
+ #[inline]
+ fn extend<T: IntoIterator<Item = Box<A>>>(&mut self, iter: T) {
+ for item in iter {
+ let _ = self.raw.insert(Downcast::type_id(&*item), item);
+ }
+ }
+}
+
+/// A view into a single occupied location in an `Map`.
+pub struct OccupiedEntry<'a, A: ?Sized + Downcast, V: 'a> {
+ #[cfg(all(feature = "std", not(feature = "hashbrown")))]
+ inner: raw_hash_map::OccupiedEntry<'a, TypeId, Box<A>>,
+ #[cfg(feature = "hashbrown")]
+ inner: raw_hash_map::OccupiedEntry<'a, TypeId, Box<A>, BuildHasherDefault<TypeIdHasher>>,
+ type_: PhantomData<V>,