# Struct std::net::Ipv4Addr

1.0.0 · source ·

    pub struct Ipv4Addr { /* private fields */ }

Expand description

An IPv4 address.

IPv4 addresses are defined as 32-bit integers in IETF RFC 791. They are usually represented as four octets.

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

## Textual representation

`Ipv4Addr` provides a `FromStr` implementation. The four octets are in decimal notation, divided by `.` (this is called “dot-decimal notation”). Notably, octal numbers (which are indicated with a leading `0`) and hexadecimal numbers (which are indicated with a leading `0x`) are not allowed per IETF RFC 6943.

## Examples

    use std::net::Ipv4Addr;

    let localhost = Ipv4Addr::new(127, 0, 0, 1);
    assert_eq!("127.0.0.1".parse(), Ok(localhost));
    assert_eq!(localhost.is_loopback(), true);
    assert!("012.004.002.000".parse::<Ipv4Addr>().is_err()); // all octets are in octal
    assert!("0000000.0.0.0".parse::<Ipv4Addr>().is_err()); // first octet is a zero in octal
    assert!("0xcb.0x0.0x71.0x00".parse::<Ipv4Addr>().is_err()); // all octets are in hex

Run

## Implementations§

source§

### impl Ipv4Addr

const: 1.32.0 · source

#### pub const fn new(a: u8, b: u8, c: u8, d: u8) -> Ipv4Addr

Creates a new IPv4 address from four eight-bit octets.

The result will represent the IP address `a`.`b`.`c`.`d`.

##### Examples

    use std::net::Ipv4Addr;

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

Run
source

#### pub const BITS: u32 = 32u32

