Struct iptrie::LCTrieMap

pub struct LCTrieMap<K, V>(_);

A map of Ip prefixes based on a level-compressed trie

Implementations

impl<K: IpPrefix, V> LCTrieMap<K, V>

pub fn len(&self) -> NonZeroUsize

Returns the size of the map.

Notice that it never equals zero since the top prefix is always present in the map.

pub fn get<Q>(&self, k: &Q) -> Option<&V>where Q: IpPrefix<Addr = K::Addr>, K: IpPrefixCovering<Q> + PartialEq<Q>,

Gets the value associated with an exact match of the key.

To access to the longest prefix match, use Self::lookup.

To get a mutable access to a value, use Self::get_mut.

Example

use std::net::Ipv4Addr;
let mut trie = RTrieMap::with_root(42);

let addr = Ipv4Addr::new(1,1,1,1);;
let ip20 = Ipv4Prefix::new(addr, 20).unwrap();
let ip22 = Ipv4Prefix::new(addr, 22).unwrap();
let ip24 = Ipv4Prefix::new(addr, 24).unwrap();

trie.insert(ip24, 24);
trie.insert(ip20, 20);

let lctrie = trie.compress();
assert_eq!( lctrie.get(&ip20), Some(&20));
assert_eq!( lctrie.get(&ip22), None);
assert_eq!( lctrie.get(&ip24), Some(&24));

pub fn get_mut<Q>(&mut self, k: &Q) -> Option<&mut V>where Q: IpPrefix<Addr = K::Addr>, K: IpPrefixCovering<Q> + PartialEq<Q>,

Gets a mutable access to the value associated with an exact match of the key.

To access to the longest prefix match, use Self::lookup_mut.

To get a mutable access to a value, use Self::get_mut.

Example

use std::net::Ipv4Addr;
let mut trie = RTrieMap::new();

let addr = Ipv4Addr::new(1,1,1,1);;
let ip20 = Ipv4Prefix::new(addr, 20).unwrap();
let ip22 = Ipv4Prefix::new(addr, 22).unwrap();

trie.insert(ip20, 20);
let mut lctrie = trie.compress();

assert_eq!( lctrie.get(&ip20), Some(&20));

assert_eq!( lctrie.get_mut(&ip22), None);
*lctrie.get_mut(&ip20).unwrap() = 42;
assert_eq!( lctrie.get(&ip20), Some(&42));

pub fn lookup<Q>(&self, k: &Q) -> (&K, &V)where Q: IpPrefix<Addr = K::Addr>, K: IpPrefixCovering<Q>,

Gets the value associated with the longest prefix match of the key.

As the top prefix always matches, the lookup never fails.

To access to the exact prefix match, use Self::get.

To get a mutable access to a value, use Self::lookup_mut.

Example

use std::net::Ipv4Addr;
let mut trie = RTrieMap::with_root(42);

let addr = Ipv4Addr::new(1,1,1,1);;
let ip20 = Ipv4Prefix::new(addr, 20).unwrap();
let ip22 = Ipv4Prefix::new(addr, 22).unwrap();
let ip24 = Ipv4Prefix::new(addr, 24).unwrap();

trie.insert(ip20, 20);
trie.insert(ip24, 24);

let lctrie = trie.compress();

assert_eq!( lctrie.lookup(&ip20), (&ip20, &20));
assert_eq!( lctrie.lookup(&ip22), (&ip20, &20));
assert_eq!( lctrie.lookup(&ip24), (&ip24, &24));

assert_eq!( lctrie.lookup(&addr), (&ip24, &24));

pub fn lookup_mut<Q>(&mut self, k: &Q) -> (&K, &mut V)where Q: IpPrefix<Addr = K::Addr>, K: IpPrefixCovering<Q>,

Gets a mutable access to the value associated with a longest prefix match of the key.

To access to the exact prefix match, use Self::get_mut.

Example

let mut trie = RTrieMap::with_root(42);

let ip20 = "1.1.1.1/20".parse::<Ipv4Prefix>().unwrap();
let ip22 = "1.1.1.1/22".parse::<Ipv4Prefix>().unwrap();

trie.insert(ip20, 20);

let mut lctrie = trie.compress();

assert_eq!( lctrie.get(&ip20), Some(&20));

*lctrie.lookup_mut(&ip22).1 = 42;
assert_eq!( lctrie.get(&ip20), Some(&42));

pub fn info(&self)

pub fn iter(&self) -> impl Iterator<Item = (&K, &V)> + '_

Iterates over all the entries.

As the root prefix always exists, this iterator is never empty.

For a mutable access of values, use Self::iter_mut

Example

let trie = Ipv4RTrieMap::with_root(42);
let lctrie = trie.compress();
assert_eq!( lctrie.len().get(), lctrie.iter().count());

pub fn iter_mut(&mut self) -> impl Iterator<Item = (&K, &mut V)> + '_

Iterates over all the entries with a mutable access to values. As the root prefix always exists, this iterator is never empty.

For a mutable access of values, use Self::iter_mut

Example

let trie = Ipv4RTrieMap::with_root(42);
let mut lctrie = trie.compress();
lctrie.iter_mut().for_each(|(_,v)| *v += 1 );
assert_eq!( lctrie.lookup(&Ipv4Prefix::root()).1, &43);

pub fn prefixes(&self) -> LCTrieSet<K>

Gets a set of copy of all the keys in a trie set.

Example

let trie = Ipv4RTrieMap::with_root(42);
let mut lctrie = trie.compress();
assert_eq!( lctrie.len(), lctrie.prefixes().len());

Trait Implementations

impl<K: IpPrefix, V: Default> FromIterator<(K, V)> for LCTrieMap<K, V>

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

Creates a value from an iterator.