cetus_utils/
integer_type.rs

1use core::fmt;
2use serde::{Deserialize, Serialize, Serializer};
3
4#[derive(Debug, Clone, Default, Deserialize)]
5pub struct I64 {
6    pub bits: u64,
7}
8
9impl I64 {
10    pub fn as_i64(&self) -> i64 {
11        self.bits as i64
12    }
13
14    pub fn inner_to(&self) -> i64 {
15        self.bits as i64
16    }
17}
18
19impl From<i64> for I64 {
20    fn from(d: i64) -> Self {
21        Self { bits: (d as u64) }
22    }
23}
24
25impl From<i32> for I64 {
26    fn from(d: i32) -> Self {
27        Self { bits: (d as u64) }
28    }
29}
30
31impl From<I64> for i64 {
32    fn from(d: I64) -> Self {
33        d.bits as i64
34    }
35}
36
37impl fmt::Display for I64 {
38    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
39        write!(f, "{}", self.inner_to())
40    }
41}
42
43impl Serialize for I64 {
44    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
45        self.as_i64().to_string().serialize(serializer)
46    }
47}
48
49#[derive(Debug, Clone, Default, Deserialize)]
50pub struct I128 {
51    pub bits: u128,
52}
53
54impl I128 {
55    pub fn as_i128(&self) -> i128 {
56        self.bits as i128
57    }
58
59    pub fn inner_to(&self) -> i128 {
60        self.bits as i128
61    }
62}
63
64impl From<i128> for I128 {
65    fn from(d: i128) -> Self {
66        Self { bits: (d as u128) }
67    }
68}
69
70impl From<I128> for i128 {
71    fn from(d: I128) -> Self {
72        d.bits as i128
73    }
74}
75
76impl fmt::Display for I128 {
77    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
78        write!(f, "{}", self.inner_to())
79    }
80}
81
82impl Serialize for I128 {
83    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
84        self.as_i128().to_string().serialize(serializer)
85    }
86}
87
88mod test {
89    #[test]
90    fn test_i64_desearialize() {
91        use super::I64;
92        let data = r#"
93            {
94                "bits": "17446744073709551617"
95            }
96        "#;
97        let v: I64 = serde_json::from_str(data).unwrap();
98        assert_eq!(v.as_i64(), -999999999999999999);
99
100        let data = r#"
101            {
102                "bits": "10000000000"
103            }
104        "#;
105        let v: I64 = serde_json::from_str(data).unwrap();
106        assert_eq!(v.as_i64(), 10000000000);
107
108        let data = r#"
109            {
110                "bits": "0"
111            }
112        "#;
113        let v: I64 = serde_json::from_str(data).unwrap();
114        assert_eq!(v.as_i64(), 0);
115
116        let data = r#"
117            {
118                "bits": "9223372036854775807"
119            }
120        "#;
121        let v: I64 = serde_json::from_str(data).unwrap();
122        assert_eq!(v.as_i64(), 9223372036854775807);
123
124        let data = r#"
125            {
126                "bits": "9223372036854775808"
127            }
128        "#;
129        let v: I64 = serde_json::from_str(data).unwrap();
130        assert_eq!(v.as_i64(), -9223372036854775808);
131    }
132
133    #[test]
134    fn test_i64_from() {
135        use super::I64;
136        assert_eq!(I64::from(0i32).as_i64(), 0i64);
137        assert_eq!(I64::from(-12i32).as_i64(), -12i64);
138        assert_eq!(I64::from(i32::MIN).as_i64(), i32::MIN as i64);
139        assert_eq!(I64::from(i32::MAX).as_i64(), i32::MAX as i64);
140
141        assert_eq!(I64::from(-12i64).as_i64(), -12i64);
142        assert_eq!(I64::from(i64::MIN).as_i64(), i64::MIN as i64);
143        assert_eq!(I64::from(i64::MAX).as_i64(), i64::MAX as i64);
144    }
145}
cetus_utils/integer_type.rs

cetus_utils/
integer_type.rs
