weavatrix-graph 0.6.1

Deterministic, evidence-carrying graph primitives for repository intelligence
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
86
87
88
89
90
91
92
93
94
95

use core::cmp::Ordering;

/// Ordered path cost with checked addition.
///
/// Implementations must return a consistent total order for valid values.
pub trait Measure: Copy {
    fn zero() -> Self;
    fn checked_add(self, other: Self) -> Option<Self>;
    fn compare(self, other: Self) -> Option<Ordering>;

    fn is_negative(self) -> bool {
        false
    }

    fn is_valid(self) -> bool {
        self.compare(self).is_some()
    }
}

macro_rules! unsigned_measure {
    ($($type:ty),+ $(,)?) => {
        $(
            impl Measure for $type {
                fn zero() -> Self {
                    0
                }

                fn checked_add(self, other: Self) -> Option<Self> {
                    self.checked_add(other)
                }

                fn compare(self, other: Self) -> Option<Ordering> {
                    Some(self.cmp(&other))
                }
            }
        )+
    };
}

macro_rules! signed_measure {
    ($($type:ty),+ $(,)?) => {
        $(
            impl Measure for $type {
                fn zero() -> Self {
                    0
                }

                fn checked_add(self, other: Self) -> Option<Self> {
                    self.checked_add(other)
                }

                fn compare(self, other: Self) -> Option<Ordering> {
                    Some(self.cmp(&other))
                }

                fn is_negative(self) -> bool {
                    self < 0
                }
            }
        )+
    };
}

macro_rules! float_measure {
    ($($type:ty),+ $(,)?) => {
        $(
            impl Measure for $type {
                fn zero() -> Self {
                    0.0
                }

                fn checked_add(self, other: Self) -> Option<Self> {
                    let sum = self + other;
                    sum.is_finite().then_some(sum)
                }

                fn compare(self, other: Self) -> Option<Ordering> {
                    self.partial_cmp(&other)
                }

                fn is_negative(self) -> bool {
                    self < 0.0
                }

                fn is_valid(self) -> bool {
                    self.is_finite()
                }
            }
        )+
    };
}

unsigned_measure!(u8, u16, u32, u64, u128, usize);
signed_measure!(i8, i16, i32, i64, i128, isize);
float_measure!(f32, f64);