Struct SyncTypeMap

pub struct SyncTypeMap(/* private fields */);

Like TypeMap but with a Send + Sync bound.

Implementations

impl SyncTypeMap

pub fn new() -> Self

Creates an empty SyncTypeMap.

The map is initially created with a capacity of 0, so it will not allocate until it is first inserted into.

Examples

use static_type_map::SyncTypeMap;

let type_map = SyncTypeMap::new();

pub fn with_capacity(capacity: usize) -> Self

Creates an empty SyncTypeMap with the specified capacity.

The map will be able to hold at least capacity types without reallocating. If capacity is 0, the static type map will not allocate.

Examples

use static_type_map::SyncTypeMap;

let type_map = SyncTypeMap::with_capacity(10);

pub fn capacity(&self) -> usize

Returns the number of types the map can hold without reallocating.

This number is a lower bound; the map might be able to hold more, but it is guaranteed to be able to hold at least so many.

Examples

use static_type_map::SyncTypeMap;

let type_map = SyncTypeMap::with_capacity(100);
assert!(type_map.capacity() >= 100);

pub fn is_empty(&self) -> bool

Returns true if the map contains no instances of any type.

Examples

use static_type_map::SyncTypeMap;

let type_map = SyncTypeMap::new();
assert!(type_map.is_empty());

pub fn len(&self) -> usize

Returns the number of types in the map.

Examples

use static_type_map::SyncTypeMap;

let mut type_map = SyncTypeMap::new();
assert_eq!(type_map.len(), 0);
type_map.insert("a");
assert_eq!(type_map.len(), 1);

pub fn clear(&mut self)

Clears the map. Keep allocated memory for reuse.

Examples

use static_type_map::SyncTypeMap;

let mut type_map = SyncTypeMap::new();
type_map.insert("a");
type_map.clear();
assert!(type_map.is_empty());

pub fn reserve(&mut self, additional: usize)

Reserves capacity for at least additional more types to be inserted in the map. The collection may reserve more space to avoid frequent reallocations.

Panics

Panics if the new allocation size overflows usize.

Examples

use static_type_map::SyncTypeMap;

let mut type_map = SyncTypeMap::new();
assert_eq!(type_map.capacity(), 0);
type_map.reserve(10);
assert!(type_map.capacity() >= 10);

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of the map as much as possible. It will drop down as much as possible while mainting the internal rules and possibly leaving some space in accordance with the resize policy.

Examples

use static_type_map::SyncTypeMap;

let mut type_map = SyncTypeMap::with_capacity(100);
assert!(type_map.capacity() >= 0);
type_map.insert("a");
type_map.insert(true);
assert!(type_map.capacity() >= 2);

pub fn contains<T>(&self) -> bool

where T: Any,

Returns true if the map contains an instance of T.

Examples

use static_type_map::SyncTypeMap;

let mut type_map = SyncTypeMap::new();
type_map.insert("a");
assert!(type_map.contains::<&str>());

pub fn get<T>(&self) -> Option<&T>

where T: Any + Send + Sync,

Returns a reference to an instance of T.

If the map does not have an instance of T, None is returned.

Examples

use static_type_map::SyncTypeMap;

let mut type_map = SyncTypeMap::new();
type_map.insert("a");
assert_eq!(type_map.get::<&str>(), Some(&"a"));
assert_eq!(type_map.get::<bool>(), None);

pub fn get_mut<T>(&mut self) -> Option<&mut T>

where T: Any + Send + Sync,

Returns a mutable reference to an instance of T.

If the map does not have an instance of T, None is returned.

Examples

use static_type_map::SyncTypeMap;

let mut type_map = SyncTypeMap::new();
type_map.insert("a");
if let Some(x) = type_map.get_mut::<&str>() {
    *x = "b";
}
assert_eq!(type_map.get::<&str>(), Some(&"b"));

pub fn insert<T>(&mut self, value: T) -> Option<T>

where T: Any + Send + Sync,

Insert an instance of type T into the map.

If the map did not have this type present, None is returned.

Examples

use static_type_map::SyncTypeMap;

let mut type_map = SyncTypeMap::new();
assert_eq!(type_map.insert("a"), None);
assert_eq!(type_map.insert("b"), Some("a"));

pub fn remove<T>(&mut self) -> Option<T>

where T: Any + Send + Sync,

Remove and return an instance of type T from the map.

If the map did not have this type present, None is returned.

Examples

use static_type_map::SyncTypeMap;

let mut type_map = SyncTypeMap::new();
type_map.insert("a");
assert_eq!(type_map.remove::<&str>(), Some("a"));

Trait Implementations

impl Debug for SyncTypeMap

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for SyncTypeMap

fn default() -> SyncTypeMap

Returns the “default value” for a type.