ipnetx 0.1.0

IP address range, prefix, and set operations for IPv4 and IPv6
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

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

/// Sealed marker trait that restricts [`IpAddress`] implementations to
/// [`Ipv4Addr`] and [`Ipv6Addr`] defined within this crate.
///
/// This is the "sealed trait" pattern: `Sealed` is `pub` inside a private
/// module, so external crates cannot name it and therefore cannot implement
/// [`IpAddress`] on their own types — even ones that satisfy all the other
/// bounds like `Copy + PartialOrd + Display`.
pub trait IpAddress:
    crate::private::Sealed
    + PartialOrd
    + Copy
    + std::fmt::Display
    + std::fmt::Debug
    + PartialEq
    + Eq
    + std::hash::Hash
{
    /// Number of bits in this address type: 32 for IPv4, 128 for IPv6.
    const BITS: u8;

    /// Returns `true` if this is the unspecified address (`0.0.0.0` for IPv4,
    /// `::` for IPv6).
    fn is_unspecified(&self) -> bool;

    /// Convert this address to a u128. IPv4 uses the low 32 bits.
    fn to_u128(self) -> u128;

    /// Construct an address from a u128. IPv4 reads the low 32 bits.
    fn from_u128(bits: u128) -> Self;

    /// Parse an IP address from its text representation.
    ///
    /// Returns `None` if the string is not a valid address for this address
    /// family (`Ipv4Addr` rejects IPv6 notation and vice-versa).
    /// This is used internally by the [`FromStr`](std::str::FromStr)
    /// implementations on [`IpPrefix`](crate::prefix::IpPrefix) and
    /// [`IpRange`](crate::range::IpRange).
    fn parse_addr(s: &str) -> Option<Self>;
}

impl IpAddress for Ipv4Addr {
    const BITS: u8 = 32;

    fn is_unspecified(&self) -> bool {
        Ipv4Addr::is_unspecified(self)
    }

    fn to_u128(self) -> u128 {
        self.to_bits() as u128
    }

    fn from_u128(bits: u128) -> Self {
        Ipv4Addr::from_bits(bits as u32)
    }

    fn parse_addr(s: &str) -> Option<Self> {
        s.parse().ok()
    }
}

impl IpAddress for Ipv6Addr {
    const BITS: u8 = 128;

    fn is_unspecified(&self) -> bool {
        Ipv6Addr::is_unspecified(self)
    }

    fn to_u128(self) -> u128 {
        self.to_bits()
    }

    fn from_u128(bits: u128) -> Self {
        Ipv6Addr::from_bits(bits)
    }

    fn parse_addr(s: &str) -> Option<Self> {
        s.parse().ok()
    }
}