#![warn(missing_docs, unused_results)]
-use std::any::TypeId;
+use std::any::{Any, TypeId};
use std::marker::PhantomData;
use raw::RawMap;
-use any::{UncheckedAnyExt, IntoBox, Any};
+use any::{UncheckedAnyExt, IntoBox};
+pub use any::CloneAny;
macro_rules! impl_common_methods {
(
self.$field.clear()
}
}
+
+ impl<A: ?Sized + UncheckedAnyExt> Default for $t<A> {
+ #[inline]
+ fn default() -> $t<A> {
+ $t::new()
+ }
+ }
}
}
-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 `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<Any + Send>`) to add those bounds.
+/// - You can add on `+ Send` or `+ Send + Sync` (e.g. `Map<dyn Any + Send>`) to add those bounds.
///
/// ```rust
/// # use anymap::AnyMap;
///
/// Values containing non-static references are not permitted.
#[derive(Debug)]
-pub struct Map<A: ?Sized + UncheckedAnyExt = Any> {
+pub struct Map<A: ?Sized + UncheckedAnyExt = dyn Any> {
raw: RawMap<A>,
}
/// 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<Any>;
+pub type AnyMap = Map<dyn Any>;
impl_common_methods! {
field: 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);
}
test_entry!(test_entry_any, AnyMap);
- test_entry!(test_entry_cloneany, Map<CloneAny>);
+ test_entry!(test_entry_cloneany, Map<dyn CloneAny>);
+
+ #[test]
+ fn test_default() {
+ let map: AnyMap = Default::default();
+ assert_eq!(map.len(), 0);
+ }
#[test]
fn test_clone() {
- let mut map: Map<CloneAny> = Map::new();
+ let mut map: Map<dyn CloneAny> = Map::new();
let _ = map.insert(A(1));
let _ = map.insert(B(2));
let _ = map.insert(D(3));
fn assert_sync<T: Sync>() { }
fn assert_clone<T: Clone>() { }
fn assert_debug<T: ::std::fmt::Debug>() { }
- assert_send::<Map<Any + Send>>();
- assert_send::<Map<Any + Send + Sync>>();
- assert_sync::<Map<Any + Sync>>();
- assert_sync::<Map<Any + Send + Sync>>();
- assert_debug::<Map<Any>>();
- assert_debug::<Map<Any + Send>>();
- assert_debug::<Map<Any + Sync>>();
- assert_debug::<Map<Any + Send + Sync>>();
- assert_send::<Map<CloneAny + Send>>();
- assert_send::<Map<CloneAny + Send + Sync>>();
- assert_sync::<Map<CloneAny + Sync>>();
- assert_sync::<Map<CloneAny + Send + Sync>>();
- assert_clone::<Map<CloneAny + Send>>();
- assert_clone::<Map<CloneAny + Send + Sync>>();
- assert_clone::<Map<CloneAny + Sync>>();
- assert_clone::<Map<CloneAny + Send + Sync>>();
- assert_debug::<Map<CloneAny>>();
- assert_debug::<Map<CloneAny + Send>>();
- assert_debug::<Map<CloneAny + Sync>>();
- assert_debug::<Map<CloneAny + Send + Sync>>();
+ assert_send::<Map<dyn Any + Send>>();
+ assert_send::<Map<dyn Any + Send + Sync>>();
+ assert_sync::<Map<dyn Any + Send + Sync>>();
+ assert_debug::<Map<dyn Any>>();
+ assert_debug::<Map<dyn Any + Send>>();
+ 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 + Send + Sync>>();
+ assert_clone::<Map<dyn CloneAny + Send>>();
+ assert_clone::<Map<dyn CloneAny + Send + Sync>>();
+ assert_clone::<Map<dyn CloneAny + Send + Sync>>();
+ assert_debug::<Map<dyn CloneAny>>();
+ assert_debug::<Map<dyn CloneAny + Send>>();
+ assert_debug::<Map<dyn CloneAny + Send + Sync>>();
}
}