W3cubDocs

/Rust

Struct std::net::Ipv6Addr

pub struct Ipv6Addr { /* fields omitted */ }

An IPv6 address.

IPv6 addresses are defined as 128-bit integers in IETF RFC 4291. They are usually represented as eight 16-bit segments.

See IpAddr for a type encompassing both IPv4 and IPv6 addresses.

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

Textual representation

Ipv6Addr provides a FromStr implementation. There are many ways to represent an IPv6 address in text, but in general, each segments is written in hexadecimal notation, and segments are separated by :. For more information, see IETF RFC 5952.

Examples

use std::net::Ipv6Addr;

let localhost = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1);
assert_eq!("::1".parse(), Ok(localhost));
assert_eq!(localhost.is_loopback(), true);

Implementations

`impl Ipv6Addr`[src]

`pub const fn new( a: u16, b: u16, c: u16, d: u16, e: u16, f: u16, g: u16, h: u16 ) -> Ipv6Addr`[src]

Creates a new IPv6 address from eight 16-bit segments.

The result will represent the IP address a:b:c:d:e:f:g:h.

Examples

use std::net::Ipv6Addr;

let addr = Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff);

`pub const LOCALHOST: Self`[src]1.30.0

An IPv6 address representing localhost: ::1.

Examples

use std::net::Ipv6Addr;

let addr = Ipv6Addr::LOCALHOST;
assert_eq!(addr, Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1));

`pub const UNSPECIFIED: Self`[src]1.30.0

An IPv6 address representing the unspecified address: ::

Examples

use std::net::Ipv6Addr;

let addr = Ipv6Addr::UNSPECIFIED;
assert_eq!(addr, Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0));

`pub fn segments(&self) -> [u16; 8]`[src]

Returns the eight 16-bit segments that make up this address.

Examples

use std::net::Ipv6Addr;

assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).segments(),
           [0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff]);

`pub fn is_unspecified(&self) -> bool`[src]1.7.0

Returns true for the special 'unspecified' address (::).

This property is defined in IETF RFC 4291.

Examples

use std::net::Ipv6Addr;

assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_unspecified(), false);
assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0).is_unspecified(), true);

`pub fn is_loopback(&self) -> bool`[src]1.7.0

Returns true if this is a loopback address (::1).

This property is defined in IETF RFC 4291.

Examples

use std::net::Ipv6Addr;

assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_loopback(), false);
assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0x1).is_loopback(), true);

`pub fn is_global(&self) -> bool`[src]

🔬 This is a nightly-only experimental API. (ip #27709)extra functionality has not been scrutinized to the level that it should be to be stable

Returns true if the address appears to be globally routable.

The following return false:

the loopback address
link-local and unique local unicast addresses
interface-, link-, realm-, admin- and site-local multicast addresses

Examples

#![feature(ip)]

use std::net::Ipv6Addr;

assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_global(), true);
assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0x1).is_global(), false);
assert_eq!(Ipv6Addr::new(0, 0, 0x1c9, 0, 0, 0xafc8, 0, 0x1).is_global(), true);

`pub fn is_unique_local(&self) -> bool`[src]

🔬 This is a nightly-only experimental API. (ip #27709)extra functionality has not been scrutinized to the level that it should be to be stable

Returns true if this is a unique local address (fc00::/7).

This property is defined in IETF RFC 4193.

Examples

#![feature(ip)]

use std::net::Ipv6Addr;

assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_unique_local(), false);
assert_eq!(Ipv6Addr::new(0xfc02, 0, 0, 0, 0, 0, 0, 0).is_unique_local(), true);

`pub fn is_unicast_link_local_strict(&self) -> bool`[src]

