Struct elastic_types::ip::Ip

pub struct Ip<TMapping> where
    TMapping: 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<TMapping> Ip<TMapping> where
    TMapping: IpMapping, 

fn new<I>(ip: I) -> Ip<TMapping> 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<TNewMapping>(ip: Ip<TMapping>) -> Ip<TNewMapping> where
    TNewMapping: 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 to 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<TMapping: Debug> Debug for Ip<TMapping> where
    TMapping: IpMapping, 

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

Formats the value using the given formatter.

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

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

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

This method tests for !=.

impl<TMapping> IpFieldType<TMapping> for Ip<TMapping> where
    TMapping: 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

Dereferences the value.

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

fn borrow(&self) -> &Ipv4Addr

Immutably borrows from an owned value.

impl<TMapping> Serialize for Ip<TMapping> where
    TMapping: 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, TMapping> Deserialize<'de> for Ip<TMapping> where
    TMapping: IpMapping, 

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

Deserialize this value from the given Serde deserializer.