Struct CustomField 

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

Implementations

impl CustomField

pub fn new() -> Self

Methods from Deref<Target = TypedDashMap<(), SyncAnyBounds, SyncAnyBounds, FxBuildHasher>>

pub fn insert<K>( &self, key: K, value: <K as TypedMapKey<Marker>>::Value, ) -> Option<<K as TypedMapKey<Marker>>::Value>

where K: 'static + TypedMapKey<Marker>, KB: HasBounds<K>, VB: HasBounds<<K as TypedMapKey<Marker>>::Value>,

Inserts a key and a value into the map.

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

If the map did have this key present, the value is updated, and old value is returned.

Examples

use typedmap::TypedDashMap;
use typedmap::TypedMapKey;

#[derive(Debug, Hash, PartialEq, Eq)]
struct Key(usize);

impl TypedMapKey for Key {
    type Value = usize;
}

let mut map: TypedDashMap = TypedDashMap::with_capacity(10);
assert!(map.insert(Key(3), 4).is_none());
assert_eq!(map.insert(Key(3), 5), Some(4));
assert_eq!(*map.get(&Key(3)).unwrap(), 5);

pub fn get<K>(&self, key: &K) -> Option<Ref<'_, Marker, K, KB, VB>>

where K: 'static + TypedMapKey<Marker>, KB: HasBounds<K>, VB: HasBounds<<K as TypedMapKey<Marker>>::Value>,

Get the entry of a key if it exists in the map.

Examples

use typedmap::TypedDashMap;
use typedmap::TypedMapKey;

#[derive(Hash, PartialEq, Eq)]
struct Key(usize);

impl TypedMapKey for Key {
    type Value = usize;
}

let mut map: TypedDashMap = TypedDashMap::with_capacity(10);
assert!(map.get(&Key(3)).is_none());
map.insert(Key(3), 4);
assert_eq!(*map.get(&Key(3)).unwrap(), 4);

pub fn get_mut<K>(&self, key: &K) -> Option<RefMut<'_, Marker, K, KB, VB>>

where K: 'static + TypedMapKey<Marker>, KB: HasBounds<K>, VB: HasBounds<<K as TypedMapKey<Marker>>::Value>,

Get mutable entry of a key if it exists in the map.

Examples

use typedmap::TypedDashMap;
use typedmap::TypedMapKey;

#[derive(Hash, PartialEq, Eq)]
struct Key(usize);

impl TypedMapKey for Key {
    type Value = usize;
}

let mut map: TypedDashMap = TypedDashMap::with_capacity(10);
assert!(map.get_mut(&Key(3)).is_none());
map.insert(Key(3), 4);
*map.get_mut(&Key(3)).unwrap() = 5;
assert_eq!(*map.get(&Key(3)).unwrap().value(), 5);

pub fn contains_key<K>(&self, key: &K) -> bool

where K: 'static + TypedMapKey<Marker>, KB: HasBounds<K>,

Check if the map contains a specific key.

Examples

use typedmap::TypedDashMap;
use typedmap::TypedMapKey;

#[derive(Hash, PartialEq, Eq)]
struct Key(usize);

impl TypedMapKey for Key {
    type Value = usize;
}

let mut map: TypedDashMap = TypedDashMap::with_capacity(10);
assert!(!map.contains_key(&Key(3)));
map.insert(Key(3), 4);
assert!(map.contains_key(&Key(3)));

pub fn remove<K>( &self, key: &K, ) -> Option<(K, <K as TypedMapKey<Marker>>::Value)>

where K: 'static + TypedMapKey<Marker>, KB: HasBounds<K>, VB: HasBounds<<K as TypedMapKey<Marker>>::Value>,

Removes an entry from the map.

Returns both key and value if the key existed and the entry was removed. Otherwise returns None.

Examples

use typedmap::TypedDashMap;
use typedmap::TypedMapKey;

#[derive(Debug, Hash, PartialEq, Eq)]
struct Key(usize);

impl TypedMapKey for Key {
    type Value = usize;
}

let mut map: TypedDashMap = TypedDashMap::with_capacity(10);
assert!(map.remove(&Key(3)).is_none());
map.insert(Key(3), 4);
assert!(map.contains_key(&Key(3)));
assert_eq!(map.remove(&Key(3)), Some((Key(3), 4)));
assert!(!map.contains_key(&Key(3)));

pub fn remove_if<K>( &self, key: &K, f: impl FnOnce(&K, &<K as TypedMapKey<Marker>>::Value) -> bool, ) -> Option<(K, <K as TypedMapKey<Marker>>::Value)>

where K: 'static + TypedMapKey<Marker>, KB: HasBounds<K>, VB: HasBounds<<K as TypedMapKey<Marker>>::Value>,

Removes an entry from the map the provided conditional function returned true.

Returns both key and value if the key existed and the entry was removed. Otherwise returns None.

Examples

use typedmap::TypedDashMap;
use typedmap::TypedMapKey;

#[derive(Debug, Hash, PartialEq, Eq)]
struct Key(usize);

impl TypedMapKey for Key {
    type Value = usize;
}

let mut map: TypedDashMap = TypedDashMap::with_capacity(10);
assert!(map.remove(&Key(3)).is_none());
map.insert(Key(3), 4);
assert!(map.contains_key(&Key(3)));
assert_eq!(map.remove_if(&Key(3), |k, v| false), None);
assert!(map.contains_key(&Key(3)));
assert_eq!(map.remove_if(&Key(3), |k, v| true), Some((Key(3), 4)));
assert!(!map.contains_key(&Key(3)));

pub fn len(&self) -> usize

Get the amount of entries in the map.

Examples

use typedmap::TypedDashMap;
use typedmap::TypedMapKey;

