Struct treebitmap::IpLookupTable[][src]

pub struct IpLookupTable<A, T> { /* fields omitted */ }

A fast, compressed IP lookup table.

Methods

impl<A, T> IpLookupTable<A, T> where
    A: Address, 
[src]

Initialize an empty lookup table with no preallocation.

Initialize an empty lookup table with pre-allocated buffers.

Return the bytes used by nodes and results.

Return number of items inside table.

Return true if no item is inside table.

Insert a value for the prefix designated by ip and masklen. If prefix existed previously, the old value is returned.

Examples

use treebitmap::IpLookupTable;
use std::net::Ipv6Addr;

let mut table = IpLookupTable::new();
let prefix = Ipv6Addr::new(0x2001, 0xdb8, 0xdead, 0xbeef, 0, 0, 0, 0);
let masklen = 32;

assert_eq!(table.insert(prefix, masklen, "foo"), None);
// Insert duplicate
assert_eq!(table.insert(prefix, masklen, "bar"), Some("foo"));

Remove an entry from the lookup table. If the prefix existed previously, the value is returned.

Examples

use treebitmap::IpLookupTable;
use std::net::Ipv6Addr;

let mut table = IpLookupTable::new();
let prefix = Ipv6Addr::new(0x2001, 0xdb8, 0xdead, 0xbeef, 0, 0, 0, 0);
let masklen = 32;
table.insert(prefix, masklen, "foo");

assert_eq!(table.remove(prefix, masklen), Some("foo"));
// Remove non-existant
assert_eq!(table.remove(prefix, masklen), None);

Perform exact match lookup of ip/masklen and return the value.

Examples

use treebitmap::IpLookupTable;
use std::net::Ipv6Addr;

let mut table = IpLookupTable::new();
let prefix = Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0);
let masklen = 32;
table.insert(prefix, masklen, "foo");

assert_eq!(table.exact_match(prefix, masklen), Some(&"foo"));
// differing mask
assert_eq!(table.exact_match(prefix, 48), None);

Perform longest match lookup of ip and return the best matching prefix, designated by ip, masklen, along with its value.

Example

use treebitmap::IpLookupTable;
use std::net::Ipv6Addr;

let mut table = IpLookupTable::new();
let less_specific = Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0);
let more_specific = Ipv6Addr::new(0x2001, 0xdb8, 0xdead, 0, 0, 0, 0, 0);
table.insert(less_specific, 32, "foo");
table.insert(more_specific, 48, "bar");

let lookupip = Ipv6Addr::new(0x2001, 0xdb8, 0xdead, 0xbeef,
                             0xcafe, 0xbabe, 0, 1);
let result = table.longest_match(lookupip);
assert_eq!(result, Some((more_specific, 48, &"bar")));

let lookupip = Ipv6Addr::new(0x2001, 0xdb8, 0xcafe, 0xf00,
                             0xf00, 0xf00, 0, 1);
let result = table.longest_match(lookupip);
assert_eq!(result, Some((less_specific, 32, &"foo")));

Returns iterator over prefixes and values.

Examples

use treebitmap::IpLookupTable;
use std::net::Ipv6Addr;

let mut table = IpLookupTable::new();
let less_specific = Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0);
let more_specific = Ipv6Addr::new(0x2001, 0xdb8, 0xdead, 0, 0, 0, 0, 0);
table.insert(less_specific, 32, "foo");
table.insert(more_specific, 48, "bar");

let mut iter = table.iter();
assert_eq!(iter.next(), Some((less_specific, 32, &"foo")));
assert_eq!(iter.next(), Some((more_specific, 48, &"bar")));
assert_eq!(iter.next(), None);

Mutable version of iter()

Trait Implementations

impl<A, T> IntoIterator for IpLookupTable<A, T> where
    A: Address, 
[src]

The type of the elements being iterated over.

Which kind of iterator are we turning this into?

Creates an iterator from a value. Read more

Auto Trait Implementations

impl<A, T> Send for IpLookupTable<A, T> where
    A: Send,
    T: Send

impl<A, T> Sync for IpLookupTable<A, T> where
    A: Sync,
    T: Sync