Struct ip_network::Ipv6Network

pub struct Ipv6Network { /* fields omitted */ }

IPv6 Network.

Methods

impl Ipv6Network

pub const LENGTH: u8

IPv4 address length in bits.

pub fn new(
    network_address: Ipv6Addr,
    netmask: u8
) -> Result<Self, IpNetworkError>

Constructs new Ipv6Network based on Ipv6Addr and netmask.

Returns error if netmask is bigger than 128 or if host bits are set in network_address.

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;

let ip = Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0);
let ip_network = Ipv6Network::new(ip, 32)?;
assert_eq!(ip_network.network_address(), ip);
assert_eq!(ip_network.netmask(), 32);

pub fn new_truncate(
    network_address: Ipv6Addr,
    netmask: u8
) -> Result<Self, IpNetworkError>

Constructs new Ipv6Network based on Ipv6Addr and netmask with truncating host bits from given network_address.

Returns error if netmask is bigger than 128.

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;

let ip = Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 1, 0, 0);
let ip_network = Ipv6Network::new_truncate(ip, 32)?;
assert_eq!(ip_network.network_address(), Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0));
assert_eq!(ip_network.netmask(), 32);

pub fn network_address(&self) -> Ipv6Addr

Returns network IP address (first address in range).

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;

let ip = Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0);
let ip_network = Ipv6Network::new(ip, 32)?;
assert_eq!(ip_network.network_address(), ip);

pub fn netmask(&self) -> u8

Returns network mask.

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;

let ip = Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0);
let ip_network = Ipv6Network::new(ip, 32)?;
assert_eq!(ip_network.netmask(), 32);

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

Returns true if given IPv6Addr is inside this network.

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;

let ip_network = Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0), 64)?;
assert!(ip_network.contains(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1)));
assert!(!ip_network.contains(Ipv6Addr::new(0x2001, 0xdb9, 0, 0, 0, 0, 0, 0)));

pub fn supernet(&self) -> Option<Self>

Returns network with smaller netmask by one. If netmask is already zero, None will be returned.

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;

let network = Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0), 32)?;
assert_eq!(network.supernet(), Some(Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0), 31)?));

Important traits for Ipv6NetworkIterator

impl Iterator for Ipv6NetworkIterator type Item = Ipv6Network;

pub fn subnets(&self) -> Ipv6NetworkIterator

Returns Ipv6NetworkIterator over networks with netmask bigger one. If netmask is already 128, empty iterator will be returned.

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;

let ip_network = Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0), 32)?;
let mut iterator = ip_network.subnets();
assert_eq!(iterator.next().unwrap(), Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0), 33)?);
assert_eq!(iterator.last().unwrap(), Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0x8000, 0, 0, 0, 0, 0), 33)?);

Important traits for Ipv6NetworkIterator

impl Iterator for Ipv6NetworkIterator type Item = Ipv6Network;

pub fn subnets_with_prefix(&self, prefix: u8) -> Ipv6NetworkIterator

Returns Ipv6NetworkIterator over networks with defined netmask. Because len() method returns usize and number of networks can be bigger than usize, you can use real_len() method to get exact number of networks.

Panics

This method panics when prefix is bigger than 128 or when prefix is lower or equal than netmask.

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;

let network = Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0), 32)?;
let mut iterator = network.subnets_with_prefix(33);
assert_eq!(2, iterator.real_len());
assert_eq!(iterator.next().unwrap(), Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0), 33)?);
assert_eq!(iterator.last().unwrap(), Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0x8000, 0, 0, 0, 0, 0), 33)?);

pub fn is_default_route(&self) -> bool

Returns true for the default route network (::/0), that contains all IPv6 addresses.

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;

assert!(Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0), 0)?.is_default_route());

pub fn is_unspecified(&self) -> bool

Returns true for the special 'unspecified' network (::/128).

This property is defined in IETF RFC 4291.

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;

assert!(!Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff), 128)?.is_unspecified());
assert!(Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0), 128)?.is_unspecified());

pub fn is_loopback(&self) -> bool

Returns true if this is a loopback network (::1/128).

This property is defined in IETF RFC 4291.

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;

