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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use core::cmp::Ordering::{self, Equal, Greater, Less};

use super::{Address, Prefix};
use crate::traits::Afi;

/// Ordering relationship between a pair of [`Prefix<A>`] `P` and `Q`.
#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
pub enum PrefixOrdering<A: Afi> {
    /// `Q` is equal to `P`.
    Equal,
    /// `Q` is a subprefix of `P`.
    Subprefix(Prefix<A>),
    /// `Q` is a superprefix of `P`.
    Superprefix(Prefix<A>),
    /// Neither `P` nor `Q` is a subprefix of the other.
    Divergent(Prefix<A>),
}

impl<A: Afi> Prefix<A> {
    /// Perform ordinal comparison with another [`Prefix<A>`], calculating the
    /// longest common prefix in the process.
    pub fn compare(&self, other: &Self) -> PrefixOrdering<A> {
        let common = self.common_with(other);
        match (
            self.length().cmp(&common.length()),
            other.length().cmp(&common.length()),
        ) {
            (Equal, Equal) => PrefixOrdering::Equal,
            (Equal, Greater) => PrefixOrdering::Subprefix(common),
            (Greater, Equal) => PrefixOrdering::Superprefix(common),
            (Greater, Greater) => PrefixOrdering::Divergent(common),
            (Less, _) | (_, Less) => {
                unreachable!("common must be shorter than both prefixes")
            }
        }
    }
}

impl<A: Afi> PartialOrd<Self> for Prefix<A> {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        match self.compare(other) {
            PrefixOrdering::Equal => Some(Equal),
            PrefixOrdering::Subprefix(_) => Some(Greater),
            PrefixOrdering::Superprefix(_) => Some(Less),
            PrefixOrdering::Divergent(_) => None,
        }
    }
}

impl<A: Afi> PartialEq<Address<A>> for Prefix<A> {
    fn eq(&self, other: &Address<A>) -> bool {
        self.eq(&Self::from(*other))
    }
}

impl<A: Afi> PartialOrd<Address<A>> for Prefix<A> {
    fn partial_cmp(&self, other: &Address<A>) -> Option<Ordering> {
        self.partial_cmp(&Self::from(*other))
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{Ipv4, Ipv6};

    mod ipv4 {
        use super::*;

        #[test]
        fn equal() {
            let x = "10.0.0.0/8".parse::<Prefix<Ipv4>>().unwrap();
            let y = "10.0.0.0/8".parse::<Prefix<Ipv4>>().unwrap();
            assert!(x == y);
        }

        #[test]
        fn lt() {
            let x = "10.0.0.0/16".parse::<Prefix<Ipv4>>().unwrap();
            let y = "10.0.0.0/8".parse::<Prefix<Ipv4>>().unwrap();
            assert!(x < y);
        }

        #[test]
        fn gt() {
            let x = "10.0.0.0/16".parse::<Prefix<Ipv4>>().unwrap();
            let y = "10.0.0.0/24".parse::<Prefix<Ipv4>>().unwrap();
            assert!(x > y);
        }

        #[test]
        fn divergent() {
            let x = "10.0.0.0/16".parse::<Prefix<Ipv4>>().unwrap();
            let y = "10.1.0.0/16".parse::<Prefix<Ipv4>>().unwrap();
            assert!(matches!(x.partial_cmp(&y), None));
        }
    }

    mod ipv6 {
        use super::*;

        #[test]
        fn equal() {
            let x = "2001:db8::/32".parse::<Prefix<Ipv6>>().unwrap();
            let y = "2001:db8::/32".parse::<Prefix<Ipv6>>().unwrap();
            assert!(x == y);
        }

        #[test]
        fn lt() {
            let x = "2001:db8::/48".parse::<Prefix<Ipv6>>().unwrap();
            let y = "2001:db8::/32".parse::<Prefix<Ipv6>>().unwrap();
            assert!(x < y);
        }

        #[test]
        fn gt() {
            let x = "2001:db8::/48".parse::<Prefix<Ipv6>>().unwrap();
            let y = "2001:db8::/64".parse::<Prefix<Ipv6>>().unwrap();
            assert!(x > y);
        }

        #[test]
        fn divergent() {
            let x = "2001:db8:f::/48".parse::<Prefix<Ipv6>>().unwrap();
            let y = "2001:db8:a::/48".parse::<Prefix<Ipv6>>().unwrap();
            assert!(matches!(x.partial_cmp(&y), None));
        }
    }
}