🔬This is a nightly-only experimental API. (`ip_bits` #113744)

The size of an IPv4 address in bits.

##### Examples

    #![feature(ip_bits)]
    use std::net::Ipv4Addr;

    assert_eq!(Ipv4Addr::BITS, 32);

Run
const: unstable · source

#### pub fn to_bits(self) -> u32

🔬This is a nightly-only experimental API. (`ip_bits` #113744)

Converts an IPv4 address into host byte order `u32`.

##### Examples

    #![feature(ip_bits)]
    use std::net::Ipv4Addr;

    let addr = Ipv4Addr::new(0x12, 0x34, 0x56, 0x78);
    assert_eq!(0x12345678, addr.to_bits());

Run
const: unstable · source

#### pub fn from_bits(bits: u32) -> Ipv4Addr

🔬This is a nightly-only experimental API. (`ip_bits` #113744)

Converts a host byte order `u32` into an IPv4 address.

##### Examples

    #![feature(ip_bits)]
    use std::net::Ipv4Addr;

    let addr = Ipv4Addr::from(0x12345678);
    assert_eq!(Ipv4Addr::new(0x12, 0x34, 0x56, 0x78), addr);

Run
1.30.0 · source

#### pub const LOCALHOST: Ipv4Addr = _

An IPv4 address with the address pointing to localhost: `127.0.0.1`

##### Examples

    use std::net::Ipv4Addr;

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

Run
1.30.0 · source

#### pub const UNSPECIFIED: Ipv4Addr = _

An IPv4 address representing an unspecified address: `0.0.0.0`

This corresponds to the constant `INADDR_ANY` in other languages.

##### Examples

    use std::net::Ipv4Addr;

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

Run
1.30.0 · source

#### pub const BROADCAST: Ipv4Addr = _

An IPv4 address representing the broadcast address: `255.255.255.255`

##### Examples

    use std::net::Ipv4Addr;

    let addr = Ipv4Addr::BROADCAST;
    assert_eq!(addr, Ipv4Addr::new(255, 255, 255, 255));

Run
const: 1.50.0 · source

#### pub const fn octets(&self) -> [u8; 4]

Returns the four eight-bit integers that make up this address.

##### Examples

    use std::net::Ipv4Addr;

    let addr = Ipv4Addr::new(127, 0, 0, 1);
    assert_eq!(addr.octets(), [127, 0, 0, 1]);

Run
1.12.0 (const: 1.32.0) · source

#### pub const fn is_unspecified(&self) -> bool

Returns `true` for the special ‘unspecified’ address (`0.0.0.0`).

This property is defined in UNIX Network Programming, Second Edition, W. Richard Stevens, p. 891; see also ip7.

##### Examples

    use std::net::Ipv4Addr;

    assert_eq!(Ipv4Addr::new(0, 0, 0, 0).is_unspecified(), true);
    assert_eq!(Ipv4Addr::new(45, 22, 13, 197).is_unspecified(), false);

Run
1.7.0 (const: 1.50.0) · source

#### pub const fn is_loopback(&self) -> bool

Returns `true` if this is a loopback address (`127.0.0.0/8`).

This property is defined by IETF RFC 1122.

##### Examples

    use std::net::Ipv4Addr;

    assert_eq!(Ipv4Addr::new(127, 0, 0, 1).is_loopback(), true);
    assert_eq!(Ipv4Addr::new(45, 22, 13, 197).is_loopback(), false);

Run
1.7.0 (const: 1.50.0) · source

#### pub const fn is_private(&self) -> bool

Returns `true` if this is a private address.

The private address ranges are defined in IETF RFC 1918 and include:

- `10.0.0.0/8`
- `172.16.0.0/12`
- `192.168.0.0/16`

##### Examples

    use std::net::Ipv4Addr;

    assert_eq!(Ipv4Addr::new(10, 0, 0, 1).is_private(), true);
    assert_eq!(Ipv4Addr::new(10, 10, 10, 10).is_private(), true);
    assert_eq!(Ipv4Addr::new(172, 16, 10, 10).is_private(), true);
    assert_eq!(Ipv4Addr::new(172, 29, 45, 14).is_private(), true);
    assert_eq!(Ipv4Addr::new(172, 32, 0, 2).is_private(), false);
    assert_eq!(Ipv4Addr::new(192, 168, 0, 2).is_private(), true);
    assert_eq!(Ipv4Addr::new(192, 169, 0, 2).is_private(), false);

Run
1.7.0 (const: 1.50.0) · source

#### pub const fn is_link_local(&self) -> bool

Returns `true` if the address is link-local (`169.254.0.0/16`).

This property is defined by IETF RFC 3927.

##### Examples

    use std::net::Ipv4Addr;

    assert_eq!(Ipv4Addr::new(169, 254, 0, 0).is_link_local(), true);
    assert_eq!(Ipv4Addr::new(169, 254, 10, 65).is_link_local(), true);
    assert_eq!(Ipv4Addr::new(16, 89, 10, 65).is_link_local(), false);

Run
const: unstable · source

#### pub fn is_global(&self) -> bool

🔬This is a nightly-only experimental API. (`ip` #27709)

Returns `true` if the address appears to be globally reachable as specified by the IANA IPv4 Special-Purpose Address Registry. Whether or not an address is practically reachable will depend on your network configuration.

Most IPv4 addresses are globally reachable; unless they are specifically defined as not globally reachable.

Non-exhaustive list of notable addresses that are not globally reachable:

- The unspecified address (`is_unspecified`)
- Addresses reserved for private use (`is_private`)
- Addresses in the shared address space (`is_shared`)
- Loopback addresses (`is_loopback`)
- Link-local addresses (`is_link_local`)
- Addresses reserved for documentation (`is_documentation`)
- Addresses reserved for benchmarking (`is_benchmarking`)
- Reserved addresses (`is_reserved`)
- The broadcast address (`is_broadcast`)

For the complete overview of which addresses are globally reachable, see the table at the IANA IPv4 Special-Purpose Address Registry.

##### Examples

    #![feature(ip)]

    use std::net::Ipv4Addr;

    // Most IPv4 addresses are globally reachable:
    assert_eq!(Ipv4Addr::new(80, 9, 12, 3).is_global(), true);

    // However some addresses have been assigned a special meaning
    // that makes them not globally reachable. Some examples are:

    // The unspecified address (`0.0.0.0`)
    assert_eq!(Ipv4Addr::UNSPECIFIED.is_global(), false);

    // Addresses reserved for private use (`10.0.0.0/8`, `172.16.0.0/12`, 192.168.0.0/16)
    assert_eq!(Ipv4Addr::new(10, 254, 0, 0).is_global(), false);
    assert_eq!(Ipv4Addr::new(192, 168, 10, 65).is_global(), false);
    assert_eq!(Ipv4Addr::new(172, 16, 10, 65).is_global(), false);

    // Addresses in the shared address space (`100.64.0.0/10`)
    assert_eq!(Ipv4Addr::new(100, 100, 0, 0).is_global(), false);

    // The loopback addresses (`127.0.0.0/8`)
    assert_eq!(Ipv4Addr::LOCALHOST.is_global(), false);

    // Link-local addresses (`169.254.0.0/16`)
    assert_eq!(Ipv4Addr::new(169, 254, 45, 1).is_global(), false);

    // Addresses reserved for documentation (`192.0.2.0/24`, `198.51.100.0/24`, `203.0.113.0/24`)
    assert_eq!(Ipv4Addr::new(192, 0, 2, 255).is_global(), false);
    assert_eq!(Ipv4Addr::new(198, 51, 100, 65).is_global(), false);
    assert_eq!(Ipv4Addr::new(203, 0, 113, 6).is_global(), false);

    // Addresses reserved for benchmarking (`198.18.0.0/15`)
    assert_eq!(Ipv4Addr::new(198, 18, 0, 0).is_global(), false);

    // Reserved addresses (`240.0.0.0/4`)
    assert_eq!(Ipv4Addr::new(250, 10, 20, 30).is_global(), false);

    // The broadcast address (`255.255.255.255`)
    assert_eq!(Ipv4Addr::BROADCAST.is_global(), false);

    // For a complete overview see the IANA IPv4 Special-Purpose Address Registry.

Run
const: unstable · source

#### pub fn is_shared(&self) -> bool

🔬This is a nightly-only experimental API. (`ip` #27709)

Returns `true` if this address is part of the Shared Address Space defined in IETF RFC 6598 (`100.64.0.0/10`).

##### Examples

    #![feature(ip)]
    use std::net::Ipv4Addr;

    assert_eq!(Ipv4Addr::new(100, 64, 0, 0).is_shared(), true);
    assert_eq!(Ipv4Addr::new(100, 127, 255, 255).is_shared(), true);
    assert_eq!(Ipv4Addr::new(100, 128, 0, 0).is_shared(), false);

Run
const: unstable · source

#### pub fn is_benchmarking(&self) -> bool

🔬This is a nightly-only experimental API. (`ip` #27709)

Returns `true` if this address part of the `198.18.0.0/15` range, which is reserved for network devices benchmarking. This range is defined in IETF RFC 2544 as `192.18.0.0` through `198.19.255.255` but errata 423 corrects it to `198.18.0.0/15`.

##### Examples

    #![feature(ip)]
    use std::net::Ipv4Addr;

    assert_eq!(Ipv4Addr::new(198, 17, 255, 255).is_benchmarking(), false);
    assert_eq!(Ipv4Addr::new(198, 18, 0, 0).is_benchmarking(), true);
    assert_eq!(Ipv4Addr::new(198, 19, 255, 255).is_benchmarking(), true);
    assert_eq!(Ipv4Addr::new(198, 20, 0, 0).is_benchmarking(), false);

Run
const: unstable · source

#### pub fn is_reserved(&self) -> bool

🔬This is a nightly-only experimental API. (`ip` #27709)

Returns `true` if this address is reserved by IANA for future use. IETF RFC 1112 defines the block of reserved addresses as `240.0.0.0/4`. This range normally includes the broadcast address `255.255.255.255`, but this implementation explicitly excludes it, since it is obviously not reserved for future use.

##### Warning

As IANA assigns new addresses, this method will be updated. This may result in non-reserved addresses being treated as reserved in code that relies on an outdated version of this method.

##### Examples

    #![feature(ip)]
    use std::net::Ipv4Addr;

    assert_eq!(Ipv4Addr::new(240, 0, 0, 0).is_reserved(), true);
    assert_eq!(Ipv4Addr::new(255, 255, 255, 254).is_reserved(), true);

    assert_eq!(Ipv4Addr::new(239, 255, 255, 255).is_reserved(), false);
    // The broadcast address is not considered as reserved for future use by this implementation
    assert_eq!(Ipv4Addr::new(255, 255, 255, 255).is_reserved(), false);

Run
1.7.0 (const: 1.50.0) · source

#### pub const fn is_multicast(&self) -> bool

Returns `true` if this is a multicast address (`224.0.0.0/4`).

Multicast addresses have a most significant octet between `224` and `239`, and is defined by IETF RFC 5771.

##### Examples

    use std::net::Ipv4Addr;

    assert_eq!(Ipv4Addr::new(224, 254, 0, 0).is_multicast(), true);
    assert_eq!(Ipv4Addr::new(236, 168, 10, 65).is_multicast(), true);
    assert_eq!(Ipv4Addr::new(172, 16, 10, 65).is_multicast(), false);

Run
1.7.0 (const: 1.50.0) · source

#### pub const fn is_broadcast(&self) -> bool

Returns `true` if this is a broadcast address (`255.255.255.255`).

A broadcast address has all octets set to `255` as defined in IETF RFC 919.

##### Examples

    use std::net::Ipv4Addr;

    assert_eq!(Ipv4Addr::new(255, 255, 255, 255).is_broadcast(), true);
    assert_eq!(Ipv4Addr::new(236, 168, 10, 65).is_broadcast(), false);

Run
1.7.0 (const: 1.50.0) · source

#### pub const fn is_documentation(&self) -> bool

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

This is defined in IETF RFC 5737:

- `192.0.2.0/24` (TEST-NET-1)
- `198.51.100.0/24` (TEST-NET-2)
- `203.0.113.0/24` (TEST-NET-3)

##### Examples

    use std::net::Ipv4Addr;

    assert_eq!(Ipv4Addr::new(192, 0, 2, 255).is_documentation(), true);
    assert_eq!(Ipv4Addr::new(198, 51, 100, 65).is_documentation(), true);
    assert_eq!(Ipv4Addr::new(203, 0, 113, 6).is_documentation(), true);
    assert_eq!(Ipv4Addr::new(193, 34, 17, 19).is_documentation(), false);

Run
const: 1.50.0 · source

#### pub const fn to_ipv6_compatible(&self) -> Ipv6Addr

Converts this address to an IPv4-compatible `IPv6` address.

`a.b.c.d` becomes `::a.b.c.d`

Note that IPv4-compatible addresses have been officially deprecated. If you don’t explicitly need an IPv4-compatible address for legacy reasons, consider using `to_ipv6_mapped` instead.

##### Examples

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

    assert_eq!(
        Ipv4Addr::new(192, 0, 2, 255).to_ipv6_compatible(),
        Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0xc000, 0x2ff)
    );

Run
const: 1.50.0 · source

#### pub const fn to_ipv6_mapped(&self) -> Ipv6Addr

Converts this address to an IPv4-mapped `IPv6` address.

`a.b.c.d` becomes `::ffff:a.b.c.d`

##### Examples

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

    assert_eq!(Ipv4Addr::new(192, 0, 2, 255).to_ipv6_mapped(),
               Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc000, 0x2ff));

Run
source§

### impl Ipv4Addr

source

#### pub fn parse_ascii(b: &[u8]) -> Result<Ipv4Addr, AddrParseError>

🔬This is a nightly-only experimental API. (`addr_parse_ascii` #101035)

Parse an IPv4 address from a slice of bytes.

    #![feature(addr_parse_ascii)]

    use std::net::Ipv4Addr;

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

    assert_eq!(Ipv4Addr::parse_ascii(b"127.0.0.1"), Ok(localhost));

Run

## Trait Implementations§

1.75.0 · source§

### impl BitAnd<&Ipv4Addr> for &Ipv4Addr

§

#### type Output = Ipv4Addr

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, rhs: &Ipv4Addr) -> Ipv4Addr

Performs the `&` operation. Read more
1.75.0 · source§

### impl BitAnd<&Ipv4Addr> for Ipv4Addr

§

#### type Output = Ipv4Addr

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, rhs: &Ipv4Addr) -> Ipv4Addr

Performs the `&` operation. Read more
1.75.0 · source§

### impl BitAnd<Ipv4Addr> for &Ipv4Addr

§

#### type Output = Ipv4Addr

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, rhs: Ipv4Addr) -> Ipv4Addr

Performs the `&` operation. Read more
1.75.0 · source§

### impl BitAnd for Ipv4Addr

§

#### type Output = Ipv4Addr

The resulting type after applying the `&` operator.
source§

#### fn bitand(self, rhs: Ipv4Addr) -> Ipv4Addr

Performs the `&` operation. Read more
1.75.0 · source§

### impl BitAndAssign<&Ipv4Addr> for Ipv4Addr

source§

#### fn bitand_assign(&mut self, rhs: &Ipv4Addr)

Performs the `&=` operation. Read more
1.75.0 · source§

### impl BitAndAssign for Ipv4Addr

source§

#### fn bitand_assign(&mut self, rhs: Ipv4Addr)

Performs the `&=` operation. Read more
1.75.0 · source§

### impl BitOr<&Ipv4Addr> for &Ipv4Addr

§

#### type Output = Ipv4Addr

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, rhs: &Ipv4Addr) -> Ipv4Addr

Performs the `|` operation. Read more
1.75.0 · source§

### impl BitOr<&Ipv4Addr> for Ipv4Addr

§

#### type Output = Ipv4Addr

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, rhs: &Ipv4Addr) -> Ipv4Addr

Performs the `|` operation. Read more
1.75.0 · source§

### impl BitOr<Ipv4Addr> for &Ipv4Addr

§

#### type Output = Ipv4Addr

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, rhs: Ipv4Addr) -> Ipv4Addr