#[derive(Hash, PartialEq, Eq, Debug)]
struct Key(usize);

impl TypedMapKey for Key {
    type Value = usize;
}

let mut map: TypedDashMap = TypedDashMap::with_capacity(10);
assert_eq!(map.len(), 0);
map.insert(Key(3), 4);
assert_eq!(map.len(), 1);

pub fn is_empty(&self) -> bool

Returns true if the map contains no elements.

Examples

use typedmap::TypedDashMap;
use typedmap::TypedMapKey;

#[derive(Hash, PartialEq, Eq)]
struct Key(usize);

impl TypedMapKey for Key {
    type Value = f32;
}

let mut map: TypedDashMap = TypedDashMap::with_capacity(10);
assert!(map.is_empty());
map.insert(Key(3), 4.0);
assert!(!map.is_empty());

pub fn clear(&self)

Clears the map, removing all key-value pairs.

Examples:

use typedmap::TypedDashMap;
use typedmap::TypedMapKey;

#[derive(Hash, PartialEq, Eq)]
struct Key(usize);

impl TypedMapKey for Key {
    type Value = f32;
}

let mut map: TypedDashMap = TypedDashMap::new();
map.insert(Key(3), 4.0);
map.clear();
assert!(map.get(&Key(3)).is_none())
// assert!(map.is_empty()); // for some reason this fails

pub fn iter(&self) -> Iter<'_, Marker, KB, VB, S>

An iterator visiting all key-value pairs in arbitrary order.

Examples

use typedmap::TypedDashMap;
use typedmap::TypedMapKey;

#[derive(Hash, PartialEq, Eq, Debug)]
struct Key(usize);
#[derive(Hash, PartialEq, Eq, Debug)]
struct SKey(&'static str);

impl TypedMapKey for Key {
    type Value = u32;
}

impl TypedMapKey for SKey {
    type Value = usize;
}

let mut map: TypedDashMap = TypedDashMap::new();
map.insert(Key(3), 3);
map.insert(SKey("four"), 4);

for key_value in map.iter() {
    if let Some((key, value)) = key_value.downcast_pair_ref::<Key>() {
        assert_eq!(key, &Key(3));
        assert_eq!(value, &3u32);
    }

    if let Some((key, value)) = key_value.downcast_pair_ref::<SKey>() {
        assert_eq!(key, &SKey("four"));
        assert_eq!(value, &4);
    }
}

pub fn iter_mut(&self) -> IterMut<'_, Marker, KB, VB, S>

An iterator visiting all key-value pairs in arbitrary order yielding mutable references.

Examples

use typedmap::TypedDashMap;
use typedmap::TypedMapKey;

#[derive(Hash, PartialEq, Eq, Debug)]
struct Key(usize);
#[derive(Hash, PartialEq, Eq, Debug)]
struct SKey(&'static str);

impl TypedMapKey for Key {
    type Value = u32;
}

impl TypedMapKey for SKey {
    type Value = usize;
}

let mut map: TypedDashMap = TypedDashMap::new();
map.insert(Key(3), 3);
map.insert(SKey("four"), 4);

for mut key_value in map.iter_mut() {
    if let Some((key, value)) = key_value.downcast_pair_mut::<Key>() {
        assert_eq!(key, &Key(3));
        assert_eq!(value, &3u32);
        *value = 4u32;
    }

    if let Some((key, value)) = key_value.downcast_pair_mut::<SKey>() {
        assert_eq!(key, &SKey("four"));
        assert_eq!(value, &4);
    }
}

pub fn entry<K>(&self, key: K) -> Entry<'_, K, KB, VB, Marker>

where K: 'static + TypedMapKey<Marker>, KB: HasBounds<K>, VB: HasBounds<<K as TypedMapKey<Marker>>::Value>,

Gets the given key’s corresponding entry in the map for in-place manipulation.

Examples

use typedmap::TypedDashMap;
use typedmap::TypedMapKey;

#[derive(Hash, PartialEq, Eq)]
struct Key(char);

impl TypedMapKey for Key {
    type Value = usize;
}

let letters: TypedDashMap = TypedDashMap::new();
for ch in "a short treatise on fungi".chars() {
   let mut counter = letters.entry(Key(ch)).or_insert(0);
   *counter += 1;
}
assert_eq!(letters.get(&Key('s')).unwrap().value(), &2);
assert_eq!(letters.get(&Key('t')).unwrap().value(), &3);
assert_eq!(letters.get(&Key('u')).unwrap().value(), &1);
assert!(letters.get(&Key('y')).is_none());

pub fn retain( &self, predicate: impl FnMut(TypedKeyValueRef<'_, Marker, KB, VB>) -> bool, )

Retain elements that the filter closure returns true for.

Examples

use typedmap::TypedDashMap;
use typedmap::TypedMapKey;

#[derive(Hash, PartialEq, Eq, Debug)]
struct Key(usize);
#[derive(Hash, PartialEq, Eq, Debug)]
struct SKey(&'static str);

impl TypedMapKey for Key {
    type Value = u32;
}

impl TypedMapKey for SKey {
    type Value = usize;
}

let mut map: TypedDashMap = TypedDashMap::new();
map.insert(Key(3), 3);
map.insert(SKey("four"), 4);

map.retain(|kv| kv.downcast_key_ref::<Key>().is_some());
assert!(map.contains_key(&Key(3)));

Trait Implementations

impl Debug for CustomField

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

Formats the value using the given formatter.

impl Default for CustomField

fn default() -> Self

Returns the “default value” for a type.

impl Deref for CustomField

type Target = TypedDashMap<(), SyncAnyBounds, SyncAnyBounds, FxBuildHasher>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.