Struct patricia_tree::map::PatriciaMap[−][src]

pub struct PatriciaMap<V> { /* fields omitted */ }

Expand description

A map based on a patricia tree.

Implementations

[src]

impl<V> PatriciaMap<V>

[src]

pub fn new() -> Self

Makes a new empty PatriciaMap instance.

Examples

use patricia_tree::PatriciaMap;

let mut map = PatriciaMap::new();
assert!(map.is_empty());

map.insert("foo", 10);
assert_eq!(map.len(), 1);
assert_eq!(map.get("foo"), Some(&10));

map.remove("foo");
assert_eq!(map.get("foo"), None);

[src]

pub fn clear(&mut self)

Clears this map, removing all values.

Examples

use patricia_tree::PatriciaMap;

let mut map = PatriciaMap::new();
map.insert("foo", 1);
map.clear();
assert!(map.is_empty());

[src]

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

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

Examples

use patricia_tree::PatriciaMap;

let mut map = PatriciaMap::new();
map.insert("foo", 1);
assert!(map.contains_key("foo"));
assert!(!map.contains_key("bar"));

[src]

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

Returns a reference to the value corresponding to the key.

Examples

use patricia_tree::PatriciaMap;

let mut map = PatriciaMap::new();
map.insert("foo", 1);
assert_eq!(map.get("foo"), Some(&1));
assert_eq!(map.get("bar"), None);

[src]

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

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

Examples

use patricia_tree::PatriciaMap;

let mut map = PatriciaMap::new();
map.insert("foo", 1);
map.get_mut("foo").map(|v| *v = 2);
assert_eq!(map.get("foo"), Some(&2));

[src]

pub fn get_longest_common_prefix<'a, K: ?Sized>(
    &self, 
    key: &'a K
) -> Option<(&'a [u8], &V)> where
    K: AsRef<[u8]>,

Finds the longest common prefix of key and the keys in this map, and returns a reference to the entry whose key matches the prefix.

Examples

use patricia_tree::PatriciaMap;

let mut map = PatriciaMap::new();
map.insert("foo", 1);
map.insert("foobar", 2);
assert_eq!(map.get_longest_common_prefix("fo"), None);
assert_eq!(map.get_longest_common_prefix("foo"), Some(("foo".as_bytes(), &1)));
assert_eq!(map.get_longest_common_prefix("fooba"), Some(("foo".as_bytes(), &1)));
assert_eq!(map.get_longest_common_prefix("foobar"), Some(("foobar".as_bytes(), &2)));
assert_eq!(map.get_longest_common_prefix("foobarbaz"), Some(("foobar".as_bytes(), &2)));

[src]

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

Inserts a key-value pair into this 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 the old value is returned.

Examples

use patricia_tree::PatriciaMap;

let mut map = PatriciaMap::new();
assert_eq!(map.insert("foo", 1), None);
assert_eq!(map.get("foo"), Some(&1));
assert_eq!(map.insert("foo", 2), Some(1));
assert_eq!(map.get("foo"), Some(&2));

[src]

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

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

Examples

use patricia_tree::PatriciaMap;

let mut map = PatriciaMap::new();
map.insert("foo", 1);
assert_eq!(map.remove("foo"), Some(1));
assert_eq!(map.remove("foo"), None);

[src]

pub fn common_prefixes<'a, 'b>(
    &'a self, 
    key: &'b [u8]
) -> impl 'b + Iterator<Item = (&'b [u8], &'a V)> where
    'a: 'b,

Returns an iterator that collects all entries in the map up to a certain key.

Example

use patricia_tree::PatriciaMap;
let mut t = PatriciaMap::new();
t.insert("a", vec!["a"]);
t.insert("x", vec!["x"]);
t.insert("ab", vec!["b"]);
t.insert("abc", vec!["c"]);
t.insert("abcd", vec!["d"]);
t.insert("abcdf", vec!["f"]);
assert!(t
    .common_prefixes(b"abcde")
    .map(|(_, v)| v)
    .flatten()
    .eq(vec![&"a", &"b", &"c", &"d"].into_iter()));

[src]

pub fn common_prefix_values<'a>(
    &'a self, 
    key: &[u8]
) -> impl 'a + Iterator<Item = &'a V>

Returns an iterator that collects all values of entries in the map up to a certain key.

Example