Performs the `|` operation. Read more
1.75.0 · source§

### impl BitOr for Ipv4Addr

§

#### type Output = Ipv4Addr

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, rhs: Ipv4Addr) -> Ipv4Addr

Performs the `|` operation. Read more
1.75.0 · source§

### impl BitOrAssign<&Ipv4Addr> for Ipv4Addr

source§

#### fn bitor_assign(&mut self, rhs: &Ipv4Addr)

Performs the `|=` operation. Read more
1.75.0 · source§

### impl BitOrAssign for Ipv4Addr

source§

#### fn bitor_assign(&mut self, rhs: Ipv4Addr)

Performs the `|=` operation. Read more
source§

### impl Clone for Ipv4Addr

source§

#### fn clone(&self) -> Ipv4Addr

Returns a copy of the value. Read more
source§

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

Performs copy-assignment from `source`. Read more
source§

### impl Debug for Ipv4Addr

source§

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

Formats the value using the given formatter. Read more
source§

### impl Display for Ipv4Addr

source§

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

Formats the value using the given formatter. Read more
1.9.0 · source§

### impl From<[u8; 4]> for Ipv4Addr

source§

#### fn from(octets: [u8; 4]) -> Ipv4Addr

Creates an `Ipv4Addr` from a four element byte array.

