Struct elastic_types::ip::prelude::Ip

pub struct Ip<M> where
    M: IpMapping,  { /* fields omitted */ }

An Elasticsearch ip with a mapping.

Where the mapping isn't custom, you can use the standard library Ipv4Addr instead.

Examples

Defining an ip with a mapping:

use std::net::Ipv4Addr;
use elastic_types::ip::mapping::DefaultIpMapping;
use elastic_types::ip::Ip;

let ip = Ip::<DefaultIpMapping>::new(Ipv4Addr::new(127, 0, 0, 1));

Methods

impl<M> Ip<M> where
    M: IpMapping, 

fn new<I>(ip: I) -> Ip<M> where
    I: Into<Ipv4Addr>, 

Creates a new Ip with the given mapping.

Examples

Create a new Ip from a Ip4vAddr:

use std::net::Ipv4Addr;
use elastic_types::ip::mapping::DefaultIpMapping;
use elastic_types::ip::Ip;
    
let ip = Ip::<DefaultIpMapping>::new(Ipv4Addr::new(127, 0, 0, 1));

fn remap<MInto>(ip: Ip<M>) -> Ip<MInto> where
    MInto: IpMapping, 

Change the mapping of this ip.

Examples

Change the mapping for a given Ip:

let es_ip = Ip::<DefaultIpMapping>::new(Ipv4Addr::new(127, 0, 0, 1));
    
let ip: Ip<MyIpMapping> = Ip::remap(es_ip);

Methods from Deref<Target = Ipv4Addr>

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

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

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

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

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

fn is_global(&self) -> bool

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

extra functionality has not been scrutinized to the level that it should be stable

Returns true if the address appears to be globally routable. See iana-ipv4-special-registry.

The following return false:

• private address (10.0.0.0/8, 172.16.0.0/12 and 192.168.0.0/16)
• the loopback address (127.0.0.0/8)
• the link-local address (169.254.0.0/16)
• the broadcast address (255.255.255.255/32)
• test addresses used for documentation (192.0.2.0/24, 198.51.100.0/24 and 203.0.113.0/24)
• the unspecified address (0.0.0.0)

Examples

#![feature(ip)]

use std::net::Ipv4Addr;

fn main() {
    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);
    assert_eq!(Ipv4Addr::new(0, 0, 0, 0).is_global(), false);
    assert_eq!(Ipv4Addr::new(80, 9, 12, 3).is_global(), true);
}

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

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

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

fn to_ipv6_compatible(&self) -> Ipv6Addr

Converts this address to an IPv4-compatible IPv6 address.

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

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, 49152, 767));

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, 65535, 49152, 767));

Trait Implementations

impl<M: Debug> Debug for Ip<M> where
    M: IpMapping, 

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

Formats the value using the given formatter.

impl<M: Clone> Clone for Ip<M> where
    M: IpMapping, 

fn clone(&self) -> Ip<M>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<M: PartialEq> PartialEq for Ip<M> where
    M: IpMapping, 

fn eq(&self, __arg_0: &Ip<M>) -> bool

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

fn ne(&self, __arg_0: &Ip<M>) -> bool

This method tests for !=.

impl<M> IpFieldType<M> for Ip<M> where
    M: IpMapping, 

impl<M> From<Ipv4Addr> for Ip<M> where
    M: IpMapping, 

fn from(value: Ipv4Addr) -> Self

Performs the conversion.

impl<M> PartialEq<Ipv4Addr> for Ip<M> where
    M: IpMapping, 

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

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

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

This method tests for !=.

impl<M> Deref for Ip<M> where
    M: IpMapping, 

type Target = Ipv4Addr

The resulting type after dereferencing

fn deref(&self) -> &Ipv4Addr

The method called to dereference a value

impl<M> Borrow<Ipv4Addr> for Ip<M> where
    M: IpMapping, 

fn borrow(&self) -> &Ipv4Addr

Immutably borrows from an owned value.

impl<M> Serialize for Ip<M> where
    M: IpMapping, 

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

Serialize this value into the given Serde serializer.

impl<'de, M> Deserialize<'de> for Ip<M> where
    M: IpMapping, 

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

Deserialize this value from the given Serde deserializer.