satint 0.3.1

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
96
97
98
99
100
101

use serde::{Deserialize, Deserializer, Serialize, Serializer};

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

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, Sisize, Su8, Su16, Su32, Su64, Su128, Susize
);

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

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

    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, Sisize, Su8, Su16, Su32, Su64, Su128, Susize
    );

    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)
        sisize_tests;  Sisize; -123_456;       Token::I64(-123_456)
        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)
        susize_tests;  Susize; 123_456;        Token::U64(123_456)
    );
}