##### Examples

    use std::net::Ipv4Addr;

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

Run
1.16.0 · source§

### impl From<Ipv4Addr> for IpAddr

source§

#### fn from(ipv4: Ipv4Addr) -> IpAddr

Copies this address to a new `IpAddr::V4`.

##### Examples

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

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

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

Run
1.1.0 · source§

### impl From<Ipv4Addr> for u32

source§

#### fn from(ip: Ipv4Addr) -> u32

Uses `Ipv4Addr::to_bits` to convert an IPv4 address to a host byte order `u32`.

1.1.0 · source§

### impl From<u32> for Ipv4Addr

source§

#### fn from(ip: u32) -> Ipv4Addr

Uses `Ipv4Addr::from_bits` to convert a host byte order `u32` into an IPv4 address.

source§

### impl FromStr for Ipv4Addr

§

#### type Err = AddrParseError

The associated error which can be returned from parsing.
source§

#### fn from_str(s: &str) -> Result<Ipv4Addr, AddrParseError>

Parses a string `s` to return a value of this type. Read more
source§

### impl Hash for Ipv4Addr

source§

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

Feeds this value into the given `Hasher`. Read more
1.3.0 · source§

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

Feeds a slice of this type into the given `Hasher`. Read more
1.75.0 · source§

### impl Not for &Ipv4Addr

