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
97// impl Serialize for JsonValue {
98//     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
99//     where
100//         S: Serializer,
101//     {
102//         let ser_str = match self {
103//             JsonValue::String(s) => format!("\"{s}\""),
104//             _ => { self.dump() }
105//         };
106//         let json_value: Value = serde_json::from_str(&ser_str).unwrap();
107//         serializer.serialize_some(&json_value)
108//     }
109// }
110
111// impl<'de> Deserialize<'de> for JsonValue {
112//     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
113//     where
114//         D: Deserializer<'de>,
115//     {
116//         let json_value: Value = Deserialize::deserialize(deserializer)?;
117//         let json_str = serde_json::to_string(&json_value).unwrap();
118//         Ok(JsonParser::new().parse_json(mh_json::parse(json_str.as_str()).unwrap()).unwrap())
119//     }
120// }
121
122impl JsonValue {
123    pub fn is_string(&self) -> bool {
124        match *self {
125            JsonValue::String(_) => true,
126            _ => false,
127        }
128    }
129
130    pub fn is_number(&self) -> bool {
131        match *self {
132            JsonValue::Number(_) => true,
133            _ => false,
134        }
135    }
136
137    pub fn is_boolean(&self) -> bool {
138        match *self {
139            JsonValue::Boolean(_) => true,
140            _ => false
141        }
142    }
143
144    pub fn is_null(&self) -> bool {
145        match *self {
146            JsonValue::Null => true,
147            _ => false,
148        }
149    }
150
151    pub fn is_object(&self) -> bool {
152        match *self {
153            JsonValue::Object(_) => true,
154            _ => false,
155        }
156    }
157
158    pub fn is_array(&self) -> bool {
159        match *self {
160            JsonValue::Array(_) => true,
161            _ => false,
162        }
163    }
164
165    pub fn as_str(&self) -> JsonResult<&str> {
166        match *self {
167            JsonValue::String(ref value) => Ok(value),
168            _ => Err("parse str error!".into())
169        }
170    }
171
172    pub fn as_number(&self) -> JsonResult<Number> {
173        match self {
174            JsonValue::Number(value) => Ok(value.clone()),
175            JsonValue::String(s) => Ok(Number::F64(s.parse::<f64>().or(Err("str to number error!"))?)),
176            _ => Err("not number json value!".into())
177        }
178    }
179
180    pub fn as_f64(&self) -> JsonResult<f64> {
181        Ok(self.as_number()?.as_f64())
182    }
183
184    pub fn as_f32(&self) -> JsonResult<f32> {
185        Ok(self.as_number()?.as_f32())
186    }
187
188    pub fn as_u64(&self) -> JsonResult<u64> {
189        Ok(self.as_number()?.as_u64())
190    }
191
192    pub fn as_u32(&self) -> JsonResult<u32> {
193        Ok(self.as_number()?.as_u32())
194    }
195
196    pub fn as_u16(&self) -> JsonResult<u16> {
197        Ok(self.as_number()?.as_u16())
198    }
199
200    pub fn as_u8(&self) -> JsonResult<u8> {
201        Ok(self.as_number()?.as_u8())
202    }
203
204    pub fn as_usize(&self) -> JsonResult<usize> {
205        Ok(self.as_number()?.as_usize())
206    }
207
208    pub fn as_i64(&self) -> JsonResult<i64> {
209        Ok(self.as_number()?.as_i64())
210    }
211
212    pub fn as_i32(&self) -> JsonResult<i32> {
213        Ok(self.as_number()?.as_i32())
214    }
215
216    pub fn as_i16(&self) -> JsonResult<i16> {
217        Ok(self.as_number()?.as_i16())
218    }
219
220    pub fn as_i8(&self) -> JsonResult<i8> {
221        Ok(self.as_number()?.as_i8())
222    }
223
224    pub fn as_isize(&self) -> JsonResult<isize> {
225        Ok(self.as_number()?.as_isize())
226    }
227
228    pub fn as_bool(&self) -> JsonResult<bool> {
229        match *self {
230            JsonValue::Boolean(ref value) => Ok(value.clone()),
231            _ => Err("parse bool error!".into())
232        }
233    }
234}
235
236impl From<String> for JsonValue {
237    fn from(value: String) -> Self {
238        JsonValue::String(value)
239    }
240}
241
242impl<'a> From<&'a str> for JsonValue {
243    fn from(value: &'a str) -> Self {
244        JsonValue::String(value.to_string())
245    }
246}
247
248impl<'a> From<&'a String> for JsonValue {
249    fn from(value: &'a String) -> Self {
250        JsonValue::String(value.to_string())
251    }
252}
253
254impl From<i8> for JsonValue {
255    fn from(value: i8) -> Self {
256        JsonValue::Number(Number::I8(value))
257    }
258}
259
260impl From<&i8> for JsonValue {
261    fn from(value: &i8) -> Self {
262        JsonValue::Number(Number::I8(*value))
263    }
264}
265
266impl From<i16> for JsonValue {
267    fn from(value: i16) -> Self {
268        JsonValue::Number(Number::I16(value))
269    }
270}
271
272impl From<&i16> for JsonValue {
273    fn from(value: &i16) -> Self {
274        JsonValue::Number(Number::I16(*value))
275    }
276}
277
278impl From<i32> for JsonValue {
279    fn from(value: i32) -> Self {
280        JsonValue::Number(Number::I32(value))
281    }
282}
283
284impl From<&i32> for JsonValue {
285    fn from(value: &i32) -> Self {
286        JsonValue::Number(Number::I32(*value))
287    }
288}
289
290impl From<i64> for JsonValue {
291    fn from(value: i64) -> Self {
292        JsonValue::Number(Number::I64(value))
293    }
294}
295
296impl From<&i64> for JsonValue {
297    fn from(value: &i64) -> Self {
298        JsonValue::Number(Number::I64(*value))
299    }
300}
301
302impl From<i128> for JsonValue {
303    fn from(value: i128) -> Self {
304        JsonValue::Number(Number::I128(value))
305    }
306}
307
308impl From<&i128> for JsonValue {
309    fn from(value: &i128) -> Self {
310        JsonValue::Number(Number::I128(*value))
311    }
312}
313
314impl From<isize> for JsonValue {
315    fn from(value: isize) -> Self {
316        JsonValue::Number(Number::Isize(value))
317    }
318}
319
320impl From<u8> for JsonValue {
321    fn from(value: u8) -> Self {
322        JsonValue::Number(Number::U8(value))
323    }
324}
325
326impl From<&u8> for JsonValue {
327    fn from(value: &u8) -> Self {
328        JsonValue::Number(Number::U8(*value))
329    }
330}
331
332impl From<u16> for JsonValue {
333    fn from(value: u16) -> Self {
334        JsonValue::Number(Number::U16(value))
335    }
336}
337
338impl From<&u16> for JsonValue {
339    fn from(value: &u16) -> Self {
340        JsonValue::Number(Number::U16(*value))
341    }
342}
343
344impl From<u32> for JsonValue {
345    fn from(value: u32) -> Self {
346        JsonValue::Number(Number::U32(value))
347    }
348}
349
350impl From<&u32> for JsonValue {
351    fn from(value: &u32) -> Self {
352        JsonValue::Number(Number::U32(*value))
353    }
354}
355
356impl From<u64> for JsonValue {
357    fn from(value: u64) -> Self {
358        JsonValue::Number(Number::U64(value))
359    }
360}
361
362impl From<&u64> for JsonValue {
363    fn from(value: &u64) -> Self {
364        JsonValue::Number(Number::U64(*value))
365    }
366}
367
368impl From<u128> for JsonValue {
369    fn from(value: u128) -> Self {
370        JsonValue::Number(Number::U128(value))
371    }
372}
373
374impl From<&u128> for JsonValue {
375    fn from(value: &u128) -> Self {
376        JsonValue::Number(Number::U128(*value))
377    }
378}
379
380impl From<usize> for JsonValue {
381    fn from(value: usize) -> Self {
382        JsonValue::Number(Number::I64(value as i64))
383    }
384}
385
386impl From<f32> for JsonValue {
387    fn from(value: f32) -> Self {
388        JsonValue::Number(Number::F32(value))
389    }
390}
391
392impl From<&f32> for JsonValue {
393    fn from(value: &f32) -> Self {
394        JsonValue::Number(Number::F32(*value))
395    }
396}
397
398impl From<f64> for JsonValue {
399    fn from(value: f64) -> Self {
400        JsonValue::Number(Number::F64(value))
401    }
402}
403
404impl From<&f64> for JsonValue {
405    fn from(value: &f64) -> Self {
406        JsonValue::Number(Number::F64(*value))
407    }
408}
409
410
411impl From<bool> for JsonValue {
412    fn from(value: bool) -> Self {
413        JsonValue::Boolean(value)
414    }
415}
416
417impl From<&bool> for JsonValue {
418    fn from(value: &bool) -> Self {
419        JsonValue::Boolean(*value)
420    }
421}
422
423impl<T> From<Vec<T>> for JsonValue
424where
425    T: Into<JsonValue>,
426{
427    fn from(value: Vec<T>) -> Self {
428        let mut array = JsonValue::new_array();
429        for v in value {
430            array.push(v.into());
431        }
432        array
433    }
434}
435
436
437impl<'a, T> From<HashMap<&'a str, T>> for JsonValue
438where
439    T: Into<JsonValue>,
440{
441    fn from(value: HashMap<&'a str, T>) -> Self {
442        let mut object = JsonValue::new_object();
443        for (k, v) in value {
444            object.insert(k, v.into()).unwrap();
445        }
446        object
447    }
448}
449
450impl<T> From<HashMap<String, T>> for JsonValue
451where
452    T: Into<JsonValue>,
453{
454    fn from(value: HashMap<String, T>) -> Self {
455        let mut object = JsonValue::new_object();
456        for (k, v) in value {
457            object.insert(k.as_str(), v.into()).unwrap();
458        }
459        object
460    }
461}
462
463impl<'a, T: Clone> From<&'a [T]> for JsonValue
464where
465    T: Into<JsonValue>,
466{
467    fn from(value: &'a [T]) -> Self {
468        let mut array = JsonValue::new_array();
469        for v in value {
470            array.push(v.clone().into())
471        };
472        array
473    }
474}
475
476impl<T> From<Option<T>> for JsonValue
477where
478    T: Into<JsonValue>,
479{
480    fn from(value: Option<T>) -> Self {
481        match value {
482            None => { JsonValue::Null }
483            Some(v) => { v.into() }
484        }
485    }
486}
487
488impl Into<Box<dyn Error>> for JsonValue {
489    fn into(self) -> Box<dyn Error> {
490        Box::from(self.to_string())
491    }
492}
493
494impl Serialize for JsonValue {
495    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
496    where
497        S: Serializer,
498    {
499        match self {
500            JsonValue::Null => Value::Null.serialize(serializer),
501            JsonValue::String(v) => v.serialize(serializer),
502            JsonValue::Number(v) => v.serialize(serializer),
503            JsonValue::Boolean(v) => v.serialize(serializer),
504            JsonValue::Object(v) => v.serialize(serializer),
505            JsonValue::Array(v) => v.serialize(serializer),
506        }
507    }
508}
509
510impl<'de> Deserialize<'de> for JsonValue {
511    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
512    where
513        D: Deserializer<'de>,
514    {
515        let value = Value::deserialize(deserializer)?;
516        Ok(JsonValue::try_from(value).or(Err(serde::de::Error::custom("to json value error")))?)
517    }
518}
519
520impl TryFrom<Value> for JsonValue {
521    type Error = serde::de::value::Error;
522
523    fn try_from(value: Value) -> Result<Self, Self::Error> {
524        match value {
525            Value::Null => Ok(JsonValue::Null),
526            Value::Bool(v) => Ok(JsonValue::Boolean(v)),
527            Value::Number(v) => Ok(JsonValue::Number(Number::try_from(v).or(Err(serde::de::Error::custom("to number error")))?)),
528            Value::String(v) => Ok(JsonValue::String(v)),
529            Value::Array(v) => {
530                let mut array = JsonValue::new_array();
531                for value in v {
532                    array.push(JsonValue::try_from(value)?);
533                }
534                Ok(array)
535            }
536            Value::Object(v) => Ok(JsonValue::Object(Object::try_from(v)?))
537        }
538    }
539}
540
541#[cfg(test)]
542mod tests {
543    use crate::JsonValue;
544
545    #[test]
546    fn test_object() {
547        let jd = crate::object! {
548            "sdsd":"dffdf",
549            "dfdf":[1,2,3,4],
550            "dfdg":null,
551            "tf":1,
552            "fs":false,
553            "sf":1.23234,
554            "dffdfdf":{
555                "1":1,
556                "2":2,
557                "3":3,
558            }
559        };
560        let strs = serde_json::to_string_pretty(&jd).unwrap();
561        println!("{}", strs);
562        let v:JsonValue = serde_json::from_str(&strs).unwrap();
563        println!("{}",v.pretty())
564    }
565}
reqrio_json/json_impl.rs

reqrio_json/
json_impl.rs
