mm1-address 0.7.22

An Erlang-style actor runtime for Rust.
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
82
83
84
85

use std::fmt;

use crate::address::Address;
use crate::subnet::{NetAddress, NetMask};

/// A range of addresses corresponding to some [`NetAddress`].
///
/// The only way to create an instance of [`AddressRange`] is from a
/// [`NetAddress`] or [`Address`], thus only valid ranges are represented by
/// this type.
///
/// This type can be used as a key in a key-value collection that uses `Ord` for
/// its keys. (**NB:** the equality is defined as "if the ranges overlap — they
/// are equal")
#[derive(Debug, Clone, Copy)]
pub struct AddressRange {
    lo: Address,
    hi: Address,
}

impl AddressRange {
    pub fn lo(&self) -> Address {
        self.lo
    }

    pub fn hi(&self) -> Address {
        self.hi
    }
}

impl From<Address> for AddressRange {
    fn from(addr: Address) -> Self {
        Self { lo: addr, hi: addr }
    }
}
impl From<NetAddress> for AddressRange {
    fn from(net: NetAddress) -> Self {
        let lo = net.address;
        let hi = Address::from_u64(net.address.into_u64() | !net.mask.into_u64());

        Self { lo, hi }
    }
}

impl From<AddressRange> for NetAddress {
    fn from(range: AddressRange) -> Self {
        let AddressRange { lo, hi } = range;
        let address = lo;
        let mask_bits = !(lo.into_u64() ^ hi.into_u64());
        let mask = NetMask::try_from(mask_bits.leading_ones() as u8).expect("should be fine");
        Self { address, mask }
    }
}

impl Ord for AddressRange {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        use std::cmp::Ordering::*;

        assert!(self.lo <= self.hi);
        assert!(other.lo <= other.hi);

        match (self.hi.cmp(&other.lo), self.lo.cmp(&other.hi)) {
            (Less, Less) => Less,
            (Greater, Greater) => Greater,
            (..) => Equal,
        }
    }
}
impl PartialEq for AddressRange {
    fn eq(&self, other: &Self) -> bool {
        Ord::cmp(self, other).is_eq()
    }
}
impl Eq for AddressRange {}
impl PartialOrd for AddressRange {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        Some(Ord::cmp(self, other))
    }
}

impl fmt::Display for AddressRange {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}-{}", self.lo, self.hi)
    }
}