use patricia_tree::PatriciaMap;
let mut t = PatriciaMap::new();
t.insert("a", vec!["a"]);
t.insert("x", vec!["x"]);
t.insert("ab", vec!["b"]);
t.insert("abc", vec!["c"]);
t.insert("abcd", vec!["d"]);
t.insert("abcdf", vec!["f"]);
assert!(t
    .common_prefix_values(b"abcde")
    .flatten()
    .eq(vec![&"a", &"b", &"c", &"d"].into_iter()));

[src]

pub fn split_by_prefix<K: AsRef<[u8]>>(&mut self, prefix: K) -> Self

Splits the map into two at the given prefix.

The returned map contains all the entries of which keys are prefixed by prefix.

Examples

use patricia_tree::PatriciaMap;

let mut a = PatriciaMap::new();
a.insert("rust", 1);
a.insert("ruby", 2);
a.insert("bash", 3);
a.insert("erlang", 4);
a.insert("elixir", 5);

let b = a.split_by_prefix("e");
assert_eq!(a.len(), 3);
assert_eq!(b.len(), 2);

assert_eq!(a.keys().collect::<Vec<_>>(), [b"bash", b"ruby", b"rust"]);
assert_eq!(b.keys().collect::<Vec<_>>(), [b"elixir", b"erlang"]);

[src]

pub fn len(&self) -> usize

Returns the number of elements in this map.

Examples

use patricia_tree::PatriciaMap;

let mut map = PatriciaMap::new();
map.insert("foo", 1);
map.insert("bar", 2);
assert_eq!(map.len(), 2);

[src]

pub fn is_empty(&self) -> bool

Returns true if this map contains no elements.

Examples

use patricia_tree::PatriciaMap;

let mut map = PatriciaMap::new();
assert!(map.is_empty());

map.insert("foo", 1);
assert!(!map.is_empty());

map.clear();
assert!(map.is_empty());

[src]

pub fn iter(&self) -> Iter<'_, V>ⓘNotable traits for Iter<'a, V>
impl<'a, V: 'a> Iterator for Iter<'a, V>    type Item = (Vec<u8>, &'a V);

Gets an iterator over the entries of this map, sorted by key.

Examples

use patricia_tree::PatriciaMap;

let map: PatriciaMap<_> =
    vec![("foo", 1), ("bar", 2), ("baz", 3)].into_iter().collect();
assert_eq!(vec![(Vec::from("bar"), &2), ("baz".into(), &3), ("foo".into(), &1)],
           map.iter().collect::<Vec<_>>());

[src]

pub fn iter_mut(&mut self) -> IterMut<'_, V>ⓘNotable traits for IterMut<'a, V>
impl<'a, V: 'a> Iterator for IterMut<'a, V>    type Item = (Vec<u8>, &'a mut V);

Gets a mutable iterator over the entries of this map, soretd by key.

Examples

use patricia_tree::PatriciaMap;

let mut map: PatriciaMap<_> =
    vec![("foo", 1), ("bar", 2), ("baz", 3)].into_iter().collect();
for (_, v) in map.iter_mut() {
   *v += 10;
}
assert_eq!(map.get("bar"), Some(&12));

[src]

pub fn iter_prefix<'a, 'b>(
    &'a self, 
    prefix: &'b [u8]
) -> impl 'a + Iterator<Item = (Vec<u8>, &'a V)> where
    'b: 'a,

Gets an iterator over the entries having the given prefix of this map, sorted by key.

Examples

use patricia_tree::PatriciaMap;

let map: PatriciaMap<_> =
    vec![("foo", 1), ("bar", 2), ("baz", 3)].into_iter().collect();
assert_eq!(vec![(Vec::from("bar"), &2), ("baz".into(), &3)],
           map.iter_prefix(b"ba").collect::<Vec<_>>());

[src]

pub fn iter_prefix_mut<'a, 'b>(
    &'a mut self, 
    prefix: &'b [u8]
) -> impl 'a + Iterator<Item = (Vec<u8>, &'a mut V)> where
    'b: 'a,

Gets a mutable iterator over the entries having the given prefix of this map, sorted by key.

Examples

use patricia_tree::PatriciaMap;

let mut map: PatriciaMap<_> =
    vec![("foo", 1), ("bar", 2), ("baz", 3)].into_iter().collect();
assert_eq!(vec![(Vec::from("bar"), &mut 2), ("baz".into(), &mut 3)],
           map.iter_prefix_mut(b"ba").collect::<Vec<_>>());

[src]

