Struct iprange::IpRange

pub struct IpRange<N: IpNet> { /* private fields */ }

A set of networks that supports various operations:

• add
• remove
• contains
• merge
• intersect
• exclude

IntoIter is implemented for &IpRange. So, you can use for to iterate over the networks in an IpRange:

extern crate ipnet;
extern crate iprange;

use iprange::IpRange;
use ipnet::Ipv4Net;

fn main() {
    let ip_range: IpRange<Ipv4Net> = ["172.16.0.0/16", "192.168.1.0/24"]
        .iter()
        .map(|s| s.parse().unwrap())
        .collect();

    for network in &ip_range {
        println!("{:?}", network);
    }
}

Implementations

impl<N: IpNet> IpRange<N>

pub fn new() -> IpRange<N>

Creates an empty IpRange.

pub fn add(&mut self, network: N) -> &mut Self

Add a network to self.

Returns &mut self in order to enable method chaining.

Pay attention that this operation will not combine two networks automatically. To do this, call simplify method explicitly. For example:

extern crate iprange;
extern crate ipnet;

use iprange::IpRange;
use ipnet::Ipv4Net;

fn main() {
    let mut ip_range: IpRange<Ipv4Net> = IpRange::new();
    ip_range.add("192.168.0.0/24".parse().unwrap())
           .add("192.168.1.0/24".parse().unwrap());
    assert_eq!(ip_range.into_iter().count(), 2);

    ip_range.simplify();
    assert_eq!(ip_range.into_iter().count(), 1);
}

pub fn remove(&mut self, network: N) -> &mut Self

Remove a network from self.

Returns &mut self in order to enable method chaining.

self does not necessarily has exactly the network to be removed. The network can be a networkwork of a network in self. This method will do splitting and remove the corresponding network. For example:

extern crate iprange;
extern crate ipnet;

use iprange::IpRange;
use ipnet::Ipv4Net;

fn main() {
    let mut ip_range: IpRange<Ipv4Net> = IpRange::new();
    ip_range.add("192.168.0.0/23".parse().unwrap())
            .remove("192.168.0.0/24".parse().unwrap());
    // Now, ip_range has only one network: "192.168.1.0/24".
}

pub fn simplify(&mut self)

Simplify self by combining networks. For example:

extern crate iprange;
extern crate ipnet;

use iprange::IpRange;
use ipnet::Ipv4Net;

fn main() {
    let mut ip_range: IpRange<Ipv4Net> = IpRange::new();
    ip_range
        .add("192.168.0.0/20".parse().unwrap())
        .add("192.168.16.0/22".parse().unwrap())
        .add("192.168.20.0/24".parse().unwrap())
        .add("192.168.21.0/24".parse().unwrap())
        .add("192.168.22.0/24".parse().unwrap())
        .add("192.168.23.0/24".parse().unwrap())
        .add("192.168.24.0/21".parse().unwrap())
        .simplify();
    // Now, ip_range has only one network: "192.168.0.0/19".
}

pub fn merge(&self, other: &IpRange<N>) -> Self

Returns a new IpRange which contains all networks that is either in self or in other.

The returned IpRange is simplified.

pub fn intersect(&self, other: &IpRange<N>) -> Self

Returns a new IpRange which contains all networks that is in both self and other.

The returned IpRange is simplified.

pub fn exclude(&self, other: &IpRange<N>) -> IpRange<N>

Returns a new IpRange which contains all networks that is in self while not in other.

The returned IpRange is simplified.

pub fn contains<T: ToNetwork<N>>(&self, network: &T) -> bool

Tests if self contains network.

network is anything that can be converted into N. See ToNetwork<N> for detail.

pub fn supernet<T: ToNetwork<N>>(&self, network: &T) -> Option<N>

Returns the network in self which is the supernetwork of network.

Returns None if no network in self contains network.

pub fn iter(&self) -> IpRangeIter<N>

Returns the iterator to &self.

Trait Implementations

impl<N: Clone + IpNet> Clone for IpRange<N>

fn clone(&self) -> IpRange<N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N: IpNet> Debug for IpRange<N>

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

Formats the value using the given formatter.

impl<N> Default for IpRange<N>where
    N: IpNet + ToNetwork<N> + Clone,

fn default() -> Self

Returns the “default value” for a type.

impl<N> FromIterator<N> for IpRange<N>where
    N: IpNet + ToNetwork<N> + Clone,

fn from_iter<T>(iter: T) -> Selfwhere
    T: IntoIterator<Item = N>,

Creates a value from an iterator.

impl<'a, N> IntoIterator for &'a IpRange<N>where
    N: IpNet + ToNetwork<N> + Clone,

type Item = N

The type of the elements being iterated over.

type IntoIter = IpRangeIter<N>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<N: PartialEq + IpNet> PartialEq<IpRange<N>> for IpRange<N>

fn eq(&self, other: &IpRange<N>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<N: Eq + IpNet> Eq for IpRange<N>

impl<N: IpNet> StructuralEq for IpRange<N>

impl<N: IpNet> StructuralPartialEq for IpRange<N>