§

#### type Output = Ipv4Addr

The resulting type after applying the `!` operator.
source§

#### fn not(self) -> Ipv4Addr

Performs the unary `!` operation. Read more
1.75.0 · source§

### impl Not for Ipv4Addr

§

#### type Output = Ipv4Addr

The resulting type after applying the `!` operator.
source§

#### fn not(self) -> Ipv4Addr

Performs the unary `!` operation. Read more
source§

### impl Ord for Ipv4Addr

source§

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

This method returns an `Ordering` between `self` and `other`. Read more
1.21.0 · source§

#### fn max(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values. Read more
1.21.0 · source§

#### fn min(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the minimum of two values. Read more
1.50.0 · source§

#### fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd,

Restrict a value to a certain interval. Read more
1.16.0 · source§

### impl PartialEq<IpAddr> for Ipv4Addr

source§

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

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

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

This method tests for `!=`. The default implementation is almost always sufficient, and should not be overridden without very good reason.
1.16.0 · source§

### impl PartialEq<Ipv4Addr> for IpAddr

source§

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

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

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

This method tests for `!=`. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

### impl PartialEq for Ipv4Addr

source§

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

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

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

This method tests for `!=`. The default implementation is almost always sufficient, and should not be overridden without very good reason.
1.16.0 · source§

