Enum IpNetwork 

pub enum IpNetwork {
    V4(Ipv4Network),
    V6(Ipv6Network),
}

Available on crate feature with-ipnetwork only.

Represents a generic network range. This type can have two variants: the v4 and the v6 case.

Variants

V4(Ipv4Network)

V6(Ipv6Network)

Implementations

impl IpNetwork

pub fn new(ip: IpAddr, prefix: u8) -> Result<IpNetwork, IpNetworkError>

Constructs a new IpNetwork from a given IpAddr and a prefix denoting the network size. If the prefix is larger than 32 (for IPv4) or 128 (for IPv6), this will raise an IpNetworkError::InvalidPrefix error. Support for IPv6 is not complete yet.

pub fn with_netmask( netaddr: IpAddr, netmask: IpAddr, ) -> Result<IpNetwork, IpNetworkError>

Constructs a new IpNetwork from a network address and a network mask.

If the netmask is not valid this will return an IpNetworkError::InvalidPrefix.

pub fn ip(&self) -> IpAddr

Returns the IP part of a given IpNetwork

pub fn prefix(&self) -> u8

Returns the prefix of the given IpNetwork

Example

use ipnetwork::IpNetwork;

assert_eq!(IpNetwork::V4("10.9.0.1".parse().unwrap()).prefix(), 32u8);
assert_eq!(IpNetwork::V4("10.9.0.32/16".parse().unwrap()).prefix(), 16u8);

assert_eq!(IpNetwork::V6("ff01::0".parse().unwrap()).prefix(), 128u8);
assert_eq!(IpNetwork::V6("ff01::0/32".parse().unwrap()).prefix(), 32u8);

pub fn network(&self) -> IpAddr

Returns the address of the network denoted by this IpNetwork. This means the lowest possible IP address inside of the network.

Examples

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

let net: IpNetwork = "10.1.9.32/16".parse().unwrap();
assert_eq!(net.network(), Ipv4Addr::new(10, 1, 0, 0));
let net: IpNetwork = "2001:db8::/96".parse().unwrap();
assert_eq!(net.network(), Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0));

pub fn broadcast(&self) -> IpAddr

Returns the broadcasting address of this IpNetwork. This means the highest possible IP address inside of the network.

Examples

use std::net::Ipv4Addr;
use ipnetwork::{IpNetwork, Ipv4Network};

let net: Ipv4Network = "10.9.0.32/16".parse().unwrap();
assert_eq!(net.broadcast(), Ipv4Addr::new(10, 9, 255, 255));

pub fn mask(&self) -> IpAddr

Returns the mask for this IpNetwork. That means the prefix most significant bits will be 1 and the rest 0

Example

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

let v4_net: IpNetwork = "10.9.0.1".parse().unwrap();
assert_eq!(v4_net.mask(), Ipv4Addr::new(255, 255, 255, 255));
let v4_net: IpNetwork = "10.9.0.32/16".parse().unwrap();
assert_eq!(v4_net.mask(), Ipv4Addr::new(255, 255, 0, 0));

let v6_net: IpNetwork = "ff01::0".parse().unwrap();
assert_eq!(v6_net.mask(), Ipv6Addr::new(0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff));
let v6_net: IpNetwork = "ff01::0/32".parse().unwrap();
assert_eq!(v6_net.mask(), Ipv6Addr::new(0xffff, 0xffff, 0, 0, 0, 0, 0, 0));

pub fn is_ipv4(&self) -> bool

Returns true if the IP in this IpNetwork is a valid IPv4 address, false if it’s a valid IPv6 address.

Example

 use ipnetwork::IpNetwork;

 let v4: IpNetwork = IpNetwork::V4("10.9.0.32/16".parse().unwrap());
 assert_eq!(v4.is_ipv4(), true);
 assert_eq!(v4.is_ipv6(), false);

pub fn is_ipv6(&self) -> bool

Returns true if the IP in this IpNetwork is a valid IPv6 address, false if it’s a valid IPv4 address.

Example

 use ipnetwork::IpNetwork;

 let v6: IpNetwork = IpNetwork::V6("ff01::0/32".parse().unwrap());
 assert_eq!(v6.is_ipv6(), true);
 assert_eq!(v6.is_ipv4(), false);

pub fn contains(&self, ip: IpAddr) -> bool

Checks if a given IpAddr is in this IpNetwork

Examples

use std::net::IpAddr;
use ipnetwork::IpNetwork;

