elfo-network 0.2.0-alpha.21

Distributed actors for elfo
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

use std::fmt;

use self::compression::Compression;

pub(crate) mod compression;

/// Things supported by the node.
// ~
// Layout:
// ```text
//      16 bits       8 bits         8 bits
// ┌──────────────┬─────────────┬──────────────┐
// │   Reserved   │ Compression │   Reserved   │
// └──────────────┴─────────────┴──────────────┘
// ```
//
// 1. [`Compression`] - compression capabilities.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct Capabilities(u32);

impl Capabilities {
    pub(crate) fn new(compression: Compression) -> Self {
        let compression = compression.into_bits();
        Self(u32::from(compression) << 8)
    }

    pub(crate) const fn from_bits(bits: u32) -> Self {
        Self(bits)
    }

    pub(crate) const fn into_bits(self) -> u32 {
        self.0
    }

    pub(crate) fn intersection(self, rhs: Self) -> Self {
        let compr = self.compression().intersection(rhs.compression());
        Self::new(compr)
    }

    pub(crate) const fn compression(self) -> Compression {
        Compression::from_bits((self.0 >> 8) as u8)
    }
}

impl fmt::Display for Capabilities {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "caps(compression={})", self.compression())
    }
}

#[cfg(test)]
mod tests {
    use proptest::prelude::*;

    use self::compression::Algorithms;
    use super::*;

    #[test]
    fn format_is_compatible_with_020alpha17() {
        let caps = Capabilities::new(Compression::new(Algorithms::LZ4, Algorithms::empty()));
        let lz4_bit = caps.into_bits() & (1 << 8);

        assert_eq!(lz4_bit, 1 << 8);
    }

    #[test]
    fn compression_encoded_right_way() {
        #[track_caller]
        fn case(create: (Algorithms, Algorithms), expect: (Algorithms, Algorithms)) {
            let caps = Capabilities::new(Compression::new(create.0, create.1));
            let compr = caps.compression();

            assert_eq!(compr.supported(), expect.0);
            assert_eq!(compr.preferred(), expect.1);

            // Just in case we should decode same caps.

            let bits = caps.into_bits();
            let same_caps = Capabilities::from_bits(bits);

            assert_eq!(caps, same_caps);
        }

        // Supported does not implies preferred.
        case(
            (Algorithms::LZ4, Algorithms::empty()),
            (Algorithms::LZ4, Algorithms::empty()),
        );

        // Preferred implies supported.
        case(
            (Algorithms::empty(), Algorithms::LZ4),
            (Algorithms::LZ4, Algorithms::LZ4),
        );

        // Nothing ever happens.
        case(
            (Algorithms::empty(), Algorithms::empty()),
            (Algorithms::empty(), Algorithms::empty()),
        );
    }

    proptest! {
        #[test]
        fn intersection_is_commutative(lhs in prop::num::u32::ANY, rhs in prop::num::u32::ANY) {
            let lhs = Capabilities::from_bits(lhs);
            let rhs = Capabilities::from_bits(rhs);
            prop_assert_eq!(lhs.intersection(rhs), rhs.intersection(lhs));
        }
    }
}