Struct Ipv4Range 

pub struct Ipv4Range { /* private fields */ }

Available on crate feature net only.

An IPv4 address range (start to end inclusive).

Examples

use bare_types::net::Ipv4Range;
use core::net::Ipv4Addr;

// Parse range notation
let range: Ipv4Range = "192.168.1.0-192.168.1.255".parse().unwrap();

// Check if IP is in range
assert!(range.contains(&Ipv4Addr::new(192, 168, 1, 100)));

// Get number of addresses
assert_eq!(range.num_addresses(), 256);

Implementations

impl Ipv4Range

pub fn new(start: Ipv4Addr, end: Ipv4Addr) -> Result<Self, Ipv4RangeError>

Creates a new IPv4 range from start and end addresses.

Errors

Returns Ipv4RangeError::InvalidRange if start > end.

Examples

use bare_types::net::Ipv4Range;
use core::net::Ipv4Addr;

let range = Ipv4Range::new(
    Ipv4Addr::new(192, 168, 1, 0),
    Ipv4Addr::new(192, 168, 1, 255)
).unwrap();

pub const fn start(&self) -> Ipv4Addr

Returns the start address.

Examples

use bare_types::net::Ipv4Range;
use core::net::Ipv4Addr;

let range: Ipv4Range = "192.168.1.0-192.168.1.255".parse().unwrap();
assert_eq!(range.start(), Ipv4Addr::new(192, 168, 1, 0));

pub const fn end(&self) -> Ipv4Addr

Returns the end address.

Examples

use bare_types::net::Ipv4Range;
use core::net::Ipv4Addr;

let range: Ipv4Range = "192.168.1.0-192.168.1.255".parse().unwrap();
assert_eq!(range.end(), Ipv4Addr::new(192, 168, 1, 255));

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

Returns true if this range contains the given IP address.

Examples

use bare_types::net::Ipv4Range;
use core::net::Ipv4Addr;

let range: Ipv4Range = "192.168.1.0-192.168.1.255".parse().unwrap();
assert!(range.contains(&Ipv4Addr::new(192, 168, 1, 100)));
assert!(!range.contains(&Ipv4Addr::new(192, 168, 2, 1)));

pub fn num_addresses(&self) -> u32

Returns the number of addresses in this range.

Examples

use bare_types::net::Ipv4Range;

let range: Ipv4Range = "192.168.1.0-192.168.1.255".parse().unwrap();
assert_eq!(range.num_addresses(), 256);

pub fn overlaps(&self, other: &Self) -> bool

Returns true if this range overlaps with another range.

Examples

use bare_types::net::Ipv4Range;

let range1: Ipv4Range = "192.168.1.0-192.168.1.255".parse().unwrap();
let range2: Ipv4Range = "192.168.1.100-192.168.2.50".parse().unwrap();
assert!(range1.overlaps(&range2));

pub fn contains_range(&self, other: &Self) -> bool

Returns true if this range fully contains another range.

Examples

use bare_types::net::Ipv4Range;

let range1: Ipv4Range = "192.168.1.0-192.168.1.255".parse().unwrap();
let range2: Ipv4Range = "192.168.1.100-192.168.1.200".parse().unwrap();
assert!(range1.contains_range(&range2));
assert!(!range2.contains_range(&range1));

pub fn is_adjacent_to(&self, other: &Self) -> bool

Returns true if this range is adjacent to another range.

Two ranges are adjacent if one ends exactly where the other starts, or they can be merged into a single continuous range.

Examples

use bare_types::net::Ipv4Range;

let range1: Ipv4Range = "192.168.1.0-192.168.1.255".parse().unwrap();
let range2: Ipv4Range = "192.168.2.0-192.168.2.255".parse().unwrap();
assert!(range1.is_adjacent_to(&range2));

pub fn merge(&self, other: &Self) -> Option<Self>

Returns a merged range if this range overlaps or is adjacent to another range.

Errors

Returns None if the ranges cannot be merged (not overlapping or adjacent).

Examples

use bare_types::net::Ipv4Range;

let range1: Ipv4Range = "192.168.1.0-192.168.1.255".parse().unwrap();
let range2: Ipv4Range = "192.168.2.0-192.168.2.255".parse().unwrap();
let merged = range1.merge(&range2).unwrap();
assert_eq!(merged.to_string(), "192.168.1.0-192.168.2.255");

pub fn is_cidr_compatible(&self) -> bool

Returns true if this range can be represented as a CIDR block.

A range can be represented as a CIDR if:

• It has a power of 2 number of addresses, AND
• The start address is aligned to that power of 2

Examples

use bare_types::net::Ipv4Range;

let range: Ipv4Range = "192.168.1.0-192.168.1.255".parse().unwrap();
assert!(range.is_cidr_compatible());

let non_cidr: Ipv4Range = "192.168.1.0-192.168.1.100".parse().unwrap();
assert!(!non_cidr.is_cidr_compatible());

pub fn cidr_prefix_len(&self) -> Option<u8>

Returns the prefix length if this range can be represented as a CIDR block.

Examples

use bare_types::net::Ipv4Range;

let range: Ipv4Range = "192.168.1.0-192.168.1.255".parse().unwrap();
assert_eq!(range.cidr_prefix_len(), Some(24));

Trait Implementations

impl Clone for Ipv4Range

fn clone(&self) -> Ipv4Range

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Ipv4Range

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Ipv4Range

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Ipv4Range

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

Formats the value using the given formatter.

impl FromStr for Ipv4Range

type Err = Ipv4RangeError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

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

impl Hash for Ipv4Range

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

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 PartialEq for Ipv4Range

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

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

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

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

impl Serialize for Ipv4Range

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Ipv4Range

impl Eq for Ipv4Range

impl StructuralPartialEq for Ipv4Range