assert!(Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0x1), 128)?.is_loopback());
assert!(!Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff), 128)?.is_loopback());

pub fn is_global(&self) -> bool

Returns true if the address appears to be globally routable.

The following return false:

• the loopback network
• link-local, site-local, and unique local unicast networks
• interface-, link-, realm-, admin- and site-local multicast networks

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;

assert!(Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff), 128)?.is_global());
assert!(!Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0x1), 128)?.is_global());
assert!(Ipv6Network::new(Ipv6Addr::new(0, 0, 0x1c9, 0, 0, 0xafc8, 0, 0x1), 128)?.is_global());

pub fn is_unique_local(&self) -> bool

Returns true if this is a part of unique local network (fc00::/7).

This property is defined in IETF RFC 4193.

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;

assert!(Ipv6Network::new(Ipv6Addr::new(0xfc02, 0, 0, 0, 0, 0, 0, 0), 16)?.is_unique_local());
assert!(!Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff), 128)?.is_unique_local());

pub fn is_unicast_link_local(&self) -> bool

Returns true if the network is part of unicast and link-local (fe80::/10).

This property is defined in IETF RFC 4291.

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;

assert!(Ipv6Network::new(Ipv6Addr::new(0xfe8a, 0, 0, 0, 0, 0, 0, 0), 16)?.is_unicast_link_local());
assert!(!Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff), 128)?.is_unicast_link_local());

pub fn is_unicast_site_local(&self) -> bool

Returns true if this is a deprecated unicast site-local network (fec0::/10).

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;

assert!(Ipv6Network::new(Ipv6Addr::new(0xfec2, 0, 0, 0, 0, 0, 0, 0), 16)?.is_unicast_site_local());
assert!(!Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff), 128)?.is_unicast_site_local());

pub fn is_documentation(&self) -> bool

Returns true if this is a part of network reserved for documentation (2001:db8::/32).

This property is defined in IETF RFC 3849.

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;

assert!(Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0), 32)?.is_documentation());
assert!(!Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff), 128)?.is_documentation());

pub fn is_unicast_global(&self) -> bool

Returns true if the network is a globally routable unicast network.

The following return false:

• the loopback network
• the link-local network
• the (deprecated) site-local network
• unique local network
• the unspecified network
• the network range reserved for documentation

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;

assert!(!Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0), 32)?.is_unicast_global());
assert!(Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff), 128)?.is_unicast_global());

pub fn is_multicast(&self) -> bool

Returns true if this is a part of multicast network (ff00::/8).

This property is defined by IETF RFC 4291.

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;

assert!(Ipv6Network::new(Ipv6Addr::new(0xff00, 0, 0, 0, 0, 0, 0, 0), 8)?.is_multicast());
assert!(!Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff), 128)?.is_multicast());

pub fn multicast_scope(&self) -> Option<Ipv6MulticastScope>

Returns the network's multicast scope if the network is multicast.

These scopes are defined in IETF RFC 7346.

Examples

use std::net::Ipv6Addr;
use ip_network::{Ipv6Network, Ipv6MulticastScope};

assert_eq!(Ipv6Network::new(Ipv6Addr::new(0xff0e, 0, 0, 0, 0, 0, 0, 0), 32)?.multicast_scope(),
                             Some(Ipv6MulticastScope::Global));
assert_eq!(Ipv6Network::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff), 128)?.multicast_scope(), None);

Trait Implementations

impl Copy for Ipv6Network

impl PartialEq<Ipv6Network> for IpNetwork

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

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

#[must_use]

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

This method tests for !=.

impl PartialEq<IpNetwork> for Ipv6Network

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

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

#[must_use]

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

This method tests for !=.

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 ==.

#[must_use]

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

This method tests for !=.

impl Clone for Ipv6Network

fn clone(&self) -> Ipv6Network

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl From<Ipv6Network> for IpNetwork

fn from(network: Ipv6Network) -> Self

Performs the conversion.

impl From<Ipv6Addr> for Ipv6Network

fn from(ip: Ipv6Addr) -> Self

Converts Ipv6Addr to Ipv6Network with netmask 128.

impl Eq for Ipv6Network