let net: IpNetwork = "127.0.0.0/24".parse().unwrap();
let ip1: IpAddr = "127.0.0.1".parse().unwrap();
let ip2: IpAddr = "172.0.0.1".parse().unwrap();
let ip4: IpAddr = "::1".parse().unwrap();
assert!(net.contains(ip1));
assert!(!net.contains(ip2));
assert!(!net.contains(ip4));

pub fn size(&self) -> NetworkSize

Returns the number of possible host addresses in this IpAddr

Examples

use ipnetwork::{IpNetwork, NetworkSize};


let net: IpNetwork = "127.0.0.0/24".parse().unwrap();
assert_eq!(net.size(), NetworkSize::V4(256))

pub fn iter(&self) -> IpNetworkIterator

Returns an iterator over the addresses contained in the network.

This lists all the addresses in the network range, in ascending order.

Trait Implementations

impl Clone for IpNetwork

fn clone(&self) -> IpNetwork

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for IpNetwork

impl Debug for IpNetwork

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for IpNetwork

Available on crate feature serde only.

fn deserialize<D>( deserializer: D, ) -> Result<IpNetwork, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for IpNetwork

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

Formats the value using the given formatter.

impl Eq for IpNetwork

impl From<IpAddr> for IpNetwork

fn from(addr: IpAddr) -> IpNetwork

Converts to this type from the input type.

impl From<IpNetwork> for Value

fn from(x: IpNetwork) -> Value

Converts to this type from the input type.

impl From<Ipv4Network> for IpNetwork

fn from(v4: Ipv4Network) -> IpNetwork

Converts to this type from the input type.

impl From<Ipv6Network> for IpNetwork

fn from(v6: Ipv6Network) -> IpNetwork

Converts to this type from the input type.

impl FromStr for IpNetwork

Tries to parse the given string into a IpNetwork. Will first try to parse it as an Ipv4Network and if that fails as an Ipv6Network. If both fails it will return an InvalidAddr error.

Examples

use std::net::Ipv4Addr;
use ipnetwork::{IpNetwork, Ipv4Network};

let expected = IpNetwork::V4(Ipv4Network::new(Ipv4Addr::new(10, 1, 9, 32), 16).unwrap());
let from_cidr: IpNetwork = "10.1.9.32/16".parse().unwrap();
assert_eq!(expected, from_cidr);

type Err = IpNetworkError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<IpNetwork, <IpNetwork as FromStr>::Err>

Parses a string s to return a value of this type.

impl Hash for IpNetwork

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

where __H: Hasher,

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl IntoActiveValue<IpNetwork> for IpNetwork

fn into_active_value(self) -> ActiveValue<IpNetwork>

Method to perform the conversion

impl IntoIterator for &IpNetwork

type IntoIter = IpNetworkIterator

Which kind of iterator are we turning this into?

type Item = IpAddr

The type of the elements being iterated over.

fn into_iter(self) -> IpNetworkIterator

Creates an iterator from a value.

impl NotU8 for IpNetwork

impl Nullable for IpNetwork

fn null() -> Value

impl Ord for IpNetwork

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

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for IpNetwork

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for IpNetwork

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

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for IpNetwork

Available on crate feature serde only.

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for IpNetwork

impl TryFrom<&str> for IpNetwork

type Error = IpNetworkError

The type returned in the event of a conversion error.

fn try_from(s: &str) -> Result<IpNetwork, <IpNetwork as TryFrom<&str>>::Error>

Performs the conversion.

impl TryFromU64 for IpNetwork

fn try_from_u64(_: u64) -> Result<Self, DbErr>

Build Self from the raw u64 returned by the driver.

impl TryGetable for IpNetwork

fn try_get_by<I: ColIdx>(res: &QueryResult, idx: I) -> Result<Self, TryGetError>

Decode the value at the column named or positioned by index.

fn try_get(res: &QueryResult, pre: &str, col: &str) -> Result<Self, TryGetError>

Decode the value at column {pre}{col} — pre is the prefix used when nesting partial models or joining tables.

fn try_get_by_index( res: &QueryResult, index: usize, ) -> Result<Self, TryGetError>

Decode the value at the given positional index in the SELECT list.

impl ValueType for IpNetwork

fn try_from(v: Value) -> Result<IpNetwork, ValueTypeErr>

fn type_name() -> String

fn array_type() -> ArrayType

fn column_type() -> ColumnType

fn unwrap(v: Value) -> Self

fn expect(v: Value, msg: &str) -> Self

fn is_option() -> bool

fn enum_type_name() -> Option<&'static str>