Struct elsa::map::FrozenMap

pub struct FrozenMap<K, V, S = RandomState> { /* private fields */ }

Append-only version of std::collections::HashMap where insertion does not require mutable access

Implementations

impl<K: Eq + Hash, V> FrozenMap<K, V>

pub fn new() -> Self

Examples found in repository

examples/fluentresource.rs (line 26)

    pub fn new() -> Self {
        ResourceManager {
            strings: FrozenMap::new(),
            resources: FrozenMap::new(),
        }
    }

pub fn len(&self) -> usize

Examples

use elsa::FrozenMap;

let map = FrozenMap::new();
assert_eq!(map.len(), 0);
map.insert(1, Box::new("a"));
assert_eq!(map.len(), 1);

pub fn is_empty(&self) -> bool

Examples

use elsa::FrozenMap;

let map = FrozenMap::new();
assert_eq!(map.is_empty(), true);
map.insert(1, Box::new("a"));
assert_eq!(map.is_empty(), false);

impl<K: Eq + Hash, V: StableDeref, S: BuildHasher> FrozenMap<K, V, S>

pub fn insert(&self, k: K, v: V) -> &V::Target

Examples found in repository

examples/fluentresource.rs (line 39)

    pub fn get_resource(&'mgr self, path: &str) -> &'mgr FluentResource<'mgr> {
        let strings = &self.strings;

        if strings.get(path).is_some() {
            return self.resources.get(path).unwrap();
        } else {
            // pretend to load a file
            let string = format!("file for {}", path);
            let val = self.strings.insert(path.to_string(), string);
            let res = FluentResource::new(val);
            self.resources.insert(path.to_string(), Box::new(res))
        }
    }

pub fn get<Q>(&self, k: &Q) -> Option<&V::Target>where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Returns a reference to the value corresponding to the key.

The key may be any borrowed form of the map’s key type, but Hash and Eq on the borrowed form must match those for the key type.

Examples

use elsa::FrozenMap;

let map = FrozenMap::new();
map.insert(1, Box::new("a"));
assert_eq!(map.get(&1), Some(&"a"));
assert_eq!(map.get(&2), None);

Examples found in repository

examples/fluentresource.rs (line 34)

    pub fn get_resource(&'mgr self, path: &str) -> &'mgr FluentResource<'mgr> {
        let strings = &self.strings;

        if strings.get(path).is_some() {
            return self.resources.get(path).unwrap();
        } else {
            // pretend to load a file
            let string = format!("file for {}", path);
            let val = self.strings.insert(path.to_string(), string);
            let res = FluentResource::new(val);
            self.resources.insert(path.to_string(), Box::new(res))
        }
    }

pub fn map_get<Q, T, F>(&self, k: &Q, f: F) -> Option<T>where K: Borrow<Q>, Q: Hash + Eq + ?Sized, F: FnOnce(&V) -> T,

Applies a function to the owner of the value corresponding to the key (if any).

The key may be any borrowed form of the map’s key type, but Hash and Eq on the borrowed form must match those for the key type.

Examples

use elsa::FrozenMap;

let map = FrozenMap::new();
map.insert(1, Box::new("a"));
assert_eq!(map.map_get(&1, Clone::clone), Some(Box::new("a")));
assert_eq!(map.map_get(&2, Clone::clone), None);

pub fn into_map(self) -> HashMap<K, V, S>

impl<K: Eq + Hash + StableDeref, V: StableDeref, S: BuildHasher> FrozenMap<K, V, S>

pub fn get_key_value<Q>(&self, k: &Q) -> Option<(&K::Target, &V::Target)>where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Returns a reference to the key and value matching a borrowed key.

The key argument may be any borrowed form of the map’s key type, but Hash and Eq on the borrowed form must match those for the key type.

Examples

use elsa::FrozenMap;

let map = FrozenMap::new();
map.insert(Box::new("1"), Box::new("a"));
assert_eq!(map.get_key_value(&"1"), Some((&"1", &"a")));
assert_eq!(map.get_key_value(&"2"), None);

Trait Implementations

impl<K, V, S> AsMut<HashMap<K, V, S>> for FrozenMap<K, V, S>

fn as_mut(&mut self) -> &mut HashMap<K, V, S>

Get mutable access to the underlying HashMap.

This is safe, as it requires a &mut self, ensuring nothing is using the ‘frozen’ contents.

impl<K: Eq + Hash, V, S: Default> Default for FrozenMap<K, V, S>

fn default() -> Self

Returns the “default value” for a type.

impl<K, V, S> From<HashMap<K, V, S>> for FrozenMap<K, V, S>

fn from(map: HashMap<K, V, S>) -> Self

Converts to this type from the input type.

impl<K: Eq + Hash, V, S: BuildHasher + Default> FromIterator<(K, V)> for FrozenMap<K, V, S>

fn from_iter<T>(iter: T) -> Selfwhere T: IntoIterator<Item = (K, V)>,

Creates a value from an iterator.

impl<Q, K, V, S> Index<&Q> for FrozenMap<K, V, S>where Q: Eq + Hash + ?Sized, K: Eq + Hash + Borrow<Q>, V: StableDeref, S: BuildHasher,

fn index(&self, idx: &Q) -> &V::Target

Examples

use elsa::FrozenMap;

let map = FrozenMap::new();
map.insert(1, Box::new("a"));
assert_eq!(map[&1], "a");

type Output = <V as Deref>::Target

The returned type after indexing.