Struct net_adds::Ipv6AddrRange

pub struct Ipv6AddrRange { /* fields omitted */ }

An IPv6 address range.

See crate::IpAddrRange for a type encompassing both IPv4 and IPv6 range.

The size of an Ipv6AddrRange struct may vary depending on the target operating system.

Textual representation

Ipv6AddrRange provides a FromStr implementation. The two parts are represented by Ipv6Addr and are separated by ‘-’.

Examples

use std::net::Ipv6Addr;

use net_adds::Ipv6AddrRange;

let a = Ipv6Addr::from(0x1);
let b = Ipv6Addr::from(0xA);
let range = Ipv6AddrRange::new(a, b);

assert_eq!(Ok(range), "::1-::A".parse());

Implementations

impl Ipv6AddrRange

pub fn new(start: Ipv6Addr, end: Ipv6Addr) -> Ipv6AddrRange

Returns an Ipv6AddrRange.

pub fn start(self) -> Ipv6Addr

Returns the first ip.

pub fn end(self) -> Ipv6Addr

Returns the last ip.

pub fn all(&self) -> Vec<Ipv6Addr>

Returns all ips included in the range.

Examples:

use std::net::Ipv6Addr;

use net_adds::Ipv6AddrRange;

let a = Ipv6Addr::from(0x1);
let b = Ipv6Addr::from(0x2);
let c = Ipv6Addr::from(0x3);

assert_eq!(Ipv6AddrRange::new(a, c).all(), vec![a, b, c]);
assert_eq!(Ipv6AddrRange::new(c, a).all(), vec![c, b, a]);
assert_eq!(Ipv6AddrRange::new(a, a).all(), vec![a]);

pub fn size(&self) -> u128

Returns the number of ip’s included in the range.

Examples:

use std::net::Ipv6Addr;

use net_adds::Ipv6AddrRange;

let a = Ipv6Addr::from(0x0);
let b = Ipv6Addr::from(0xA);

let range = Ipv6AddrRange::new(a, b);
assert_eq!(range.size(), 11);

let range = Ipv6AddrRange::new(b, a);
assert_eq!(range.size(), 11);

pub fn has(&self, ip: Ipv6Addr) -> bool

Returns true if the ip argument is included in the range, else returns false.

Examples:

use std::net::Ipv6Addr;

use net_adds::Ipv6AddrRange;

let a = Ipv6Addr::from(0x0);
let b = Ipv6Addr::from(0xA);

let range = Ipv6AddrRange::new(a, b);

assert!(range.has(Ipv6Addr::from(0x0)));
assert!(range.has(Ipv6Addr::from(0x2)));
assert!(range.has(Ipv6Addr::from(0xA)));

assert!(!range.has(Ipv6Addr::from(0xFFFF)));

let range = Ipv6AddrRange::new(b, a);

assert!(range.has(Ipv6Addr::from(0x0)));
assert!(range.has(Ipv6Addr::from(0x2)));
assert!(range.has(Ipv6Addr::from(0xA)));

assert!(!range.has(Ipv6Addr::from(0xFFFF)));

Trait Implementations

impl Clone for Ipv6AddrRange

fn clone(&self) -> Ipv6AddrRange

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Ipv6AddrRange

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

Formats the value using the given formatter.

impl Display for Ipv6AddrRange

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

Formats the value using the given formatter.

impl From<(Ipv6Addr, Ipv6Addr)> for Ipv6AddrRange

fn from(ips: (Ipv6Addr, Ipv6Addr)) -> Ipv6AddrRange

Create an Ipv6AddrRange from a tuple of two Ipv6Addr.

Examples:

use std::net::Ipv6Addr;

use net_adds::Ipv6AddrRange;

let start = Ipv6Addr::from(0x1);
let end = Ipv6Addr::from(0xA);

assert_eq!(Ipv6AddrRange::from((start, end)), Ipv6AddrRange::new(start, end));

impl From<Ipv6AddrRange> for IpAddrRange

fn from(range: Ipv6AddrRange) -> IpAddrRange

Create an IpAddrRange::V6 from an Ipv6AddrRange.

Examples:

use std::net::Ipv6Addr;

use net_adds::{IpAddrRange, Ipv6AddrRange};

let a = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0);
let b = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0xa);
let range = Ipv6AddrRange::new(a, b);

assert_eq!(IpAddrRange::from(range), IpAddrRange::V6(range));

impl FromStr for Ipv6AddrRange

fn from_str(s: &str) -> Result<Self, Self::Err>

Parse a string as Ipv6AddrRange.

If the string representation is not valid return an NetAddsError::RangeAddrParse(RangeAddrParseError).

Examples:

use std::net::Ipv6Addr;

use net_adds::Ipv6AddrRange;

let a = Ipv6Addr::new(0xFFFF, 0, 0, 0, 0, 0, 0, 0xFF);
let b = Ipv6Addr::new(0xFFFF, 0, 0, 0, 0, 0, 0, 0xFFFF);

assert_eq!("ffff::ff-ffff::ffff".parse(), Ok(Ipv6AddrRange::new(a, b)));
assert_eq!("ffff:0::ff-ffff::ffff".parse(), Ok(Ipv6AddrRange::new(a, b)));

type Err = NetAddsError

The associated error which can be returned from parsing.

impl Hash for Ipv6AddrRange

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl IntoIterator for Ipv6AddrRange

fn into_iter(self) -> Self::IntoIter

Create a Ipv6Addr iterator.

Examples:

use std::net::Ipv6Addr;

use net_adds::Ipv6AddrRange;

let a = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1);
let b = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 3);
let mut iter = Ipv6AddrRange::new(a, b).into_iter();

assert_eq!(iter.next(), Some(Ipv6Addr::from(1)));
assert_eq!(iter.next(), Some(Ipv6Addr::from(2)));
assert_eq!(iter.next(), Some(Ipv6Addr::from(3)));
assert_eq!(iter.next(), None);

type Item = Ipv6Addr

The type of the elements being iterated over.

type IntoIter = IntoIter<Self::Item>

Which kind of iterator are we turning this into?

impl IntoSmartIterator for Ipv6AddrRange

fn into_smart_iter(self) -> Self::IntoSmartIter

Create a smart Ipv6Addr iterator.

Examples:

use std::net::Ipv6Addr;

use net_adds::{Ipv6AddrRange, IntoSmartIterator};

let a = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1);
let b = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 3);
let mut iter = Ipv6AddrRange::new(a, b).into_smart_iter();

assert_eq!(iter.next(), Some(Ipv6Addr::from(1)));
assert_eq!(iter.next(), Some(Ipv6Addr::from(2)));
assert_eq!(iter.next(), Some(Ipv6Addr::from(3)));
assert_eq!(iter.next(), None);

type Item = Ipv6Addr

The type of the elements being iterated over.

type IntoSmartIter = Ipv6AddrSmartIterator

Which kind of iterator are we turning this into?

impl Ord for Ipv6AddrRange

fn cmp(&self, other: &Ipv6AddrRange) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl PartialEq<Ipv6AddrRange> for Ipv6AddrRange

fn eq(&self, other: &Ipv6AddrRange) -> bool

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

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

This method tests for !=.

impl PartialOrd<Ipv6AddrRange> for Ipv6AddrRange

fn partial_cmp(&self, other: &Ipv6AddrRange) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for Ipv6AddrRange

impl Eq for Ipv6AddrRange

impl StructuralEq for Ipv6AddrRange

impl StructuralPartialEq for Ipv6AddrRange