pub fn keys(&self) -> Keys<'_, V>ⓘNotable traits for Keys<'a, V>
impl<'a, V: 'a> Iterator for Keys<'a, V>    type Item = Vec<u8>;

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

Examples

use patricia_tree::PatriciaMap;

let map: PatriciaMap<_> =
    vec![("foo", 1), ("bar", 2), ("baz", 3)].into_iter().collect();
assert_eq!(vec![Vec::from("bar"), "baz".into(), "foo".into()],
           map.keys().collect::<Vec<_>>());

[src]

pub fn values(&self) -> Values<'_, V>ⓘNotable traits for Values<'a, V>
impl<'a, V: 'a> Iterator for Values<'a, V>    type Item = &'a V;

Gets an iterator over the values of this map, in order by key.

Examples

use patricia_tree::PatriciaMap;

let map: PatriciaMap<_> =
    vec![("foo", 1), ("bar", 2), ("baz", 3)].into_iter().collect();
assert_eq!(vec![2, 3, 1],
           map.values().cloned().collect::<Vec<_>>());

[src]

pub fn values_mut(&mut self) -> ValuesMut<'_, V>ⓘNotable traits for ValuesMut<'a, V>
impl<'a, V: 'a> Iterator for ValuesMut<'a, V>    type Item = &'a mut V;

Gets a mutable iterator over the values of this map, in order by key.

Examples

use patricia_tree::PatriciaMap;

let mut map: PatriciaMap<_> =
    vec![("foo", 1), ("bar", 2), ("baz", 3)].into_iter().collect();
for v in map.values_mut() {
    *v += 10;
}
assert_eq!(vec![12, 13, 11],
           map.values().cloned().collect::<Vec<_>>());

Trait Implementations

[src]

impl<V> AsRef<Node<V>> for PatriciaMap<V>

[src]

fn as_ref(&self) -> &Node<V>

Performs the conversion.

[src]

impl<V: Clone> Clone for PatriciaMap<V>

[src]

fn clone(&self) -> PatriciaMap<V>

Returns a copy of the value. Read more

1.0.0[src]

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

Performs copy-assignment from source. Read more

[src]

impl<V: Debug> Debug for PatriciaMap<V>

[src]

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

Formats the value using the given formatter. Read more

[src]

impl<V> Default for PatriciaMap<V>

[src]

fn default() -> Self

Returns the “default value” for a type. Read more

[src]

impl<K, V> Extend<(K, V)> for PatriciaMap<V> where
    K: AsRef<[u8]>,

[src]

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

Extends a collection with the contents of an iterator. Read more

[src]

fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

[src]

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements. Read more

[src]

impl<V> From<Node<V>> for PatriciaMap<V>

[src]

fn from(f: Node<V>) -> Self

Performs the conversion.

[src]

impl<V> From<PatriciaMap<V>> for Node<V>

[src]

fn from(f: PatriciaMap<V>) -> Self

Performs the conversion.

[src]

impl<K, V> FromIterator<(K, V)> for PatriciaMap<V> where
    K: AsRef<[u8]>,

[src]

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

Creates a value from an iterator. Read more

[src]

impl<V> IntoIterator for PatriciaMap<V>

type Item = (Vec<u8>, V)

The type of the elements being iterated over.

type IntoIter = IntoIter<V>

Which kind of iterator are we turning this into?

[src]

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value. Read more

Auto Trait Implementations

impl<V> RefUnwindSafe for PatriciaMap<V> where
    V: RefUnwindSafe,

impl<V> Send for PatriciaMap<V> where
    V: Send,

impl<V> Sync for PatriciaMap<V> where
    V: Sync,

impl<V> Unpin for PatriciaMap<V> where
    V: Unpin,

impl<V> UnwindSafe for PatriciaMap<V> where
    V: UnwindSafe,

Blanket Implementations

[src]

impl<T> Any for T where
    T: 'static + ?Sized,

[src]

pub fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

[src]

impl<T> Borrow<T> for T where
    T: ?Sized,

[src]

pub fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized,

[src]

pub fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

[src]

impl<T> From<T> for T

[src]

pub fn from(t: T) -> T

Performs the conversion.

[src]

impl<T, U> Into<U> for T where
    U: From<T>,

[src]

pub fn into(self) -> U

Performs the conversion.

[src]

impl<T> ToOwned for T where
    T: Clone,

type Owned = T

The resulting type after obtaining ownership.

[src]

pub fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

[src]

pub fn clone_into(&self, target: &mut T)

🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

[src]

pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

[src]

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

[src]

pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.