Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://docs.rs/cap-std/latest/cap_std/net/enum.IpAddr.html below:

IpAddr in cap_std::net - Rust

pub enum IpAddr {
    V4(Ipv4Addr),
    V6(Ipv6Addr),
}

An IP address, either IPv4 or IPv6.

This enum can contain either an Ipv4Addr or an Ipv6Addr, see their respective documentation for more details.

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

let localhost_v4 = IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1));
let localhost_v6 = IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1));

assert_eq!("127.0.0.1".parse(), Ok(localhost_v4));
assert_eq!("::1".parse(), Ok(localhost_v6));

assert_eq!(localhost_v4.is_ipv6(), false);
assert_eq!(localhost_v4.is_ipv4(), true);

An IPv4 address.

An IPv6 address.

Returns true for the special ‘unspecified’ address.

See the documentation for Ipv4Addr::is_unspecified() and Ipv6Addr::is_unspecified() for more details.

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

assert_eq!(IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)).is_unspecified(), true);
assert_eq!(IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0)).is_unspecified(), true);

Returns true if this is a loopback address.

See the documentation for Ipv4Addr::is_loopback() and Ipv6Addr::is_loopback() for more details.

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

assert_eq!(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)).is_loopback(), true);
assert_eq!(IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0x1)).is_loopback(), true);

Returns true if the address appears to be globally routable.

See the documentation for Ipv4Addr::is_global() and Ipv6Addr::is_global() for more details.

#![feature(ip)]

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

assert_eq!(IpAddr::V4(Ipv4Addr::new(80, 9, 12, 3)).is_global(), true);
assert_eq!(IpAddr::V6(Ipv6Addr::new(0, 0, 0x1c9, 0, 0, 0xafc8, 0, 0x1)).is_global(), true);

Returns true if this is a multicast address.

See the documentation for Ipv4Addr::is_multicast() and Ipv6Addr::is_multicast() for more details.

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

assert_eq!(IpAddr::V4(Ipv4Addr::new(224, 254, 0, 0)).is_multicast(), true);
assert_eq!(IpAddr::V6(Ipv6Addr::new(0xff00, 0, 0, 0, 0, 0, 0, 0)).is_multicast(), true);

Returns true if this address is in a range designated for documentation.

See the documentation for Ipv4Addr::is_documentation() and Ipv6Addr::is_documentation() for more details.

#![feature(ip)]

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

assert_eq!(IpAddr::V4(Ipv4Addr::new(203, 0, 113, 6)).is_documentation(), true);
assert_eq!(
    IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0)).is_documentation(),
    true
);

Returns true if this address is in a range designated for benchmarking.

See the documentation for Ipv4Addr::is_benchmarking() and Ipv6Addr::is_benchmarking() for more details.

#![feature(ip)]

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

assert_eq!(IpAddr::V4(Ipv4Addr::new(198, 19, 255, 255)).is_benchmarking(), true);
assert_eq!(IpAddr::V6(Ipv6Addr::new(0x2001, 0x2, 0, 0, 0, 0, 0, 0)).is_benchmarking(), true);

Returns true if this address is an IPv4 address, and false otherwise.

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

assert_eq!(IpAddr::V4(Ipv4Addr::new(203, 0, 113, 6)).is_ipv4(), true);
assert_eq!(IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0)).is_ipv4(), false);

Returns true if this address is an IPv6 address, and false otherwise.

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

assert_eq!(IpAddr::V4(Ipv4Addr::new(203, 0, 113, 6)).is_ipv6(), false);
assert_eq!(IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0)).is_ipv6(), true);

Converts this address to an IpAddr::V4 if it is an IPv4-mapped IPv6 address, otherwise returns self as-is.

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

let localhost_v4 = Ipv4Addr::new(127, 0, 0, 1);

assert_eq!(IpAddr::V4(localhost_v4).to_canonical(), localhost_v4);
assert_eq!(IpAddr::V6(localhost_v4.to_ipv6_mapped()).to_canonical(), localhost_v4);
assert_eq!(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)).to_canonical().is_loopback(), true);
assert_eq!(IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0x7f00, 0x1)).is_loopback(), false);
assert_eq!(IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0x7f00, 0x1)).to_canonical().is_loopback(), true);

