Struct ip_network_table::IpNetworkTable

pub struct IpNetworkTable<T> { /* fields omitted */ }

Table holding IPv4 and IPv6 network prefixes with value.

Methods

impl<T> IpNetworkTable<T>

pub fn new() -> Self

Constructs a new, empty IpNetworkTable<T>.

pub fn with_capacity(ipv4_size: usize, ipv6_size: usize) -> Self

Constructs a new, empty IpNetworkTable<T> with the specified capacity.

pub fn len(&self) -> (usize, usize)

Returns the number of elements in the table. First value is number of IPv4 networks and second is number of IPv6 networks.

pub fn is_empty(&self) -> bool

Returns true if table is empty.

pub fn insert<N: Into<IpNetwork>>(&mut self, network: N, data: T) -> Option<T>

Insert a value for the IpNetwork. If prefix existed previously, the old value is returned.

Examples

use ip_network_table::IpNetworkTable;
use ip_network::Ipv6Network;
use std::net::Ipv6Addr;

let mut table = IpNetworkTable::new();
let network = Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0xdead, 0xbeef, 0, 0, 0, 0), 64).unwrap();

assert_eq!(table.insert(network, "foo"), None);
// Insert duplicate
assert_eq!(table.insert(network, "bar"), Some("foo"));
// Value is replaced
assert_eq!(table.insert(network, "null"), Some("bar"));

pub fn remove<N: Into<IpNetwork>>(&mut self, network: N) -> Option<T>

Remove a IpNetwork from table. If prefix existed, the value is returned.

Examples

use ip_network_table::IpNetworkTable;
use ip_network::Ipv6Network;
use std::net::Ipv6Addr;

let mut table = IpNetworkTable::new();
let network = Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0xdead, 0xbeef, 0, 0, 0, 0), 64).unwrap();

assert_eq!(table.insert(network, "foo"), None);
// Remove network from table
assert_eq!(table.remove(network), Some("foo"));
// Network is removed
assert_eq!(table.exact_match(network), None);

pub fn exact_match<N: Into<IpNetwork>>(&self, network: N) -> Option<&T>

Get pointer to value from table based on exact network match. If network is not in table, None is returned.

Examples

use ip_network_table::IpNetworkTable;
use ip_network::Ipv6Network;
use std::net::Ipv6Addr;

let mut table = IpNetworkTable::new();
let network_a = Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0xdead, 0xbeef, 0, 0, 0, 0), 64).unwrap();
let network_b = Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0xdead, 0xbeef, 0, 0, 0, 0), 128).unwrap();

assert_eq!(table.insert(network_a, "foo"), None);
// Get value for network from table
assert_eq!(table.exact_match(network_a), Some(&"foo"));
// Network B doesnt exists in table
assert_eq!(table.exact_match(network_b), None);

pub fn exact_match_mut<N: Into<IpNetwork>>(
    &mut self,
    network: N
) -> Option<&mut T>

Get mutable pointer to value from table based on exact network match. If network is not in table, None is returned.

Examples

use ip_network_table::IpNetworkTable;
use ip_network::Ipv6Network;
use std::net::Ipv6Addr;

let mut table = IpNetworkTable::new();
let network_a = Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0xdead, 0xbeef, 0, 0, 0, 0), 64).unwrap();
let network_b = Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0xdead, 0xbeef, 0, 0, 0, 0), 128).unwrap();

assert_eq!(table.insert(network_a, "foo"), None);
// Get value for network from table
assert_eq!(table.exact_match_mut(network_a), Some(&mut "foo"));
// Network B doesnt exists in table
assert_eq!(table.exact_match(network_b), None);

pub fn longest_match<I: Into<IpAddr>>(&self, ip: I) -> Option<(IpNetwork, &T)>

Find most specific IP network in table that contains given IP address. If no network in table contains given IP address, None is returned.

Examples

use ip_network_table::IpNetworkTable;
use ip_network::{IpNetwork, Ipv6Network};
use std::net::{IpAddr, Ipv6Addr};