🔬 This is a nightly-only experimental API. (ip #27709)extra functionality has not been scrutinized to the level that it should be to be stable

Returns true if the address is a unicast link-local address (fe80::/64).

A common mis-conception is to think that "unicast link-local addresses start with fe80::", but the IETF RFC 4291 actually defines a stricter format for these addresses:

|   10     |
|  bits    |         54 bits         |          64 bits           |
+----------+-------------------------+----------------------------+
|1111111010|           0             |       interface ID         |
+----------+-------------------------+----------------------------+

This method validates the format defined in the RFC and won't recognize the following addresses such as fe80:0:0:1:: or fe81:: as unicast link-local addresses for example. If you need a less strict validation use Ipv6Addr::is_unicast_link_local() instead.

Examples

#![feature(ip)]

use std::net::Ipv6Addr;

let ip = Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0);
assert!(ip.is_unicast_link_local_strict());

let ip = Ipv6Addr::new(0xfe80, 0, 0, 0, 0xffff, 0xffff, 0xffff, 0xffff);
assert!(ip.is_unicast_link_local_strict());

let ip = Ipv6Addr::new(0xfe80, 0, 0, 1, 0, 0, 0, 0);
assert!(!ip.is_unicast_link_local_strict());
assert!(ip.is_unicast_link_local());

let ip = Ipv6Addr::new(0xfe81, 0, 0, 0, 0, 0, 0, 0);
assert!(!ip.is_unicast_link_local_strict());
assert!(ip.is_unicast_link_local());

Examples

#![feature(ip)]

use std::net::Ipv6Addr;

let ip = Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0);
assert!(ip.is_unicast_link_local());

let ip = Ipv6Addr::new(0xfe80, 0, 0, 0, 0xffff, 0xffff, 0xffff, 0xffff);
assert!(ip.is_unicast_link_local());

let ip = Ipv6Addr::new(0xfe80, 0, 0, 1, 0, 0, 0, 0);
assert!(ip.is_unicast_link_local());
assert!(!ip.is_unicast_link_local_strict());

let ip = Ipv6Addr::new(0xfe81, 0, 0, 0, 0, 0, 0, 0);
assert!(ip.is_unicast_link_local());
assert!(!ip.is_unicast_link_local_strict());

Examples

#![feature(ip)]

use std::net::Ipv6Addr;

assert_eq!(
    Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_unicast_site_local(),
    false
);
assert_eq!(Ipv6Addr::new(0xfec2, 0, 0, 0, 0, 0, 0, 0).is_unicast_site_local(), true);

Warning

As per RFC 3879, the whole FEC0::/10 prefix is deprecated. New software must not support site-local addresses.

`pub fn is_documentation(&self) -> bool`[src]

🔬 This is a nightly-only experimental API. (ip #27709)extra functionality has not been scrutinized to the level that it should be to be stable

Returns true if this is an address reserved for documentation (2001:db8::/32).

This property is defined in IETF RFC 3849.

Examples

#![feature(ip)]

use std::net::Ipv6Addr;

assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_documentation(), false);
assert_eq!(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0).is_documentation(), true);

`pub fn is_unicast_global(&self) -> bool`[src]

🔬 This is a nightly-only experimental API. (ip #27709)extra functionality has not been scrutinized to the level that it should be to be stable

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

The following return false:

the loopback address
the link-local addresses
unique local addresses
the unspecified address
the address range reserved for documentation

This method returns true for site-local addresses as per RFC 4291 section 2.5.7

The special behavior of [the site-local unicast] prefix defined in [RFC3513] must no longer
be supported in new implementations (i.e., new implementations must treat this prefix as
Global Unicast).

Examples

#![feature(ip)]

use std::net::Ipv6Addr;

assert_eq!(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0).is_unicast_global(), false);
assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_unicast_global(), true);

`pub fn multicast_scope(&self) -> Option<Ipv6MulticastScope>`[src]

🔬 This is a nightly-only experimental API. (ip #27709)extra functionality has not been scrutinized to the level that it should be to be stable

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

Examples

#![feature(ip)]

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

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

`pub fn is_multicast(&self) -> bool`[src]1.7.0

Returns true if this is a multicast address (ff00::/8).

This property is defined by IETF RFC 4291.

Examples

use std::net::Ipv6Addr;

assert_eq!(Ipv6Addr::new(0xff00, 0, 0, 0, 0, 0, 0, 0).is_multicast(), true);
assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_multicast(), false);