Returns the eight-bit integers this address consists of as a slice.

#![feature(ip_as_octets)]

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

assert_eq!(IpAddr::V4(Ipv4Addr::LOCALHOST).as_octets(), &[127, 0, 0, 1]);
assert_eq!(IpAddr::V6(Ipv6Addr::LOCALHOST).as_octets(),
           &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])

Parse an IP address from a slice of bytes.

#![feature(addr_parse_ascii)]

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

let localhost_v4 = IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1));
let localhost_v6 = IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1));

assert_eq!(IpAddr::parse_ascii(b"127.0.0.1"), Ok(localhost_v4));
assert_eq!(IpAddr::parse_ascii(b"::1"), Ok(localhost_v6));

Creates an IpAddr::V6 from an eight element 16-bit array.

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

let addr = IpAddr::from([
    0x20du16, 0x20cu16, 0x20bu16, 0x20au16,
    0x209u16, 0x208u16, 0x207u16, 0x206u16,
]);
assert_eq!(
    IpAddr::V6(Ipv6Addr::new(
        0x20d, 0x20c, 0x20b, 0x20a,
        0x209, 0x208, 0x207, 0x206,
    )),
    addr
);

Creates an IpAddr::V6 from a sixteen element byte array.

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

let addr = IpAddr::from([
    0x19u8, 0x18u8, 0x17u8, 0x16u8, 0x15u8, 0x14u8, 0x13u8, 0x12u8,
    0x11u8, 0x10u8, 0x0fu8, 0x0eu8, 0x0du8, 0x0cu8, 0x0bu8, 0x0au8,
]);
assert_eq!(
    IpAddr::V6(Ipv6Addr::new(
        0x1918, 0x1716, 0x1514, 0x1312,
        0x1110, 0x0f0e, 0x0d0c, 0x0b0a,
    )),
    addr
);

Creates an IpAddr::V4 from a four element byte array.

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

let addr = IpAddr::from([13u8, 12u8, 11u8, 10u8]);
assert_eq!(IpAddr::V4(Ipv4Addr::new(13, 12, 11, 10)), addr);

Copies this address to a new IpAddr::V4.

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

let addr = Ipv4Addr::new(127, 0, 0, 1);

assert_eq!(
    IpAddr::V4(addr),
    IpAddr::from(addr)
)

Copies this address to a new IpAddr::V6.

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

The associated error which can be returned from parsing.

Parses a string

to return a value of this type.

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

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

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

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

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

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

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

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

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

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

This method returns an ordering between

and

values if one exists.

Tests less than (for

and

) and is used by the

operator.

Tests less than or equal to (for

and

) and is used by the

operator.

Tests greater than (for

and

) and is used by the

operator.

Tests greater than or equal to (for

and

) and is used by the

operator.

This method returns an ordering between

and

values if one exists.

Tests less than (for

and

) and is used by the

operator.

Tests less than or equal to (for

and

) and is used by the

operator.

Tests greater than (for

and

) and is used by the

operator.

Tests greater than or equal to (for

and

) and is used by the

operator.

This method returns an ordering between

and

values if one exists.

Tests less than (for

and

) and is used by the

operator.

Tests less than or equal to (for

and

) and is used by the

operator.

Tests greater than (for

and

) and is used by the

operator.

Tests greater than or equal to (for

and

) and is used by the

operator.

This method returns an ordering between

and

values if one exists.

Tests less than (for

and

) and is used by the

operator.

Tests less than or equal to (for

and

) and is used by the

operator.

Tests greater than (for

and

) and is used by the

operator.

Tests greater than or equal to (for

and

) and is used by the

operator.

This method returns an ordering between

and

values if one exists.

Tests less than (for

and

) and is used by the

operator.

Tests less than or equal to (for

and

) and is used by the

operator.

Tests greater than (for

and

) and is used by the

operator.

Tests greater than or equal to (for

and

) and is used by the

operator.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4