mybatis_drive/types/
bools.rs

1use std::ops::{Deref, DerefMut};
2use rbson::Bson;
3use serde::{Deserializer, Serializer};
4use serde::de::Error;
5
6/// Rbatis Bool
7/// for example:
8/// let b = Bool::from(true);
9/// let b = Bool::from("true");
10/// let b = Bool::from(1);
11///
12///
13/// 1,1.0,"1",true              will be Bool{ inner: true }
14/// -1,0,"2",false...and..more  will be Bool{ inner: false }
15#[derive(Debug, Clone, Eq, Hash, Ord, PartialEq, PartialOrd)]
16pub struct Bool {
17    pub inner: bool,
18}
19
20impl From<bool> for Bool {
21    fn from(arg: bool) -> Self {
22        Bool {
23            inner: arg
24        }
25    }
26}
27
28impl From<i32> for Bool {
29    fn from(arg: i32) -> Self {
30        Bool {
31            inner: {
32                if arg == 1 {
33                    true
34                } else {
35                    false
36                }
37            }
38        }
39    }
40}
41
42impl From<i64> for Bool {
43    fn from(arg: i64) -> Self {
44        Bool {
45            inner: {
46                if arg == 1 {
47                    true
48                } else {
49                    false
50                }
51            }
52        }
53    }
54}
55
56impl From<u32> for Bool {
57    fn from(arg: u32) -> Self {
58        Bool {
59            inner: {
60                if arg == 1 {
61                    true
62                } else {
63                    false
64                }
65            }
66        }
67    }
68}
69
70impl From<u64> for Bool {
71    fn from(arg: u64) -> Self {
72        Bool {
73            inner: {
74                if arg == 1 {
75                    true
76                } else {
77                    false
78                }
79            }
80        }
81    }
82}
83
84impl From<f64> for Bool {
85    fn from(arg: f64) -> Self {
86        Bool {
87            inner: {
88                if arg == 1f64 {
89                    true
90                } else {
91                    false
92                }
93            }
94        }
95    }
96}
97
98
99impl From<&str> for Bool {
100    fn from(arg: &str) -> Self {
101        Bool {
102            inner: {
103                if arg == "true" || arg == "1" || arg == "1.0" {
104                    true
105                } else {
106                    false
107                }
108            }
109        }
110    }
111}
112
113
114impl serde::Serialize for Bool {
115    #[inline]
116    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
117        serializer.serialize_bool(self.inner)
118    }
119}
120
121impl<'de> serde::Deserialize<'de> for Bool {
122    #[inline]
123    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {
124        let bson = Bson::deserialize(deserializer)?;
125        match bson {
126            Bson::Boolean(data) => {
127                return Ok(Bool {
128                    inner: data,
129                });
130            }
131            Bson::Int32(data) => {
132                return Ok(Bool::from(data));
133            }
134            Bson::Int64(data) => {
135                return Ok(Bool::from(data));
136            }
137            Bson::Double(data) => {
138                return Ok(Bool::from(data));
139            }
140            Bson::UInt32(data) => {
141                return Ok(Bool::from(data));
142            }
143            Bson::UInt64(data) => {
144                return Ok(Bool::from(data));
145            }
146            Bson::String(data) => {
147                return Ok(Bool::from(data.as_str()));
148            }
149            _ => {
150                Err(D::Error::custom("deserialize unsupported bson type!"))
151            }
152        }
153    }
154}
155
156impl Deref for Bool {
157    type Target = bool;
158
159    fn deref(&self) -> &Self::Target {
160        &self.inner
161    }
162}
163
164impl DerefMut for Bool {
165    fn deref_mut(&mut self) -> &mut Self::Target {
166        &mut self.inner
167    }
168}
169
170
171
172#[cfg(test)]
173mod test {
174    use crate::Bool;
175
176    #[test]
177    fn test_ser_de() {
178        let b = Bool::from("1");
179        let bsons = rbson::to_bson(&b).unwrap();
180        let b_de: Bool = rbson::from_bson(bsons).unwrap();
181        assert_eq!(b, b_de);
182        assert_eq!(b.inner, b_de.inner);
183    }
184}
mybatis_drive/types/bools.rs

mybatis_drive/types/
bools.rs
