Struct trie_map::Trie

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

Methods

impl<K, V> Trie<K, V> where
    K: Hash + Eq, 

pub fn new() -> Self

pub fn insert<Q: ?Sized, I: IntoIterator<Item = K>>(
    &mut self,
    prefix: I,
    value: V
) where
    K: Borrow<Q>,
    Q: Hash + Eq, 

pub fn insert_alt<Q: ?Sized, I: IntoIterator<Item = K>>(
    &mut self,
    prefix: I,
    value: V
) where
    K: Borrow<Q>,
    Q: Hash + Eq, 

pub fn is_empty(&self) -> bool

pub fn get_ref<Q: ?Sized, I: IntoIterator<Item = K>>(
    &self,
    prefix: I
) -> Option<&Trie<K, V>> where
    K: Borrow<Q>,
    Q: Hash + Eq, 

pub fn get_mut<Q: ?Sized, I: IntoIterator<Item = K>>(
    &mut self,
    prefix: I
) -> Option<&mut Trie<K, V>> where
    K: Borrow<Q>,
    Q: Hash + Eq, 

pub fn remove<Q: ?Sized, I: IntoIterator<Item = K>>(
    &mut self,
    prefix: I
) -> Option<V> where
    K: Borrow<Q>,
    Q: Hash + Eq, 

pub fn values_vec<'a, Q: ?Sized>(&'a self) -> Vec<&'a V> where
    K: Borrow<Q>,
    Q: Hash + Eq, 

pub fn values<'a, B, Q: ?Sized>(&'a self) -> B where
    B: FromIterator<&'a V>,
    K: Borrow<Q>,
    Q: Hash + Eq, 

pub fn values_prefix<'a, I, Q: ?Sized>(&'a self, prefix: I) -> Vec<&'a V> where
    I: IntoIterator<Item = K>,
    V: Debug,
    K: Borrow<Q> + Debug,
    Q: Hash + Eq, 

Important traits for Iter<'a, K, V>

impl<'a, K, V> Iterator for Iter<'a, K, V> where
    K: Eq + Hash,  type Item = IterItem<'a, K, V>;

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

impl<V> Trie<char, V>

pub fn insert_str<S: AsRef<str>>(&mut self, prefix: S, value: V)

pub fn get_ref_str<Q: ?Sized, S: AsRef<str>>(
    &self,
    prefix: S
) -> Option<&Trie<char, V>> where
    Q: Hash + Eq, 

pub fn get_mut_str<Q: ?Sized, S: AsRef<str>>(
    &mut self,
    prefix: S
) -> Option<&mut Trie<char, V>> where
    Q: Hash + Eq, 

pub fn remove_str<Q: ?Sized, S: AsRef<str>>(&mut self, prefix: S) -> Option<V> where
    Q: Hash + Eq, 

impl<V> Trie<u8, V>

pub fn insert_bytes<S>(&mut self, prefix: S, value: V) where
    S: AsRef<[u8]>, 

pub fn get_ref_str<Q: ?Sized, S: AsRef<[u8]>>(&self, prefix: S) -> Option<&Self> where
    Q: Hash + Eq, 

pub fn get_mut_str<Q: ?Sized, S: AsRef<[u8]>>(
    &mut self,
    prefix: S
) -> Option<&mut Self> where
    Q: Hash + Eq, 

pub fn remove_str<Q: ?Sized, S: AsRef<[u8]>>(&mut self, prefix: S) -> Option<V> where
    Q: Hash + Eq, 

Trait Implementations

impl<K, V, P> Extend<(P, V)> for Trie<K, V> where
    P: IntoIterator<Item = K>,
    K: Eq + Hash, 

fn extend<I: IntoIterator<Item = (P, V)>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

impl<K, V> Default for Trie<K, V> where
    K: Eq + Hash, 

fn default() -> Self

Returns the "default value" for a type.

impl<'a, K, V> IntoIterator for &'a Trie<K, V> where
    K: Eq + Hash, 

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

Which kind of iterator are we turning this into?

type Item = IterItem<'a, K, V>

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K, V, P> Index<P> for Trie<K, V> where
    P: IntoIterator<Item = K>,
    K: Eq + Hash, 

type Output = Trie<K, V>

The returned type after indexing.

fn index(&self, iter: P) -> &Self

Performs the indexing (container[index]) operation.

impl<'a, K, V, P> IndexMut<P> for Trie<K, V> where
    P: IntoIterator<Item = K>,
    K: Eq + Hash, 

fn index_mut(&mut self, iter: P) -> &mut Self

Performs the mutable indexing (container[index]) operation.

impl<K, V, P> FromIterator<(P, V)> for Trie<K, V> where
    P: IntoIterator<Item = K>,
    K: Eq + Hash, 

fn from_iter<I: IntoIterator<Item = (P, V)>>(iter: I) -> Self

Creates a value from an iterator.