Struct ipnetwork::Ipv6Network

pub struct Ipv6Network { /* fields omitted */ }

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 fn with_netmask(
    netaddr: Ipv6Addr,
    netmask: Ipv6Addr
) -> Result<Self, 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.

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

Trait Implementations

impl Clone for Ipv6Network

fn clone(&self) -> Ipv6Network

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for Ipv6Network

impl Debug for Ipv6Network

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Ipv6Network

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Display for Ipv6Network

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

Formats the value using the given formatter.

impl Eq for Ipv6Network

impl From<Ipv6Addr> for Ipv6Network

fn from(a: Ipv6Addr) -> Ipv6Network

Performs the conversion.

impl From<Ipv6Network> for IpNetwork

fn from(v6: Ipv6Network) -> IpNetwork

Performs the conversion.

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<Self, Self::Err>

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

impl Hash for Ipv6Network

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

Feeds this value into the given Hasher.

pub 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 &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.

#[must_use]pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl PartialEq<Ipv6Network> for Ipv6Network

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

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

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

This method tests for !=.

impl PartialOrd<Ipv6Network> for Ipv6Network

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

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

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

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

#[must_use]pub fn le(&self, other: &Rhs) -> bool

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

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

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

#[must_use]pub 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 Serialize for Ipv6Network

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.

impl StructuralEq for Ipv6Network

impl StructuralPartialEq for Ipv6Network

impl TryFrom<&'_ str> for Ipv6Network

type Error = IpNetworkError

The type returned in the event of a conversion error.

fn try_from(s: &str) -> Result<Self, Self::Error>

Performs the conversion.