Struct Ipv6Network 

pub struct Ipv6Network { /* private fields */ }

Available on crate feature ipnetwork only.

Represents a network range where the IP addresses are of v6

Implementations

impl Ipv6Network

pub const fn new( addr: Ipv6Addr, prefix: u8, ) -> Result<Ipv6Network, IpNetworkError>

Constructs a new Ipv6Network from any Ipv6Addr and a prefix denoting the network size.

If the prefix is larger than 128 this will return an IpNetworkError::InvalidPrefix.

pub const fn new_checked(addr: Ipv6Addr, prefix: u8) -> Option<Ipv6Network>

Constructs a new Ipv6Network from any Ipv6Addr, and a prefix denoting the network size.

If the prefix is larger than 128 this will return None. This is useful in const contexts, where Option::unwrap may be called to trigger a compile-time error in case the prefix is an unexpected value.

Examples

use std::net::Ipv6Addr;
use ipnetwork::Ipv6Network;

const PREFIX: u8 = 64;
const ADDR: Ipv6Addr = Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0);

// Okay!
const NETWORK: Ipv6Network = Ipv6Network::new_checked(ADDR, PREFIX).unwrap();
assert_eq!(NETWORK.prefix(), PREFIX);

use std::net::Ipv6Addr;
use ipnetwork::Ipv6Network;

// Prefix is greater than 128.
const PREFIX: u8 = 128 + 1;
const ADDR: Ipv6Addr = Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0);

// This fails!
const NETWORK: Option<Ipv6Network> = Ipv6Network::new_checked(ADDR, PREFIX);
assert_eq!(NETWORK.unwrap().prefix(), PREFIX);

pub fn with_netmask( netaddr: Ipv6Addr, netmask: Ipv6Addr, ) -> Result<Ipv6Network, IpNetworkError>

Constructs a new Ipv6Network from a network address and a network mask.

If the netmask is not valid this will return an IpNetworkError::InvalidPrefix.

pub fn iter(&self) -> Ipv6NetworkIterator

Returns an iterator over Ipv6Network. Each call to next will return the next Ipv6Addr in the given network. None will be returned when there are no more addresses.

Warning

This can return up to 2^128 addresses, which will take a long time to iterate over.

pub fn ip(&self) -> Ipv6Addr

pub fn prefix(&self) -> u8

pub fn is_subnet_of(self, other: Ipv6Network) -> bool

Checks if the given Ipv6Network is a subnet of the other.

pub fn is_supernet_of(self, other: Ipv6Network) -> bool

Checks if the given Ipv6Network is a supernet of the other.

pub fn overlaps(self, other: Ipv6Network) -> bool

Checks if the given Ipv6Network is partly contained in other.

pub fn mask(&self) -> Ipv6Addr

Returns the mask for this Ipv6Network. That means the prefix most significant bits will be 1 and the rest 0

Examples

use std::net::Ipv6Addr;
use ipnetwork::Ipv6Network;

let net: Ipv6Network = "ff01::0".parse().unwrap();
assert_eq!(net.mask(), Ipv6Addr::new(0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff));
let net: Ipv6Network = "ff01::0/32".parse().unwrap();
assert_eq!(net.mask(), Ipv6Addr::new(0xffff, 0xffff, 0, 0, 0, 0, 0, 0));

pub fn network(&self) -> Ipv6Addr

Returns the address of the network denoted by this Ipv6Network. This means the lowest possible IPv6 address inside of the network.

Examples

use std::net::Ipv6Addr;
use ipnetwork::Ipv6Network;

let net: Ipv6Network = "2001:db8::/96".parse().unwrap();
assert_eq!(net.network(), Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0));

pub fn broadcast(&self) -> Ipv6Addr

Returns the broadcast address of this Ipv6Network. This means the highest possible IPv4 address inside of the network.

Examples

use std::net::Ipv6Addr;
use ipnetwork::Ipv6Network;