let mut table = IpNetworkTable::new();
let network = IpNetwork::new(Ipv6Addr::new(0x2001, 0xdb8, 0xdead, 0xbeef, 0, 0, 0, 0), 64).unwrap();
let ip_address = Ipv6Addr::new(0x2001, 0xdb8, 0xdead, 0xbeef, 0, 0, 0, 0x1);

assert_eq!(table.insert(network, "foo"), None);
// Get value for network from table
assert_eq!(table.longest_match(ip_address), Some((network, &"foo")));

pub fn longest_match_mut<I: Into<IpAddr>>(
    &mut self,
    ip: I
) -> Option<(IpNetwork, &mut T)>

Find most specific IP network in table that contains given IP address. If no network in table contains given IP address, None is returned.

Examples

use ip_network_table::IpNetworkTable;
use ip_network::{IpNetwork, Ipv6Network};
use std::net::Ipv6Addr;

let mut table = IpNetworkTable::new();
let network = IpNetwork::new(Ipv6Addr::new(0x2001, 0xdb8, 0xdead, 0xbeef, 0, 0, 0, 0), 64).unwrap();
let ip_address = Ipv6Addr::new(0x2001, 0xdb8, 0xdead, 0xbeef, 0, 0, 0, 0x1);

assert_eq!(table.insert(network, "foo"), None);
// Get value for network from table
assert_eq!(table.longest_match_mut(ip_address), Some((network, &mut "foo")));

pub fn longest_match_ipv4(&self, ip: Ipv4Addr) -> Option<(Ipv4Network, &T)>

Specific version of longest_match for IPv4 address.

pub fn longest_match_ipv6(&self, ip: Ipv6Addr) -> Option<(Ipv6Network, &T)>

Specific version of longest_match for IPv6 address.

pub fn matches<I: Into<IpAddr>>(
    &self,
    ip: I
) -> Box<dyn Iterator<Item = (IpNetwork, &T)>>

Find all IP networks in table that contains given IP address. Returns iterator of IpNetwork and reference to value.

Examples

use ip_network_table::IpNetworkTable;
use ip_network::{IpNetwork, Ipv6Network};
use std::net::Ipv6Addr;

let mut table = IpNetworkTable::new();
let network = IpNetwork::new(Ipv6Addr::new(0x2001, 0xdb8, 0xdead, 0xbeef, 0, 0, 0, 0), 64).unwrap();
let ip_address = Ipv6Addr::new(0x2001, 0xdb8, 0xdead, 0xbeef, 0, 0, 0, 0x1);

assert_eq!(table.insert(network, "foo"), None);
// Get value for network from table
assert_eq!(table.matches(ip_address).count(), 1);

pub fn matches_ipv4(
    &self,
    ip: Ipv4Addr
) -> impl Iterator<Item = (Ipv4Network, &T)>

Specific version of matches for IPv4 address.

pub fn matches_ipv6(
    &self,
    ip: Ipv6Addr
) -> impl Iterator<Item = (Ipv6Network, &T)>

Specific version of matches for IPv6 address.

pub fn matches_mut<I: Into<IpAddr>>(
    &mut self,
    ip: I
) -> Box<dyn Iterator<Item = (IpNetwork, &mut T)>>

Find all IP networks in table that contains given IP address. Returns iterator of IpNetwork and mutable reference to value.

Examples

use ip_network_table::IpNetworkTable;
use ip_network::{IpNetwork, Ipv6Network};
use std::net::{IpAddr, Ipv6Addr};

let mut table = IpNetworkTable::new();
let network = IpNetwork::new(Ipv6Addr::new(0x2001, 0xdb8, 0xdead, 0xbeef, 0, 0, 0, 0), 64).unwrap();
let ip_address = Ipv6Addr::new(0x2001, 0xdb8, 0xdead, 0xbeef, 0, 0, 0, 0x1);

assert_eq!(table.insert(network, "foo"), None);
// Get value for network from table
assert_eq!(table.matches_mut(ip_address).count(), 1);

