Struct prefix_tree::PrefixMap

pub struct PrefixMap<K, V> { /* fields omitted */ }

A map implemented with prefix tree.

Methods

impl<K: Eq + Clone, V> PrefixMap<K, V>

pub fn new() -> PrefixMap<K, V>

Creates an empty PrefixMap.

Examples

use prefix_tree::PrefixMap;

let mut map: PrefixMap<u8, i32> = PrefixMap::new();

pub fn contains_key<Q>(&self, key: Q) -> bool where
    Q: AsRef<[K]>, 

Returns true if the map contains a value for the specified key.

Examples

use prefix_tree::PrefixMap;

let mut map: PrefixMap<u8, i32> = PrefixMap::new();
map.insert("foo", 1);
assert_eq!(map.contains_key("foo"), true);
assert_eq!(map.contains_key("bar"), false);

pub fn clear(&mut self)

Clears the map, removing all key-value pairs.

Examples

use prefix_tree::PrefixMap;

let mut map: PrefixMap<u8, i32> = PrefixMap::new();
map.insert("foo", 1);
map.clear();
assert!(map.is_empty());

pub fn get<Q>(&self, key: Q) -> Option<&V> where
    Q: AsRef<[K]>, 

Returns a reference to the value corresponding to the key.

Examples

use prefix_tree::PrefixMap;

let mut map: PrefixMap<u8, i32> = PrefixMap::new();
map.insert("foo", 1);
assert_eq!(map.get("foo"), Some(&1));
assert_eq!(map.get("bar"), None);

pub fn get_mut<Q>(&mut self, key: Q) -> Option<&mut V> where
    Q: AsRef<[K]>, 

Returns a mutable reference to the value corresponding to the key.

Examples

use prefix_tree::PrefixMap;

let mut map: PrefixMap<u8, i32> = PrefixMap::new();
map.insert("foo", 1);
if let Some(x) = map.get_mut("foo") {
    *x = 2;
}
assert_eq!(map.get("foo"), Some(&2));

pub fn insert<Q>(&mut self, key: Q, value: V) -> Option<V> where
    Q: AsRef<[K]>, 

Inserts a key-value pair into the map.

Examples

use prefix_tree::PrefixMap;

let mut map: PrefixMap<u8, i32> = PrefixMap::new();
assert_eq!(map.insert("a", 42), None);
assert_eq!(map.is_empty(), false);
assert_eq!(map.insert("a", 5), Some(42));
assert_eq!(map.get("a"), Some(&5));

pub fn remove<Q>(&mut self, key: Q) -> Option<V> where
    Q: AsRef<[K]>, 

Removes a key from the map, returning the value at the key if the key was previously in the map.

Examples

use prefix_tree::PrefixMap;

let mut map: PrefixMap<u8, i32> = PrefixMap::new();
assert_eq!(map.insert("a", 42), None);
assert_eq!(map.remove("a"), Some(42));
assert_eq!(map.get("a"), None);

pub fn is_empty(&self) -> bool

Returns true if the map contains no elements.

Examples

use prefix_tree::PrefixMap;

let mut map: PrefixMap<u8, i32> = PrefixMap::new();
assert_eq!(map.is_empty(), true);
map.insert("foo", 1);
assert_eq!(map.is_empty(), false);

pub fn len(&self) -> usize

Returns the number of elements in the map.

Examples

use prefix_tree::PrefixMap;

let mut map: PrefixMap<u8, i32> = PrefixMap::new();
assert_eq!(map.len(), 0);
map.insert("foo", 1);
assert_eq!(map.len(), 1);

pub fn iter(&self) -> Iter<K, V>

Gets an iterator over the entries of the map, in arbitrary order.

Examples

use prefix_tree::PrefixMap;

let mut map: PrefixMap<u8, i32> = PrefixMap::new();
map.insert("1", 9);
map.insert("2", 8);
map.insert("3", 7);

for (key, value) in map.iter() {
    println!("{:?}: {:?}", key, value);
}

pub fn keys(&self) -> Keys<K, V>

Gets an iterator over the keys of the map, in arbitrary order.

Examples

use prefix_tree::PrefixMap;

let mut map: PrefixMap<i32, i32> = PrefixMap::new();
map.insert([1], 2);
map.insert([2], 3);

assert_eq!(map.keys().collect::<Vec<_>>(), vec![vec![1], vec![2]]);

pub fn values(&self) -> Values<K, V>

Gets an iterator over the values of the map, in arbitrary order.

Examples

use prefix_tree::PrefixMap;

let mut map: PrefixMap<i32, i32> = PrefixMap::new();
map.insert([1], 2);
map.insert([2], 3);

assert_eq!(map.values().cloned().collect::<Vec<_>>(), vec![2, 3]);

Trait Implementations

impl<K: Clone, V: Clone> Clone for PrefixMap<K, V>

fn clone(&self) -> PrefixMap<K, V>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<K: Debug, V: Debug> Debug for PrefixMap<K, V>

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

Formats the value using the given formatter.

impl<K: Default, V: Default> Default for PrefixMap<K, V>

fn default() -> PrefixMap<K, V>

Returns the "default value" for a type.

impl<K: Eq + Clone, V: Eq> Eq for PrefixMap<K, V>

impl<'a, K: 'a + Eq + Clone, V: 'a> FromIterator<(&'a [K], V)> for PrefixMap<K, V>

fn from_iter<I>(iter: I) -> PrefixMap<K, V> where
    I: IntoIterator<Item = (&'a [K], V)>, 

Creates a value from an iterator.

impl<K: Eq + Clone + Hash, V: Hash> Hash for PrefixMap<K, V>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<K: Eq + Clone, V, Q: AsRef<[K]>> Index<Q> for PrefixMap<K, V>

type Output = V

The returned type after indexing.

fn index(&self, index: Q) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a, K: 'a + Eq + Clone, V: 'a> IntoIterator for &'a PrefixMap<K, V>

type Item = (Vec<K>, &'a V)

The type of the elements being iterated over.

type IntoIter = Iter<'a, K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K: Eq + Clone, V: Eq> PartialEq<PrefixMap<K, V>> for PrefixMap<K, V>

fn eq(&self, other: &PrefixMap<K, V>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.