[−][src]Struct ip_network_table::IpNetworkTable
Table holding IPv4 and IPv6 network prefixes with value.
Methods
impl<T> IpNetworkTable<T>
[src]
pub fn new() -> Self
[src]
Constructs a new, empty IpNetworkTable<T>
.
pub fn with_capacity(ipv4_size: usize, ipv6_size: usize) -> Self
[src]
Constructs a new, empty IpNetworkTable<T>
with the specified capacity.
pub fn len(&self) -> (usize, usize)
[src]
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
[src]
Returns true
if table is empty.
pub fn insert<N: Into<IpNetwork>>(&mut self, network: N, data: T) -> Option<T>
[src]
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>
[src]
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>
[src]
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>
[src]
&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)>
[src]
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)>
[src]
&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)>
[src]
Specific version of longest_match
for IPv4 address.
pub fn longest_match_ipv6(&self, ip: Ipv6Addr) -> Option<(Ipv6Network, &T)>
[src]
Specific version of longest_match
for IPv6 address.
pub fn matches<I: Into<IpAddr>>(
&self,
ip: I
) -> Box<dyn Iterator<Item = (IpNetwork, &T)>>
[src]
&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)>
[src]
&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)>
[src]
&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)>>
[src]
&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)>
[src]
&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)>
[src]
&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)>
[src]
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)>
[src]
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)>
[src]
Iterator for all IPv4 networks in table. Order is not guaranteed.
pub fn iter_ipv6(&self) -> impl Iterator<Item = (Ipv6Network, &T)>
[src]
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,
[src]
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>
[src]
fn default() -> IpNetworkTable<T>
[src]
Auto Trait Implementations
impl<T> RefUnwindSafe for IpNetworkTable<T> where
T: RefUnwindSafe,
T: RefUnwindSafe,
impl<T> Send for IpNetworkTable<T> where
T: Send,
T: Send,
impl<T> Sync for IpNetworkTable<T> where
T: Sync,
T: Sync,
impl<T> Unpin for IpNetworkTable<T>
impl<T> UnwindSafe for IpNetworkTable<T> where
T: RefUnwindSafe,
T: RefUnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,