`pub fn to_ipv4_mapped(&self) -> Option<Ipv4Addr>`[src]

🔬 This is a nightly-only experimental API. (ip #27709)extra functionality has not been scrutinized to the level that it should be to be stable

Converts this address to an IPv4 address if it's an "IPv4-mapped IPv6 address" defined in IETF RFC 4291 section 2.5.5.2, otherwise returns None.

::ffff:a.b.c.d becomes a.b.c.d. All addresses not starting with ::ffff will return None.

Examples

#![feature(ip)]

use std::net::{Ipv4Addr, Ipv6Addr};

assert_eq!(Ipv6Addr::new(0xff00, 0, 0, 0, 0, 0, 0, 0).to_ipv4_mapped(), None);
assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).to_ipv4_mapped(),
           Some(Ipv4Addr::new(192, 10, 2, 255)));
assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).to_ipv4_mapped(), None);

`pub fn to_ipv4(&self) -> Option<Ipv4Addr>`[src]

Converts this address to an IPv4 address. Returns None if this address is neither IPv4-compatible or IPv4-mapped.

::a.b.c.d and ::ffff:a.b.c.d become a.b.c.d

Examples

use std::net::{Ipv4Addr, Ipv6Addr};

assert_eq!(Ipv6Addr::new(0xff00, 0, 0, 0, 0, 0, 0, 0).to_ipv4(), None);
assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).to_ipv4(),
           Some(Ipv4Addr::new(192, 10, 2, 255)));
assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).to_ipv4(),
           Some(Ipv4Addr::new(0, 0, 0, 1)));

`pub const fn octets(&self) -> [u8; 16]`[src]1.12.0

Returns the sixteen eight-bit integers the IPv6 address consists of.

use std::net::Ipv6Addr;

assert_eq!(Ipv6Addr::new(0xff00, 0, 0, 0, 0, 0, 0, 0).octets(),
           [255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);

Trait Implementations

`impl Clone for Ipv6Addr`[src]

`fn clone(&self) -> Ipv6Addr`[src]

`fn clone_from(&mut self, source: &Self)`[src]

`impl Copy for Ipv6Addr`[src]

`impl Debug for Ipv6Addr`[src]

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

`impl Display for Ipv6Addr`[src]

Write an Ipv6Addr, conforming to the canonical style described by RFC 5952.

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

`impl Eq for Ipv6Addr`[src]

`impl From<[u16; 8]> for Ipv6Addr`[src]1.16.0

`fn from(segments: [u16; 8]) -> Ipv6Addr`[src]

Creates an Ipv6Addr from an eight element 16-bit array.

Examples

use std::net::Ipv6Addr;

let addr = Ipv6Addr::from([
    525u16, 524u16, 523u16, 522u16,
    521u16, 520u16, 519u16, 518u16,
]);
assert_eq!(
    Ipv6Addr::new(
        0x20d, 0x20c,
        0x20b, 0x20a,
        0x209, 0x208,
        0x207, 0x206
    ),
    addr
);

`impl From<[u8; 16]> for Ipv6Addr`[src]1.9.0

`fn from(octets: [u8; 16]) -> Ipv6Addr`[src]

Creates an Ipv6Addr from a sixteen element byte array.

Examples

use std::net::Ipv6Addr;

let addr = Ipv6Addr::from([
    25u8, 24u8, 23u8, 22u8, 21u8, 20u8, 19u8, 18u8,
    17u8, 16u8, 15u8, 14u8, 13u8, 12u8, 11u8, 10u8,
]);
assert_eq!(
    Ipv6Addr::new(
        0x1918, 0x1716,
        0x1514, 0x1312,
        0x1110, 0x0f0e,
        0x0d0c, 0x0b0a
    ),
    addr
);

`impl From<Ipv6Addr> for IpAddr`[src]1.16.0

`fn from(ipv6: Ipv6Addr) -> IpAddr`[src]

Copies this address to a new IpAddr::V6.

Examples

use std::net::{IpAddr, Ipv6Addr};

let addr = Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff);

