reqrio_json/
json_impl.rs

1use std::collections::HashMap;
2use std::error::Error;
3use std::ops::{Index, IndexMut};
4
5use serde::{Deserialize, Deserializer, Serialize, Serializer};
6use serde_json::Value;
7
8use crate::number::Number;
9use crate::object::Object;
10use crate::{JsonResult, JsonValue, NULL};
11
12impl Index<usize> for JsonValue {
13    type Output = JsonValue;
14
15    fn index(&self, index: usize) -> &Self::Output {
16        match self {
17            JsonValue::Array(vec) => vec.get(index).unwrap_or(&NULL),
18            _ => &NULL
19        }
20    }
21}
22
23impl IndexMut<usize> for JsonValue {
24    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
25        match self {
26            JsonValue::Array(vec) => {
27                let in_bounds = index < vec.len();
28                if in_bounds {
29                    &mut vec[index]
30                } else {
31                    vec.push(JsonValue::Null);
32                    vec.last_mut().unwrap()
33                }
34            }
35            _ => {
36                *self = JsonValue::Array(vec![]);
37                self.push(JsonValue::Null);
38                self.index_mut(index)
39            }
40        }
41    }
42}
43
44impl<'a> Index<&'a str> for JsonValue {
45    type Output = JsonValue;
46
47    fn index(&self, index: &str) -> &JsonValue {
48        match *self {
49            JsonValue::Object(ref object) => &object[index],
50            _ => &NULL
51        }
52    }
53}
54
55impl Index<String> for JsonValue {
56    type Output = JsonValue;
57
58    fn index(&self, index: String) -> &JsonValue {
59        self.index(index.as_str())
60    }
61}
62
63impl<'a> Index<&'a String> for JsonValue {
64    type Output = JsonValue;
65
66    fn index(&self, index: &String) -> &JsonValue {
67        self.index(index.as_str())
68    }
69}
70
71impl<'a> IndexMut<&'a str> for JsonValue {
72    fn index_mut(&mut self, index: &str) -> &mut JsonValue {
73        match *self {
74            JsonValue::Object(ref mut object) => {
75                &mut object[index]
76            }
77            _ => {
78                *self = JsonValue::new_object();
79                self.index_mut(index)
80            }
81        }
82    }
83}
84
85impl IndexMut<String> for JsonValue {
86    fn index_mut(&mut self, index: String) -> &mut JsonValue {
87        self.index_mut(index.as_str())
88    }
89}
90
91impl<'a> IndexMut<&'a String> for JsonValue {
92    fn index_mut(&mut self, index: &String) -> &mut JsonValue {
93        self.index_mut(index.as_str())
94    }
95}
96
97impl JsonValue {
98    pub fn is_string(&self) -> bool {
99        matches!(self, JsonValue::String(_))
100    }
101
102    pub fn is_number(&self) -> bool {
103        matches!(self, JsonValue::Number(_))
104    }
105
106    pub fn is_boolean(&self) -> bool {
107        matches!(self, JsonValue::Boolean(_))
108    }
109
110    pub fn is_null(&self) -> bool {
111        matches!(self, JsonValue::Null)
112    }
113
114    pub fn is_object(&self) -> bool {
115        matches!(self, JsonValue::Object(_))
116    }
117
118    pub fn is_array(&self) -> bool {
119        matches!(self, JsonValue::Array(_))
120    }
121
122    pub fn as_str(&self) -> JsonResult<&str> {
123        match *self {
124            JsonValue::String(ref value) => Ok(value),
125            _ => Err("parse str error!".into())
126        }
127    }
128
129    pub fn as_number(&self) -> JsonResult<Number> {
130        match self {
131            JsonValue::Number(value) => Ok(value.clone()),
132            JsonValue::String(s) => Ok(Number::F64(s.parse::<f64>().or(Err("str to number error!"))?)),
133            _ => Err("not number json value!".into())
134        }
135    }
136
137    pub fn as_f64(&self) -> JsonResult<f64> {
138        Ok(self.as_number()?.as_f64())
139    }
140
141    pub fn as_f32(&self) -> JsonResult<f32> {
142        Ok(self.as_number()?.as_f32())
143    }
144
145    pub fn as_u64(&self) -> JsonResult<u64> {
146        Ok(self.as_number()?.as_u64())
147    }
148
149    pub fn as_u32(&self) -> JsonResult<u32> {
150        Ok(self.as_number()?.as_u32())
151    }
152
153    pub fn as_u16(&self) -> JsonResult<u16> {
154        Ok(self.as_number()?.as_u16())
155    }
156
157    pub fn as_u8(&self) -> JsonResult<u8> {
158        Ok(self.as_number()?.as_u8())
159    }
160
161    pub fn as_usize(&self) -> JsonResult<usize> {
162        Ok(self.as_number()?.as_usize())
163    }
164
165    pub fn as_i64(&self) -> JsonResult<i64> {
166        Ok(self.as_number()?.as_i64())
167    }
168
169    pub fn as_i32(&self) -> JsonResult<i32> {
170        Ok(self.as_number()?.as_i32())
171    }
172
173    pub fn as_i16(&self) -> JsonResult<i16> {
174        Ok(self.as_number()?.as_i16())
175    }
176
177    pub fn as_i8(&self) -> JsonResult<i8> {
178        Ok(self.as_number()?.as_i8())
179    }
180
181    pub fn as_isize(&self) -> JsonResult<isize> {
182        Ok(self.as_number()?.as_isize())
183    }
184
185    pub fn as_bool(&self) -> JsonResult<bool> {
186        match self {
187            JsonValue::Boolean(value) => Ok(*value),
188            _ => Err("parse bool error!".into())
189        }
190    }
191}
192
193impl From<String> for JsonValue {
194    fn from(value: String) -> Self {
195        JsonValue::String(value)
196    }
197}
198
199impl<'a> From<&'a str> for JsonValue {
200    fn from(value: &'a str) -> Self {
201        JsonValue::String(value.to_string())
202    }
203}
204
205impl<'a> From<&'a String> for JsonValue {
206    fn from(value: &'a String) -> Self {
207        JsonValue::String(value.to_string())
208    }
209}
210
211impl From<i8> for JsonValue {
212    fn from(value: i8) -> Self {
213        JsonValue::Number(Number::I8(value))
214    }
215}
216
217impl From<&i8> for JsonValue {
218    fn from(value: &i8) -> Self {
219        JsonValue::Number(Number::I8(*value))
220    }
221}
222
223impl From<i16> for JsonValue {
224    fn from(value: i16) -> Self {
225        JsonValue::Number(Number::I16(value))
226    }
227}
228
229impl From<&i16> for JsonValue {
230    fn from(value: &i16) -> Self {
231        JsonValue::Number(Number::I16(*value))
232    }
233}
234
235impl From<i32> for JsonValue {
236    fn from(value: i32) -> Self {
237        JsonValue::Number(Number::I32(value))
238    }
239}
240
241impl From<&i32> for JsonValue {
242    fn from(value: &i32) -> Self {
243        JsonValue::Number(Number::I32(*value))
244    }
245}
246
247impl From<i64> for JsonValue {
248    fn from(value: i64) -> Self {
249        JsonValue::Number(Number::I64(value))
250    }
251}
252
253impl From<&i64> for JsonValue {
254    fn from(value: &i64) -> Self {
255        JsonValue::Number(Number::I64(*value))
256    }
257}
258
259impl From<i128> for JsonValue {
260    fn from(value: i128) -> Self {
261        JsonValue::Number(Number::I128(value))
262    }
263}
264
265impl From<&i128> for JsonValue {
266    fn from(value: &i128) -> Self {
267        JsonValue::Number(Number::I128(*value))
268    }
269}
270
271impl From<isize> for JsonValue {
272    fn from(value: isize) -> Self {
273        JsonValue::Number(Number::Isize(value))
274    }
275}
276
277impl From<u8> for JsonValue {
278    fn from(value: u8) -> Self {
279        JsonValue::Number(Number::U8(value))
280    }
281}
282
283impl From<&u8> for JsonValue {
284    fn from(value: &u8) -> Self {
285        JsonValue::Number(Number::U8(*value))
286    }
287}
288
289impl From<u16> for JsonValue {
290    fn from(value: u16) -> Self {
291        JsonValue::Number(Number::U16(value))
292    }
293}
294
295impl From<&u16> for JsonValue {
296    fn from(value: &u16) -> Self {
297        JsonValue::Number(Number::U16(*value))
298    }
299}
300
301impl From<u32> for JsonValue {
302    fn from(value: u32) -> Self {
303        JsonValue::Number(Number::U32(value))
304    }
305}
306
307impl From<&u32> for JsonValue {
308    fn from(value: &u32) -> Self {
309        JsonValue::Number(Number::U32(*value))
310    }
311}
312
313impl From<u64> for JsonValue {
314    fn from(value: u64) -> Self {
315        JsonValue::Number(Number::U64(value))
316    }
317}
318
319impl From<&u64> for JsonValue {
320    fn from(value: &u64) -> Self {
321        JsonValue::Number(Number::U64(*value))
322    }
323}
324
325impl From<u128> for JsonValue {
326    fn from(value: u128) -> Self {
327        JsonValue::Number(Number::U128(value))
328    }
329}
330
331impl From<&u128> for JsonValue {
332    fn from(value: &u128) -> Self {
333        JsonValue::Number(Number::U128(*value))
334    }
335}
336
337impl From<usize> for JsonValue {
338    fn from(value: usize) -> Self {
339        JsonValue::Number(Number::I64(value as i64))
340    }
341}
342
343impl From<f32> for JsonValue {
344    fn from(value: f32) -> Self {
345        JsonValue::Number(Number::F32(value))
346    }
347}
348
349impl From<&f32> for JsonValue {
350    fn from(value: &f32) -> Self {
351        JsonValue::Number(Number::F32(*value))
352    }
353}
354
355impl From<f64> for JsonValue {
356    fn from(value: f64) -> Self {
357        JsonValue::Number(Number::F64(value))
358    }
359}
360
361impl From<&f64> for JsonValue {
362    fn from(value: &f64) -> Self {
363        JsonValue::Number(Number::F64(*value))
364    }
365}
366
367
368impl From<bool> for JsonValue {
369    fn from(value: bool) -> Self {
370        JsonValue::Boolean(value)
371    }
372}
373
374impl From<&bool> for JsonValue {
375    fn from(value: &bool) -> Self {
376        JsonValue::Boolean(*value)
377    }
378}
379
380impl<T> From<Vec<T>> for JsonValue
381where
382    T: Into<JsonValue>,
383{
384    fn from(value: Vec<T>) -> Self {
385        let mut array = JsonValue::new_array();
386        for v in value {
387            array.push(v.into());
388        }
389        array
390    }
391}
392
393
394impl<'a, T> From<HashMap<&'a str, T>> for JsonValue
395where
396    T: Into<JsonValue>,
397{
398    fn from(value: HashMap<&'a str, T>) -> Self {
399        let mut object = JsonValue::new_object();
400        for (k, v) in value {
401            object.insert(k, v.into()).unwrap();
402        }
403        object
404    }
405}
406
407impl<T> From<HashMap<String, T>> for JsonValue
408where
409    T: Into<JsonValue>,
410{
411    fn from(value: HashMap<String, T>) -> Self {
412        let mut object = JsonValue::new_object();
413        for (k, v) in value {
414            object.insert(k.as_str(), v.into()).unwrap();
415        }
416        object
417    }
418}
419
420impl<'a, T: Clone> From<&'a [T]> for JsonValue
421where
422    T: Into<JsonValue>,
423{
424    fn from(value: &'a [T]) -> Self {
425        let mut array = JsonValue::new_array();
426        for v in value {
427            array.push(v.clone().into())
428        };
429        array
430    }
431}
432
433impl<T> From<Option<T>> for JsonValue
434where
435    T: Into<JsonValue>,
436{
437    fn from(value: Option<T>) -> Self {
438        match value {
439            None => { JsonValue::Null }
440            Some(v) => { v.into() }
441        }
442    }
443}
444
445impl Into<Box<dyn Error>> for JsonValue {
446    fn into(self) -> Box<dyn Error> {
447        Box::from(self.to_string())
448    }
449}
450
451impl Serialize for JsonValue {
452    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
453    where
454        S: Serializer,
455    {
456        match self {
457            JsonValue::Null => Value::Null.serialize(serializer),
458            JsonValue::String(v) => v.serialize(serializer),
459            JsonValue::Number(v) => v.serialize(serializer),
460            JsonValue::Boolean(v) => v.serialize(serializer),
461            JsonValue::Object(v) => v.serialize(serializer),
462            JsonValue::Array(v) => v.serialize(serializer),
463        }
464    }
465}
466
467impl<'de> Deserialize<'de> for JsonValue {
468    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
469    where
470        D: Deserializer<'de>,
471    {
472        let value = Value::deserialize(deserializer)?;
473        Ok(JsonValue::try_from(value).or(Err(serde::de::Error::custom("to json value error")))?)
474    }
475}
476
477impl TryFrom<Value> for JsonValue {
478    type Error = serde::de::value::Error;
479
480    fn try_from(value: Value) -> Result<Self, Self::Error> {
481        match value {
482            Value::Null => Ok(JsonValue::Null),
483            Value::Bool(v) => Ok(JsonValue::Boolean(v)),
484            Value::Number(v) => Ok(JsonValue::Number(Number::try_from(v).or(Err(serde::de::Error::custom("to number error")))?)),
485            Value::String(v) => Ok(JsonValue::String(v)),
486            Value::Array(v) => {
487                let mut array = JsonValue::new_array();
488                for value in v {
489                    array.push(JsonValue::try_from(value)?);
490                }
491                Ok(array)
492            }
493            Value::Object(v) => Ok(JsonValue::Object(Object::try_from(v)?))
494        }
495    }
496}
497
498#[cfg(test)]
499mod tests {
500    use crate::JsonValue;
501
502    #[test]
503    fn test_object() {
504        let jd = crate::object! {
505            "sdsd":"dffdf",
506            "dfdf":[1,2,3,4],
507            "dfdg":null,
508            "tf":1,
509            "fs":false,
510            "sf":1.23234,
511            "dffdfdf":{
512                "1":1,
513                "2":2,
514                "3":3,
515            }
516        };
517        let strs = serde_json::to_string_pretty(&jd).unwrap();
518        println!("{}", strs);
519        let v: JsonValue = serde_json::from_str(&strs).unwrap();
520        println!("{}", v.pretty());
521        println!("{} {}", v["sdsd"].to_string(), v["tf"].pretty())
522    }
523}
reqrio_json/json_impl.rs

reqrio_json/
json_impl.rs
