satint 0.3.0

Saturating integers
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 serde::{Deserialize, Deserializer, Serialize, Serializer};

use crate::{
    common::Inner,
    si::{Si8, Si16, Si32, Si64, Si128},
    su::{Su8, Su16, Su32, Su64, Su128},
};

macro_rules! generate_serde {
    ($($name:ident),+ $(,)?) => {
        $(
            impl Serialize for $name {
                #[inline]
                fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                where
                    S: Serializer,
                {
                    self.as_inner().serialize(serializer)
                }
            }

            impl<'de> Deserialize<'de> for $name {
                #[inline]
                fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
                where
                    D: Deserializer<'de>,
                {
                    type InnerTy = <$name as Inner>::Inner;
                    InnerTy::deserialize(deserializer).map(Self::new)
                }
            }
        )+
    };
}

generate_serde!(Si8, Si16, Si32, Si64, Si128, Su8, Su16, Su32, Su64, Su128);

#[cfg(test)]
mod tests {
    use ::serde::{Deserialize, Serialize};
    use serde_test::{Token, assert_tokens};

    use crate::{
        si::{Si8, Si16, Si32, Si64, Si128},
        su::{Su8, Su16, Su32, Su64, Su128},
    };

    fn assert_serialize<T: Serialize>() {}

    fn assert_deserialize<T>()
    where
        T: for<'de> Deserialize<'de>,
    {
    }

    macro_rules! test_serde_traits {
        ($($name:ident),+ $(,)?) => {
            #[test]
            fn generated_types_implement_serde_traits() {
                $(
                    assert_serialize::<$name>();
                    assert_deserialize::<$name>();
                )+
            }
        };
    }

    test_serde_traits!(Si8, Si16, Si32, Si64, Si128, Su8, Su16, Su32, Su64, Su128);

    macro_rules! test_serde_tokens {
        ($($mod_name:ident; $name:ident; $value:expr; $token:expr)+) => {
            $(
                mod $mod_name {
                    use super::*;

                    #[test]
                    fn round_trips_as_inner_primitive() {
                        assert_tokens(&$name::new($value), &[$token]);
                    }
                }
            )+
        };
    }

    test_serde_tokens!(
        si8_tests;  Si8;  -12;          Token::I8(-12)
        si16_tests; Si16; -1234;        Token::I16(-1234)
        si32_tests; Si32; -123_456;     Token::I32(-123_456)
        si64_tests; Si64; -123_456_789; Token::I64(-123_456_789)
        su8_tests;  Su8;  200;          Token::U8(200)
        su16_tests; Su16; 60_000;       Token::U16(60_000)
        su32_tests; Su32; 3_000_000_000; Token::U32(3_000_000_000)
        su64_tests; Su64; u64::MAX;     Token::U64(u64::MAX)
    );
}