assert_eq!(
    IpAddr::V6(addr),
    IpAddr::from(addr)
);

`impl From<Ipv6Addr> for u128`[src]1.26.0

`fn from(ip: Ipv6Addr) -> u128`[src]

Convert an Ipv6Addr into a host byte order u128.

Examples

use std::net::Ipv6Addr;

let addr = Ipv6Addr::new(
    0x1020, 0x3040, 0x5060, 0x7080,
    0x90A0, 0xB0C0, 0xD0E0, 0xF00D,
);
assert_eq!(0x102030405060708090A0B0C0D0E0F00D_u128, u128::from(addr));

`impl From<u128> for Ipv6Addr`[src]1.26.0

`fn from(ip: u128) -> Ipv6Addr`[src]

Convert a host byte order u128 into an Ipv6Addr.

Examples

use std::net::Ipv6Addr;

let addr = Ipv6Addr::from(0x102030405060708090A0B0C0D0E0F00D_u128);
assert_eq!(
    Ipv6Addr::new(
        0x1020, 0x3040, 0x5060, 0x7080,
        0x90A0, 0xB0C0, 0xD0E0, 0xF00D,
    ),
    addr);

`impl FromStr for Ipv6Addr`[src]

`type Err = AddrParseError`

The associated error which can be returned from parsing.

`fn from_str(s: &str) -> Result<Ipv6Addr, AddrParseError>`[src]

`impl Hash for Ipv6Addr`[src]

`fn hash<H: Hasher>(&self, s: &mut H)`[src]

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

`impl Ord for Ipv6Addr`[src]

`fn cmp(&self, other: &Ipv6Addr) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl PartialEq<IpAddr> for Ipv6Addr`[src]1.16.0

`fn eq(&self, other: &IpAddr) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl PartialEq<Ipv6Addr> for Ipv6Addr`[src]

`fn eq(&self, other: &Ipv6Addr) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl PartialEq<Ipv6Addr> for IpAddr`[src]1.16.0

`fn eq(&self, other: &Ipv6Addr) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl PartialOrd<IpAddr> for Ipv6Addr`[src]1.16.0

`fn partial_cmp(&self, other: &IpAddr) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl PartialOrd<Ipv6Addr> for Ipv6Addr`[src]

`fn partial_cmp(&self, other: &Ipv6Addr) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl PartialOrd<Ipv6Addr> for IpAddr`[src]1.16.0

`fn partial_cmp(&self, other: &Ipv6Addr) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

Auto Trait Implementations

`impl RefUnwindSafe for Ipv6Addr`

`impl Send for Ipv6Addr`

`impl Sync for Ipv6Addr`

`impl Unpin for Ipv6Addr`

`impl UnwindSafe for Ipv6Addr`

Blanket Implementations

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

fn borrow(&self) -> &TⓘNotable traits for &'_ mut F
impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized, 
    type Output = <F as Future>::Output;
impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized, 
    type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized, '_> Read for &'_ mut R
impl<W: Write + ?Sized, '_> Write for &'_ mut W

[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

fn borrow_mut(&mut self) -> &mut TⓘNotable traits for &'_ mut F
impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized, 
    type Output = <F as Future>::Output;
impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized, 
    type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized, '_> Read for &'_ mut R
impl<W: Write + ?Sized, '_> Write for &'_ mut W

[src]

`impl<T> From<T> for T`[src]

`fn from(t: T) -> T`[src]

`impl<T, U> Into for T where U: From<T>,` [src]

`fn into(self) -> U`[src]

`impl<T> ToOwned for T where T: Clone,` [src]

`type Owned = T`

The resulting type after obtaining ownership.

`fn to_owned(&self) -> T`[src]

`fn clone_into(&self, target: &mut T)`[src]

`impl<T> ToString for T where T: Display + ?Sized,` [src]

`default fn to_string(&self) -> String`[src]

`impl<T, U> TryFrom for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>`[src]

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = >::Error`