pub fn matches_mut_ipv4(
    &mut self,
    ip: Ipv4Addr
) -> impl Iterator<Item = (Ipv4Network, &mut T)>

Specific version of matches_mut for IPv4 address.

pub fn matches_mut_ipv6(
    &mut self,
    ip: Ipv6Addr
) -> impl Iterator<Item = (Ipv6Network, &mut T)>

Specific version of matches_mut for IPv6 address.

pub fn iter(&self) -> impl Iterator<Item = (IpNetwork, &T)>

Iterator for all networks in table, first are iterated IPv4 and then IPv6 networks. Order is not guaranteed.

Examples

use ip_network_table::IpNetworkTable;
use ip_network::{IpNetwork, Ipv4Network, Ipv6Network};
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};

let mut table: IpNetworkTable<&str> = IpNetworkTable::new();
let network_a = Ipv4Network::new(Ipv4Addr::new(192, 168, 0, 0), 24).unwrap();
assert_eq!(table.insert(network_a, "foo"), None);
let network_b = Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0xdead, 0xbeef, 0, 0, 0, 0), 64).unwrap();
assert_eq!(table.insert(network_b, "foo"), None);

let mut iterator = table.iter();
assert_eq!(iterator.next(), Some((IpNetwork::V4(network_a), &"foo")));
assert_eq!(iterator.next(), Some((IpNetwork::V6(network_b), &"foo")));
assert_eq!(iterator.next(), None);

pub fn iter_mut(&mut self) -> impl Iterator<Item = (IpNetwork, &mut T)>

Mutable iterator for all networks in table, first are iterated IPv4 and then IPv6 networks. Order is not guaranteed.

Examples

use ip_network_table::IpNetworkTable;
use ip_network::{IpNetwork, Ipv4Network, Ipv6Network};
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};

let mut table: IpNetworkTable<&str> = IpNetworkTable::new();
let network_a = Ipv4Network::new(Ipv4Addr::new(192, 168, 0, 0), 24).unwrap();
assert_eq!(table.insert(network_a, "foo"), None);
let network_b = Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0xdead, 0xbeef, 0, 0, 0, 0), 64).unwrap();
assert_eq!(table.insert(network_b, "foo"), None);

let mut iterator = table.iter_mut();
for (network, value) in iterator {
   *value = "bar";
}

assert_eq!(table.exact_match(network_a), Some(&"bar"));
assert_eq!(table.exact_match(network_b), Some(&"bar"));

pub fn iter_ipv4(&self) -> impl Iterator<Item = (Ipv4Network, &T)>

Iterator for all IPv4 networks in table. Order is not guaranteed.

pub fn iter_ipv6(&self) -> impl Iterator<Item = (Ipv6Network, &T)>

Iterator for all IPv6 networks in table. Order is not guaranteed.

pub fn retain<F>(&mut self, f: F) where
    F: FnMut(IpNetwork, &mut T) -> bool, 

Retains only the elements specified by the predicate.

In other words, remove all pairs (k, v) such that f(ip_network, &mut v) returns false.

Examples

use ip_network_table::IpNetworkTable;
use ip_network::{IpNetwork, Ipv4Network, Ipv6Network};
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};

let mut table: IpNetworkTable<&str> = IpNetworkTable::new();
let network_a = Ipv4Network::new(Ipv4Addr::new(192, 168, 0, 0), 24).unwrap();
assert_eq!(table.insert(network_a, "foo"), None);
let network_b = Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0xdead, 0xbeef, 0, 0, 0, 0), 64).unwrap();
assert_eq!(table.insert(network_b, "foo"), None);

// Keep just IPv4 networks
table.retain(|network, _| network.is_ipv4());

assert_eq!(table.exact_match(network_a), Some(&"foo"));
assert_eq!(table.exact_match(network_b), None);

Trait Implementations

impl<T: Default> Default for IpNetworkTable<T>

fn default() -> IpNetworkTable<T>

Returns the "default value" for a type.