Trait ip::traits::PrefixRange

pub trait PrefixRange: Clone + Debug + Display + From<Self::Prefix> + FromStr<Err = Error> + Hash + IntoIterator<Item = Self::Prefix> + PartialEq + Eq + PartialOrd {
    type Prefix: Prefix<Length = Self::Length>;
    type Length: Length;

    // Required methods
    fn prefix(&self) -> Self::Prefix;
    fn lower(&self) -> Self::Length;
    fn upper(&self) -> Self::Length;
    fn with_intersection(
        self,
        len_range: RangeInclusive<Self::Length>
    ) -> Option<Self>;
    fn with_length_range(
        self,
        len_range: RangeInclusive<Self::Length>
    ) -> Option<Self>;

    // Provided methods
    fn or_longer(self) -> Self { ... }
    fn or_longer_excl(self) -> Option<Self> { ... }
    fn with_length(self, len: Self::Length) -> Option<Self> { ... }
    fn afi(&self) -> Afi { ... }
    fn new_prefix_length(&self, length: u8) -> Result<Self::Length, Error> { ... }
}

Address-family independent interface for IP prefix ranges.

See also concrete::PrefixRange<A> and any::PrefixRange for address-family specific items.

Required Associated Types

type Prefix: Prefix<Length = Self::Length>

The type of IP prefix over which Self represents a range.

type Length: Length

The type used to represent lengths for this IP prefix type.

Required Methods

fn prefix(&self) -> Self::Prefix

Return the covering super-prefix of self.

fn lower(&self) -> Self::Length

Return the lower bound Self::Length of self.

fn upper(&self) -> Self::Length

Return the upper bound Self::Length of self.

fn with_intersection( self, len_range: RangeInclusive<Self::Length> ) -> Option<Self>

Construct a new IP prefix-range from the intersection of self and len_range.

Examples

use ip::{traits::PrefixRange as _, Ipv6, Prefix, PrefixLength, PrefixRange};

let lower = PrefixLength::<Ipv6>::from_primitive(52)?;
let upper = PrefixLength::<Ipv6>::from_primitive(56)?;

let x: PrefixRange<Ipv6> = "2001:db8::/48".parse::<Prefix<Ipv6>>()?.into();
assert_eq!(x.with_intersection(lower..=upper).into_iter().count(), 0,);

let y: PrefixRange<Ipv6> = "2001:db8::/54".parse::<Prefix<Ipv6>>()?.into();
assert_eq!(y.with_intersection(lower..=upper).into_iter().count(), 1,);

fn with_length_range( self, len_range: RangeInclusive<Self::Length> ) -> Option<Self>

Construct a new IP prefix-range consisting of all the more specific subprefixes of self with prefix-lengths within len_range.

Examples

use core::cmp::max;

use ip::{traits::PrefixRange as _, Address, Ipv4, Prefix, PrefixLength, PrefixRange};

let addr = "192.0.2.0".parse::<Address<Ipv4>>()?;

let [l, m, n, p, q]: &[PrefixLength<Ipv4>] = &[24u8, 26, 28, 30, 32].into_iter()
    .map(PrefixLength::<Ipv4>::from_primitive)
    .collect::<Result<Vec<PrefixLength<Ipv4>>, _>>()? else { panic!() };

let prefix = Prefix::<Ipv4>::new(addr, *l);

assert_eq!(
    PrefixRange::<Ipv4>::new(prefix, *m..=*n)?
        .with_length_range(*p..=*q)
        .unwrap(),
    PrefixRange::<Ipv4>::new(prefix, max(*m, *p)..=*q)?,
);

Provided Methods

fn or_longer(self) -> Self

Construct a new IP prefix-range consisting of all the more-specific sub-prefixes of self.

Examples

use ip::{traits::PrefixRange as _, Any, Prefix, PrefixRange};

let range: PrefixRange<Any> = "2001:db8::/126".parse::<Prefix<Any>>()?.into();

assert_eq!(range.or_longer().into_iter().count(), 7,);

fn or_longer_excl(self) -> Option<Self>

Construct a new IP prefix-range consisting of all the strictly more-specific sub-prefixes of self.

Examples

use ip::{traits::PrefixRange as _, Any, Prefix, PrefixRange};

let x: PrefixRange<Any> = "192.0.2.0/24,25,27".parse()?;
let y: PrefixRange<Any> = "192.0.2.0/24,26,32".parse()?;

assert_eq!(x.or_longer_excl().unwrap(), y);

fn with_length(self, len: Self::Length) -> Option<Self>

Construct a new IP prefix-range consisting of all the more-specific sub-prefixes of self of length len.

Examples

use ip::{traits::PrefixRange as _, Any, Ipv6, Prefix, PrefixLength, PrefixRange};

let range: PrefixRange<Any> = "2001:db8::/32".parse::<Prefix<Any>>()?.into();
let len = PrefixLength::<Ipv6>::from_primitive(48)?.into();

assert_eq!(range.with_length(len).unwrap().into_iter().count(), 1 << 16,);

fn afi(&self) -> Afi

Returns the address-family associated with this IP prefix-range.

Examples

use ip::{traits::PrefixRange as _, Any, PrefixRange};

let range: PrefixRange<Any> = "2001:db8::/32,48,64".parse()?;

assert_eq!(range.afi().to_string(), "ipv6");

fn new_prefix_length(&self, length: u8) -> Result<Self::Length, Error>

Try to construct a new Self::Length for the address-family associated with this IP prefix-range.

Errors

Fails when length is outside of the bounds of prefix-lengths of the address-family.

Examples

use ip::{traits::PrefixRange as _, Any, Ipv4, PrefixLength, PrefixRange};

let range: PrefixRange<Any> = "192.0.2.0/24,26,28".parse()?;

assert_eq!(
    range.new_prefix_length(30)?,
    PrefixLength::<Ipv4>::from_primitive(30)?.into(),
);

Implementors

impl Range for ip::any::PrefixRange

type Prefix = Prefix

type Length = Length

impl<A: Afi> Range for ip::concrete::PrefixRange<A>

type Prefix = Prefix<A>

type Length = PrefixLength<A>