### impl PartialOrd<IpAddr> for Ipv4Addr

source§

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

This method returns an ordering between `self` and `other` values if one exists. Read more
source§

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

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more
source§

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

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

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

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more
source§

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

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more
1.16.0 · source§

### impl PartialOrd<Ipv4Addr> for IpAddr

source§

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

This method returns an ordering between `self` and `other` values if one exists. Read more
source§

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

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more
source§

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

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

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

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more
source§

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

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

### impl PartialOrd for Ipv4Addr

source§

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

This method returns an ordering between `self` and `other` values if one exists. Read more
source§

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

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more
source§

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

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

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

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more
source§

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

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

### impl Step for Ipv4Addr

source§

#### fn steps_between(_: &Ipv4Addr, _: &Ipv4Addr) -> Option<usize>

🔬This is a nightly-only experimental API. (`step_trait` #42168)
Returns the number of successor steps required to get from `start` to `end`. Read more
source§

#### fn forward_checked(start: Ipv4Addr, count: usize) -> Option<Ipv4Addr>

🔬This is a nightly-only experimental API. (`step_trait` #42168)
Returns the value that would be obtained by taking the successor of `self` `count` times. Read more
source§

#### fn backward_checked(start: Ipv4Addr, count: usize) -> Option<Ipv4Addr>

🔬This is a nightly-only experimental API. (`step_trait` #42168)
Returns the value that would be obtained by taking the predecessor of `self` `count` times. Read more
source§

#### unsafe fn forward_unchecked(start: Ipv4Addr, count: usize) -> Ipv4Addr

🔬This is a nightly-only experimental API. (`step_trait` #42168)
Returns the value that would be obtained by taking the successor of `self` `count` times. Read more
source§

#### unsafe fn backward_unchecked(start: Ipv4Addr, count: usize) -> Ipv4Addr

🔬This is a nightly-only experimental API. (`step_trait` #42168)
Returns the value that would be obtained by taking the predecessor of `self` `count` times. Read more
source§

#### fn forward(start: Self, count: usize) -> Self

🔬This is a nightly-only experimental API. (`step_trait` #42168)
Returns the value that would be obtained by taking the successor of `self` `count` times. Read more
source§

#### fn backward(start: Self, count: usize) -> Self

🔬This is a nightly-only experimental API. (`step_trait` #42168)
Returns the value that would be obtained by taking the predecessor of `self` `count` times. Read more
source§

### impl Copy for Ipv4Addr

source§

### impl Eq for Ipv4Addr

source§

### impl StructuralEq for Ipv4Addr

source§

### impl StructuralPartialEq for Ipv4Addr

source§

### impl TrustedStep for Ipv4Addr

## Auto Trait Implementations§

§

### impl RefUnwindSafe for Ipv4Addr

§

### impl Send for Ipv4Addr

§

### impl Sync for Ipv4Addr

§

### impl Unpin for Ipv4Addr

§

### impl UnwindSafe for Ipv4Addr

## Blanket Implementations§

source§

### impl<T> Any for Twhere T: 'static + ?Sized,

source§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
source§

### impl<T> Borrow<T> for Twhere T: ?Sized,

source§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

### impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

### impl<T> From<T> for T

source§

#### fn from(t: T) -> T

Returns the argument unchanged.

source§

### impl<T, U> Into<U> for Twhere U: From<T>,

source§

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

source§

### impl<T> ToOwned for Twhere T: Clone,

§

#### type Owned = T

The resulting type after obtaining ownership.
source§

#### fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

#### fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

### impl<T> ToString for Twhere T: Display + ?Sized,

source§

#### default fn to_string(&self) -> String

Converts the given value to a `String`. Read more
source§

### impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

#### type Error = Infallible

The type returned in the event of a conversion error.
source§

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

### impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.