let net: Ipv6Network = "2001:db8::/96".parse().unwrap();
assert_eq!(net.broadcast(), Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0xffff, 0xffff));

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

Checks if a given Ipv6Addr is in this Ipv6Network

Examples

use std::net::Ipv6Addr;
use ipnetwork::Ipv6Network;

let net: Ipv6Network = "ff01::0/32".parse().unwrap();
assert!(net.contains(Ipv6Addr::new(0xff01, 0, 0, 0, 0, 0, 0, 0x1)));
assert!(!net.contains(Ipv6Addr::new(0xffff, 0, 0, 0, 0, 0, 0, 0x1)));

pub fn size(&self) -> u128

Returns number of possible host addresses in this Ipv6Network.

Examples

use std::net::Ipv6Addr;
use ipnetwork::Ipv6Network;

let net: Ipv6Network = "ff01::0/32".parse().unwrap();
assert_eq!(net.size(), 79228162514264337593543950336);

let tinynet: Ipv6Network = "ff01::0/128".parse().unwrap();
assert_eq!(tinynet.size(), 1);

pub fn nth(self, n: u128) -> Option<Ipv6Addr>

Returns the n:th address within this network. The addresses are indexed from 0 and n must be smaller than the size of the network.

Examples

use std::net::Ipv6Addr;
use ipnetwork::Ipv6Network;

let net: Ipv6Network = "ff01::0/32".parse().unwrap();
assert_eq!(net.nth(0).unwrap(), "ff01::0".parse::<Ipv6Addr>().unwrap());
assert_eq!(net.nth(255).unwrap(), "ff01::ff".parse::<Ipv6Addr>().unwrap());
assert_eq!(net.nth(65538).unwrap(), "ff01::1:2".parse::<Ipv6Addr>().unwrap());
assert!(net.nth(net.size()).is_none());

Trait Implementations

impl Clone for Ipv6Network

fn clone(&self) -> Ipv6Network

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Ipv6Network

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

Formats the value using the given formatter.

impl Display for Ipv6Network

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

Formats the value using the given formatter.

impl From<Ipv6Addr> for Ipv6Network

fn from(a: Ipv6Addr) -> Ipv6Network

Converts to this type from the input type.

impl From<Ipv6Network> for IpNetwork

fn from(v6: Ipv6Network) -> IpNetwork

Converts to this type from the input type.

impl FromStr for Ipv6Network

Creates an Ipv6Network from parsing a string in CIDR notation.

Examples

use std::net::Ipv6Addr;
use ipnetwork::Ipv6Network;

let new = Ipv6Network::new(Ipv6Addr::new(0xff01, 0, 0, 0x17, 0, 0, 0, 0x2), 65).unwrap();
let from_cidr: Ipv6Network = "FF01:0:0:17:0:0:0:2/65".parse().unwrap();
assert_eq!(new.ip(), from_cidr.ip());
assert_eq!(new.prefix(), from_cidr.prefix());

type Err = IpNetworkError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Ipv6Network, <Ipv6Network as FromStr>::Err>

Parses a string s to return a value of this type.

impl Hash for Ipv6Network

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

where __H: Hasher,

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl IntoIterator for &Ipv6Network

type IntoIter = Ipv6NetworkIterator

Which kind of iterator are we turning this into?

type Item = Ipv6Addr

The type of the elements being iterated over.

fn into_iter(self) -> Ipv6NetworkIterator

Creates an iterator from a value.

impl Ord for Ipv6Network

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Ipv6Network

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd for Ipv6Network

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl TryFrom<&str> for Ipv6Network

type Error = IpNetworkError

The type returned in the event of a conversion error.

fn try_from( s: &str, ) -> Result<Ipv6Network, <Ipv6Network as TryFrom<&str>>::Error>

Performs the conversion.

impl Copy for Ipv6Network

impl Eq for Ipv6Network

impl StructuralPartialEq for Ipv6Network