The type returned in the event of a conversion error.

`fn try_into(self) -> Result<U, >::Error>`[src]

© 2010 The Rust Project Developers
Licensed under the Apache License, Version 2.0 or the MIT license, at your option.
https://doc.rust-lang.org/std/net/struct.Ipv6Addr.html

Struct std::net::Ipv6Addr

Textual representation

Examples

Implementations

impl Ipv6Addr[src]

pub const fn new( a: u16, b: u16, c: u16, d: u16, e: u16, f: u16, g: u16, h: u16) -> Ipv6Addr[src]

Examples

pub const LOCALHOST: Self[src]1.30.0

Examples

pub const UNSPECIFIED: Self[src]1.30.0

Examples

pub fn segments(&self) -> [u16; 8][src]

Examples

pub fn is_unspecified(&self) -> bool[src]1.7.0

Examples

pub fn is_loopback(&self) -> bool[src]1.7.0

Examples

pub fn is_global(&self) -> bool[src]

Examples

pub fn is_unique_local(&self) -> bool[src]

Examples

pub fn is_unicast_link_local_strict(&self) -> bool[src]

Examples

See also

pub fn is_unicast_link_local(&self) -> bool[src]

Examples

See also

pub fn is_unicast_site_local(&self) -> bool[src]

Examples

Warning

pub fn is_documentation(&self) -> bool[src]

Examples

pub fn is_unicast_global(&self) -> bool[src]

Examples

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

Examples

pub fn is_multicast(&self) -> bool[src]1.7.0

Examples

pub fn to_ipv4_mapped(&self) -> Option<Ipv4Addr>[src]

Examples

pub fn to_ipv4(&self) -> Option<Ipv4Addr>[src]

Examples

pub const fn octets(&self) -> [u8; 16][src]1.12.0

Trait Implementations

impl Clone for Ipv6Addr[src]

fn clone(&self) -> Ipv6Addr[src]

fn clone_from(&mut self, source: &Self)[src]

impl Copy for Ipv6Addr[src]

impl Debug for Ipv6Addr[src]

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

impl Display for Ipv6Addr[src]

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

impl Eq for Ipv6Addr[src]

impl From<[u16; 8]> for Ipv6Addr[src]1.16.0

fn from(segments: [u16; 8]) -> Ipv6Addr[src]

Examples

impl From<[u8; 16]> for Ipv6Addr[src]1.9.0

fn from(octets: [u8; 16]) -> Ipv6Addr[src]

Examples

impl From<Ipv6Addr> for IpAddr[src]1.16.0

fn from(ipv6: Ipv6Addr) -> IpAddr[src]

Examples

impl From<Ipv6Addr> for u128[src]1.26.0

fn from(ip: Ipv6Addr) -> u128[src]

Examples

impl From<u128> for Ipv6Addr[src]1.26.0

fn from(ip: u128) -> Ipv6Addr[src]

Examples

impl FromStr for Ipv6Addr[src]

type Err = AddrParseError

fn from_str(s: &str) -> Result<Ipv6Addr, AddrParseError>[src]

impl Hash for Ipv6Addr[src]

fn hash<H: Hasher>(&self, s: &mut H)[src]

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

impl Ord for Ipv6Addr[src]

fn cmp(&self, other: &Ipv6Addr) -> Ordering[src]

fn max(self, other: Self) -> Self[src]1.21.0

fn min(self, other: Self) -> Self[src]1.21.0

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

impl PartialEq<IpAddr> for Ipv6Addr[src]1.16.0

`impl Ipv6Addr`[src]

`pub const fn new( a: u16, b: u16, c: u16, d: u16, e: u16, f: u16, g: u16, h: u16 ) -> Ipv6Addr`[src]

`pub const LOCALHOST: Self`[src]1.30.0

`pub const UNSPECIFIED: Self`[src]1.30.0

`pub fn segments(&self) -> [u16; 8]`[src]

`pub fn is_unspecified(&self) -> bool`[src]1.7.0

`pub fn is_loopback(&self) -> bool`[src]1.7.0

