-//! This crate provides the `AnyMap` type, a safe and convenient store for one value of each type.
+//! This crate provides a safe and convenient store for one value of each type.
+//!
+//! Your starting point is [`Map`]. It has an example.
#![warn(missing_docs, unused_results)]
-use std::any::TypeId;
-use std::marker::PhantomData;
+use core::any::{Any, TypeId};
+use core::marker::PhantomData;
use raw::RawMap;
-use any::{UncheckedAnyExt, IntoBox, Any};
+use any::{UncheckedAnyExt, IntoBox};
+pub use any::CloneAny;
macro_rules! impl_common_methods {
(
}
}
-pub mod any;
+mod any;
pub mod raw;
/// A collection containing zero or one values for any given type and allowing convenient,
/// type-safe access to those values.
///
/// The type parameter `A` allows you to use a different value type; normally you will want it to
-/// be `anymap::any::Any`, but there are other choices:
+/// be `core::any::Any` (also known as `std::any::Any`), but there are other choices:
///
-/// - If you want the entire map to be cloneable, use `CloneAny` instead of `Any`.
-/// - You can add on `+ Send` and/or `+ Sync` (e.g. `Map<dyn Any + Send>`) to add those bounds.
+/// - If you want the entire map to be cloneable, use `CloneAny` instead of `Any`; with that, you
+/// can only add types that implement `Clone` to the map.
+/// - You can add on `+ Send` or `+ Send + Sync` (e.g. `Map<dyn Any + Send>`) to add those auto
+/// traits.
+///
+/// Cumulatively, there are thus six forms of map:
+///
+/// - <code>[Map]<dyn [core::any::Any]></code>, also spelled [`AnyMap`] for convenience.
+/// - <code>[Map]<dyn [core::any::Any] + Send></code>
+/// - <code>[Map]<dyn [core::any::Any] + Send + Sync></code>
+/// - <code>[Map]<dyn [CloneAny]></code>
+/// - <code>[Map]<dyn [CloneAny] + Send></code>
+/// - <code>[Map]<dyn [CloneAny] + Send + Sync></code>
+///
+/// ## Example
+///
+/// (Here using the [`AnyMap`] convenience alias; the first line could use
+/// <code>[anymap::Map][Map]::<[core::any::Any]>::new()</code> instead if desired.)
///
/// ```rust
-/// # use anymap::AnyMap;
-/// let mut data = AnyMap::new();
+/// let mut data = anymap::AnyMap::new();
/// assert_eq!(data.get(), None::<&i32>);
/// data.insert(42i32);
/// assert_eq!(data.get(), Some(&42i32));
}
}
-/// The most common type of `Map`: just using `Any`.
+/// 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.
}
}
-impl<A: ?Sized + UncheckedAnyExt>
Into<RawMap<A>> for Map<A> {
+impl<A: ?Sized + UncheckedAnyExt>
From<Map<A>> for RawMap<A> {
#[inline]
- fn
into(self) -> RawMap<A> {
- self.raw
+ fn
from(map: Map<A>) -> RawMap<A> {
+ map.raw
}
}
#[cfg(test)]
mod tests {
- use {Map, AnyMap, Entry};
- use any::{Any, CloneAny};
+ use super::*;
#[derive(Clone, Debug, PartialEq)] struct A(i32);
#[derive(Clone, Debug, PartialEq)] struct B(i32);
fn assert_send<T: Send>() { }
fn assert_sync<T: Sync>() { }
fn assert_clone<T: Clone>() { }
- fn assert_debug<T: ::std::fmt::Debug>() { }
+ fn assert_debug<T: ::core::fmt::Debug>() { }
assert_send::<Map<dyn Any + Send>>();
assert_send::<Map<dyn Any + Send + Sync>>();
- assert_sync::<Map<dyn Any + Sync>>();
assert_sync::<Map<dyn Any + Send + Sync>>();
assert_debug::<Map<dyn Any>>();
assert_debug::<Map<dyn Any + Send>>();
- assert_debug::<Map<dyn Any + Sync>>();
assert_debug::<Map<dyn Any + Send + Sync>>();
assert_send::<Map<dyn CloneAny + Send>>();
assert_send::<Map<dyn CloneAny + Send + Sync>>();
- assert_sync::<Map<dyn CloneAny + Sync>>();
assert_sync::<Map<dyn CloneAny + Send + Sync>>();
assert_clone::<Map<dyn CloneAny + Send>>();
assert_clone::<Map<dyn CloneAny + Send + Sync>>();
- assert_clone::<Map<dyn CloneAny + Sync>>();
assert_clone::<Map<dyn CloneAny + Send + Sync>>();
assert_debug::<Map<dyn CloneAny>>();
assert_debug::<Map<dyn CloneAny + Send>>();
- assert_debug::<Map<dyn CloneAny + Sync>>();
assert_debug::<Map<dyn CloneAny + Send + Sync>>();
}
}