rustmeter-beacon-core 0.2.0

Core library for rustmeter-beacon
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

/// Trait for efficient ZigZag encoding and decoding of signed integers.
pub trait ZigZag: Sized + Copy {
    type Unsigned;

    /// Encodes a signed integer into an unsigned integer.
    /// -1 -> 1, 0 -> 0, 1 -> 2, etc.
    fn zigzag_encode(self) -> Self::Unsigned;

    /// Decodes an unsigned integer back into a signed integer (inverse of encode).
    fn zigzag_decode(encoded: Self::Unsigned) -> Self;
}

// Macro for implementing
macro_rules! impl_zigzag {
    ($signed:ty, $unsigned:ty) => {
        impl ZigZag for $signed {
            type Unsigned = $unsigned;

            #[inline(always)]
            fn zigzag_encode(self) -> Self::Unsigned {
                const BITS: u32 = <$signed>::BITS;
                // (n << 1) ^ (n >> 31)
                // Uses arithmetic shift (>>), which preserves the sign bit.
                ((self << 1) ^ (self >> (BITS - 1))) as $unsigned
            }

            #[inline(always)]
            fn zigzag_decode(encoded: Self::Unsigned) -> Self {
                // (n >> 1) ^ -(n & 1)
                // -(n & 1) is either 0 (if even) or -1 (all bits 1, if odd)
                (encoded >> 1) as $signed ^ -((encoded & 1) as $signed)
            }
        }
    };
}

// Implementations for common types
impl_zigzag!(i8, u8);
impl_zigzag!(i16, u16);
impl_zigzag!(i32, u32);
impl_zigzag!(i64, u64);
impl_zigzag!(isize, usize);

#[cfg(test)]
mod tests {
    use super::ZigZag;
    #[test]
    fn test_zigzag() {
        let enc = (-1i8).zigzag_encode();
        assert_eq!(enc, 1u8);
        let dec = i8::zigzag_decode(enc);
        assert_eq!(dec, -1i8);

        let enc = (0i16).zigzag_encode();
        assert_eq!(enc, 0u16);
        let dec = i16::zigzag_decode(enc);
        assert_eq!(dec, 0i16);

        let enc = (1i32).zigzag_encode();
        assert_eq!(enc, 2u32);
        let dec = i32::zigzag_decode(enc);
        assert_eq!(dec, 1i32);

        let enc = (-12345i64).zigzag_encode();
        assert_eq!(enc, 24689u64);
        let dec = i64::zigzag_decode(enc);
        assert_eq!(dec, -12345i64);
    }
}

/// Trait for writing VarInts
/// Allows generic VarInt writing for unsigned integer types.
pub trait VarIntWritable: Copy + PartialOrd {
    /// Returns whether the value is zero.
    fn is_zero(self) -> bool;

    /// Returns the lower 7 bits as a byte.
    fn low_7_bits(self) -> u8;

    /// Shifts the value right by 7 bits (in-place).
    fn shr_7(&mut self);
}

macro_rules! impl_varint_writable {
    ($($t:ty),*) => {
        $(
            impl VarIntWritable for $t {
                #[inline(always)]
                fn is_zero(self) -> bool {
                    self == 0
                }

                #[inline(always)]
                fn low_7_bits(self) -> u8 {
                    (self & 0x7F) as u8
                }

                #[inline(always)]
                fn shr_7(&mut self) {
                    *self >>= 7;
                }
            }
        )*
    };
}

impl_varint_writable!(u8, u16, u32, u64, usize, u128);