`pub fn is_global(&self) -> bool`[src]

`pub fn is_unique_local(&self) -> bool`[src]

`pub fn is_unicast_link_local_strict(&self) -> bool`[src]

`pub fn is_unicast_link_local(&self) -> bool`[src]

`pub fn is_unicast_site_local(&self) -> bool`[src]

`pub fn is_documentation(&self) -> bool`[src]

`pub fn is_unicast_global(&self) -> bool`[src]

`pub fn multicast_scope(&self) -> Option<Ipv6MulticastScope>`[src]

`pub fn is_multicast(&self) -> bool`[src]1.7.0

`pub fn to_ipv4_mapped(&self) -> Option<Ipv4Addr>`[src]

`pub fn to_ipv4(&self) -> Option<Ipv4Addr>`[src]

`pub const fn octets(&self) -> [u8; 16]`[src]1.12.0

`impl Clone for Ipv6Addr`[src]

`fn clone(&self) -> Ipv6Addr`[src]

`fn clone_from(&mut self, source: &Self)`[src]

`impl Copy for Ipv6Addr`[src]

`impl Debug for Ipv6Addr`[src]

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

`impl Display for Ipv6Addr`[src]

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

`impl Eq for Ipv6Addr`[src]

`impl From<[u16; 8]> for Ipv6Addr`[src]1.16.0

`fn from(segments: [u16; 8]) -> Ipv6Addr`[src]

`impl From<[u8; 16]> for Ipv6Addr`[src]1.9.0

`fn from(octets: [u8; 16]) -> Ipv6Addr`[src]

`impl From<Ipv6Addr> for IpAddr`[src]1.16.0

`fn from(ipv6: Ipv6Addr) -> IpAddr`[src]

`impl From<Ipv6Addr> for u128`[src]1.26.0

`fn from(ip: Ipv6Addr) -> u128`[src]

`impl From<u128> for Ipv6Addr`[src]1.26.0

`fn from(ip: u128) -> Ipv6Addr`[src]

`impl FromStr for Ipv6Addr`[src]

`type Err = AddrParseError`

`fn from_str(s: &str) -> Result<Ipv6Addr, AddrParseError>`[src]

`impl Hash for Ipv6Addr`[src]

`fn hash<H: Hasher>(&self, s: &mut H)`[src]

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

`impl Ord for Ipv6Addr`[src]

`fn cmp(&self, other: &Ipv6Addr) -> Ordering`[src]

`fn max(self, other: Self) -> Self`[src]1.21.0

`fn min(self, other: Self) -> Self`[src]1.21.0

`fn clamp(self, min: Self, max: Self) -> Self`[src]

`impl PartialEq<IpAddr> for Ipv6Addr`[src]1.16.0

`fn eq(&self, other: &IpAddr) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl PartialEq<Ipv6Addr> for Ipv6Addr`[src]

`fn eq(&self, other: &Ipv6Addr) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl PartialEq<Ipv6Addr> for IpAddr`[src]1.16.0

`fn eq(&self, other: &Ipv6Addr) -> bool`[src]

`fn ne(&self, other: &Rhs) -> bool`[src]

`impl PartialOrd<IpAddr> for Ipv6Addr`[src]1.16.0

`fn partial_cmp(&self, other: &IpAddr) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl PartialOrd<Ipv6Addr> for Ipv6Addr`[src]

`fn partial_cmp(&self, other: &Ipv6Addr) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl PartialOrd<Ipv6Addr> for IpAddr`[src]1.16.0

`fn partial_cmp(&self, other: &Ipv6Addr) -> Option<Ordering>`[src]

`fn lt(&self, other: &Rhs) -> bool`[src]

`fn le(&self, other: &Rhs) -> bool`[src]

`fn gt(&self, other: &Rhs) -> bool`[src]

`fn ge(&self, other: &Rhs) -> bool`[src]

`impl RefUnwindSafe for Ipv6Addr`

`impl Send for Ipv6Addr`

`impl Sync for Ipv6Addr`

`impl Unpin for Ipv6Addr`