impl PartialOrd<Ipv6Network> for IpNetwork

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

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

#[must_use]

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

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

#[must_use]

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]

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

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

#[must_use]

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 PartialOrd<IpNetwork> for Ipv6Network

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

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

#[must_use]

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

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

#[must_use]

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]

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

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

#[must_use]

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

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

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

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

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

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

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

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

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

impl Display for Ipv6Network

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

Converts Ipv6Network to string in format X:X::X/Y (CIDR notation).

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;

let ip_network = Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0), 32)?;
assert_eq!(ip_network.to_string(), "2001:db8::/32");

impl Debug for Ipv6Network

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

Formats the value using the given formatter.

impl Hash for Ipv6Network

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 FromStr for Ipv6Network

type Err = IpNetworkParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Ipv6Network, IpNetworkParseError>

Converts string in format X:X::X/Y (CIDR notation) to Ipv6Network.

Examples

use std::net::Ipv6Addr;
use ip_network::Ipv6Network;
use std::str::FromStr;

let ip_network = Ipv6Network::from_str("2001:db8::/32")?;
assert_eq!(ip_network.network_address(), Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0));
assert_eq!(ip_network.netmask(), 32);

impl<'expr> AsExpression<Cidr> for &'expr Ipv6Network

type Expression = Bound<Cidr, Self>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

impl<'expr> AsExpression<Nullable<Cidr>> for &'expr Ipv6Network

type Expression = Bound<Nullable<Cidr>, Self>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

impl AsExpression<Cidr> for Ipv6Network

type Expression = Bound<Cidr, Self>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

impl AsExpression<Nullable<Cidr>> for Ipv6Network

type Expression = Bound<Nullable<Cidr>, Self>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

impl<__ST, __DB> Queryable<__ST, __DB> for Ipv6Network where
    __DB: Backend,
    Self: FromSql<__ST, __DB>, 

type Row = Self

The Rust type you'd like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

impl ToSql<Cidr, Pg> for Ipv6Network

fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> Result

See the trait documentation.

impl<__DB> ToSql<Nullable<Cidr>, __DB> for Ipv6Network where
    __DB: Backend,
    Self: ToSql<Cidr, __DB>, 

fn to_sql<W: Write>(&self, out: &mut Output<W, __DB>) -> Result

See the trait documentation.

impl FromSql<Cidr, Pg> for Ipv6Network

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

impl<__ST, __DB> FromSqlRow<__ST, __DB> for Ipv6Network where
    __DB: Backend,
    Self: FromSql<__ST, __DB>, 

fn build_from_row<R: Row<__DB>>(row: &mut R) -> Result<Self>

See the trait documentation.

const FIELDS_NEEDED: usize

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

impl ToSql for Ipv6Network

fn to_sql(
    &self,
    _: &Type,
    w: &mut Vec<u8>
) -> Result<IsNull, Box<dyn Error + Sync + Send>>

Converts the value of self into the binary format of the specified Postgres Type, appending it to out.

fn accepts(ty: &Type) -> bool

Determines if a value of this type can be converted to the specified Postgres Type.

fn to_sql_checked(
    &self,
    ty: &Type,
    out: &mut Vec<u8>
) -> Result<IsNull, Box<dyn Error + Sync + Send>>

An adaptor method used internally by Rust-Postgres.

impl FromSql for Ipv6Network

fn from_sql(
    _: &Type,
    raw: &[u8]
) -> Result<Ipv6Network, Box<dyn Error + Sync + Send>>

Creates a new value of this type from a buffer of data of the specified Postgres Type in its binary format.

fn accepts(ty: &Type) -> bool

Determines if a value of this type can be created from the specified Postgres Type.

fn from_sql_null(
    ty: &Type
) -> Result<Self, Box<dyn Error + 'static + Sync + Send>>

Creates a new value of this type from a NULL SQL value.

fn from_sql_nullable(
    ty: &Type,
    raw: Option<&[u8]>
) -> Result<Self, Box<dyn Error + 'static + Sync + Send>>

A convenience function that delegates to from_sql and from_sql_null depending on the value of raw.

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<'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.