Trait stry_common::utils::vec_map::VecMapExt[−][src]

pub trait VecMapExt<K, V> {
    fn cleared(self) -> Self;

    fn inserted(self, k: K, v: V) -> Self
    where
        K: Eq;

    fn removed<Q>(self, k: &Q) -> Self
    where
        K: Eq + Borrow<Q>,
        Q: Eq + PartialEq<K>;

    fn retained<F>(self, f: F) -> Self
    where
        K: Eq,
        F: FnMut(&K, &mut V) -> bool;

    fn shrinked_to_fit(self) -> Self
    where
        K: Eq;
}

Extension trait that contains functions that allow for chaining of VecMap functions.

Before:

use fenn::vec_map::VecMap;

let mut map = VecMap::new();

map.insert(37, "a");
map.insert(38, "b");

map.remove(&37);

assert_eq!(map.get(&37), None);
assert_eq!(map.get(&38), Some(&"b"));

After:

use fenn::vec_map::{VecMapExt, VecMap};

let map = VecMap::new()
    .inserted(37, "a")
    .inserted(38, "b")
    .removed(&37);

assert_eq!(map.get(&37), None);
assert_eq!(map.get(&38), Some(&"b"));

Required methods

fn cleared(self) -> Self[src]

Clears the map, removing all key-value pairs. Keeps the allocated memory for reuse.

Examples

use fenn::vec_map::{VecMapExt, VecMap};

let a = VecMap::new()
    .inserted(1, "a")
    .cleared();

assert!(a.is_empty());

fn inserted(self, k: K, v: V) -> Self where
    K: Eq, [src]

Inserts a key-value pair into the map.

If the map did have this key present, the value is updated. The key is not updated, though; this matters for types that can be == without being identical.

Warning

Unlike the standard VecMap::insert that this wraps, this function ignores any returned values.

Examples

use fenn::vec_map::{VecMapExt, VecMap};

let map = VecMap::new()
    .inserted(37, "a");

assert_eq!(map[&37], "a");
assert_eq!(map.is_empty(), false);

fn removed<Q>(self, k: &Q) -> Self where
    K: Eq + Borrow<Q>,
    Q: Eq + PartialEq<K>, [src]

Removes a key from the map.

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

fn retained<F>(self, f: F) -> Self where
    K: Eq,
    F: FnMut(&K, &mut V) -> bool, [src]

Retains only the elements specified by the predicate.

In other words, remove all pairs (k, v) such that f(&k, &mut v) returns false.

Examples

use fenn::vec_map::{VecMapExt, VecMap};

let map = (0..8).map(|x|(x, x * 10)).collect::<VecMap<i32, i32>>()
    .retained(|&k, _| k % 2 == 0);

assert_eq!(map.len(), 4);

fn shrinked_to_fit(self) -> Self where
    K: Eq, [src]

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

Examples

use fenn::vec_map::{VecMapExt, VecMap};

let map: VecMap<i32, i32> = VecMap::with_capacity(100)
    .inserted(1, 2)
    .inserted(3, 4)
    .shrinked_to_fit();

assert!(map.capacity() >= 2);
Loading content...

Implementors

impl<K, V> VecMapExt<K, V> for VecMap<K, V>[src]

Loading content...