Struct iprange::IpRange

pub struct IpRange<N> where
    N: IpNet + ToNetwork<N> + Clone,  { /* fields omitted */ }

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);
    }
}

Methods

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

fn new() -> IpRange<N>

Creates an empty IpRange.

fn add(&mut self, network: N) -> &mut IpRange<N>

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);
}

fn remove(&mut self, network: N) -> &mut IpRange<N>

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".
}

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".
}

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

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

The returned IpRange is simplified.

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

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

The returned IpRange is simplified.

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.

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.

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.

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

Returns the iterator to &self.

Trait Implementations

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

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: Debug> Debug for IpRange<N> where
    N: IpNet + ToNetwork<N> + Clone, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

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

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

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

fn ne(&self, __arg_0: &IpRange<N>) -> bool

This method tests for !=.

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

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> FromIterator<N> for IpRange<N> where
    N: IpNet + ToNetwork<N> + Clone, 

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

Creates a value from an iterator.