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::{JsonResult, JsonValue, NULL};
9use crate::number::Number;
10use crate::parser::JsonParser;
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 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
111impl<'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_none(&self) -> bool {
124        match self {
125            JsonValue::Null => { true }
126            _ => { false }
127        }
128    }
129
130    pub fn is_string(&self) -> bool {
131        match *self {
132            JsonValue::String(_) => true,
133            _ => false,
134        }
135    }
136
137    pub fn is_number(&self) -> bool {
138        match *self {
139            JsonValue::Number(_) => true,
140            _ => false,
141        }
142    }
143
144    pub fn is_boolean(&self) -> bool {
145        match *self {
146            JsonValue::Boolean(_) => true,
147            _ => false
148        }
149    }
150
151    pub fn is_null(&self) -> bool {
152        match *self {
153            JsonValue::Null => true,
154            _ => false,
155        }
156    }
157
158    pub fn is_object(&self) -> bool {
159        match *self {
160            JsonValue::Object(_) => true,
161            _ => false,
162        }
163    }
164
165    pub fn is_array(&self) -> bool {
166        match *self {
167            JsonValue::Array(_) => true,
168            _ => false,
169        }
170    }
171
172    pub fn as_str(&self) -> JsonResult<&str> {
173        match *self {
174            JsonValue::String(ref value) => Ok(value),
175            _ => Err("parse str error!".into())
176        }
177    }
178
179    pub fn as_number(&self) -> JsonResult<Number> {
180        match self {
181            JsonValue::Number(value) => Ok(value.clone()),
182            JsonValue::String(s) => Ok(Number::F64(s.parse::<f64>()?)),
183            _ => Err("parse number error!".into())
184        }
185    }
186
187    pub fn as_f64(&self) -> JsonResult<f64> {
188        self.as_number()?.as_f64()
189    }
190
191    pub fn as_f32(&self) -> JsonResult<f32> {
192        self.as_number()?.as_f32()
193    }
194
195    pub fn as_u64(&self) -> JsonResult<u64> {
196        self.as_number()?.as_u64()
197    }
198
199    pub fn as_u32(&self) -> JsonResult<u32> {
200        self.as_number()?.as_u32()
201    }
202
203    pub fn as_u16(&self) -> JsonResult<u16> {
204        self.as_number()?.as_u16()
205    }
206
207    pub fn as_u8(&self) -> JsonResult<u8> {
208        self.as_number()?.as_u8()
209    }
210
211    pub fn as_usize(&self) -> JsonResult<usize> {
212        self.as_number()?.as_usize()
213    }
214
215    pub fn as_i64(&self) -> JsonResult<i64> {
216        self.as_number()?.as_i64()
217    }
218
219    pub fn as_i32(&self) -> JsonResult<i32> {
220        self.as_number()?.as_i32()
221    }
222
223    pub fn as_i16(&self) -> JsonResult<i16> {
224        self.as_number()?.as_i16()
225    }
226
227    pub fn as_i8(&self) -> JsonResult<i8> {
228        self.as_number()?.as_i8()
229    }
230
231    pub fn as_isize(&self) -> JsonResult<isize> {
232        self.as_number()?.as_isize()
233    }
234
235    pub fn as_bool(&self) -> JsonResult<bool> {
236        match *self {
237            JsonValue::Boolean(ref value) => Ok(value.clone()),
238            _ => Err("parse bool error!".into())
239        }
240    }
241}
242
243impl From<String> for JsonValue {
244    fn from(value: String) -> Self {
245        JsonValue::String(value)
246    }
247}
248
249impl<'a> From<&'a str> for JsonValue {
250    fn from(value: &'a str) -> Self {
251        JsonValue::String(value.to_string())
252    }
253}
254
255impl<'a> From<&'a String> for JsonValue {
256    fn from(value: &'a String) -> Self {
257        JsonValue::String(value.to_string())
258    }
259}
260
261impl From<i8> for JsonValue {
262    fn from(value: i8) -> Self {
263        JsonValue::Number(Number::I64(value as i64))
264    }
265}
266
267impl From<&i8> for JsonValue {
268    fn from(value: &i8) -> Self {
269        JsonValue::Number(Number::I64(*value as i64))
270    }
271}
272
273impl From<i16> for JsonValue {
274    fn from(value: i16) -> Self {
275        JsonValue::Number(Number::I64(value as i64))
276    }
277}
278
279impl From<&i16> for JsonValue {
280    fn from(value: &i16) -> Self {
281        JsonValue::Number(Number::I64(*value as i64))
282    }
283}
284
285impl From<i32> for JsonValue {
286    fn from(value: i32) -> Self {
287        JsonValue::Number(Number::I64(value as i64))
288    }
289}
290
291impl From<&i32> for JsonValue {
292    fn from(value: &i32) -> Self {
293        JsonValue::Number(Number::I64(*value as i64))
294    }
295}
296
297impl From<i64> for JsonValue {
298    fn from(value: i64) -> Self {
299        JsonValue::Number(Number::I64(value))
300    }
301}
302
303impl From<&i64> for JsonValue {
304    fn from(value: &i64) -> Self {
305        JsonValue::Number(Number::I64(*value))
306    }
307}
308
309impl From<u8> for JsonValue {
310    fn from(value: u8) -> Self {
311        JsonValue::Number(Number::U64(value as u64))
312    }
313}
314
315impl From<u16> for JsonValue {
316    fn from(value: u16) -> Self {
317        JsonValue::Number(Number::U64(value as u64))
318    }
319}
320
321impl From<u32> for JsonValue {
322    fn from(value: u32) -> Self {
323        JsonValue::Number(Number::U64(value as u64))
324    }
325}
326
327impl From<u64> for JsonValue {
328    fn from(value: u64) -> Self {
329        JsonValue::Number(Number::U64(value))
330    }
331}
332
333impl From<u128> for JsonValue {
334    fn from(value: u128) -> Self {
335        JsonValue::Number(Number::U64(value as u64))
336    }
337}
338
339impl From<f32> for JsonValue {
340    fn from(value: f32) -> Self {
341        JsonValue::Number(Number::F64(value as f64))
342    }
343}
344
345impl From<&f32> for JsonValue {
346    fn from(value: &f32) -> Self {
347        JsonValue::Number(Number::F64(*value as f64))
348    }
349}
350
351impl From<f64> for JsonValue {
352    fn from(value: f64) -> Self {
353        JsonValue::Number(Number::F64(value))
354    }
355}
356
357impl From<&f64> for JsonValue {
358    fn from(value: &f64) -> Self {
359        JsonValue::Number(Number::F64(*value))
360    }
361}
362
363impl From<usize> for JsonValue {
364    fn from(value: usize) -> Self {
365        JsonValue::Number(Number::I64(value as i64))
366    }
367}
368
369impl From<bool> for JsonValue {
370    fn from(value: bool) -> Self {
371        JsonValue::Boolean(value)
372    }
373}
374
375impl From<&bool> for JsonValue {
376    fn from(value: &bool) -> Self {
377        JsonValue::Boolean(*value)
378    }
379}
380
381impl<T> From<Vec<T>> for JsonValue
382where
383    T: Into<JsonValue>,
384{
385    fn from(value: Vec<T>) -> Self {
386        let mut array = JsonValue::new_array();
387        for v in value {
388            array.push(v.into());
389        }
390        array
391    }
392}
393
394
395impl<'a, T> From<HashMap<&'a str, T>> for JsonValue
396where
397    T: Into<JsonValue>,
398{
399    fn from(value: HashMap<&'a str, T>) -> Self {
400        let mut object = JsonValue::new_object();
401        for (k, v) in value {
402            object.insert(k, v.into()).unwrap();
403        }
404        object
405    }
406}
407
408impl<T> From<HashMap<String, T>> for JsonValue
409where
410    T: Into<JsonValue>,
411{
412    fn from(value: HashMap<String, T>) -> Self {
413        let mut object = JsonValue::new_object();
414        for (k, v) in value {
415            object.insert(k.as_str(), v.into()).unwrap();
416        }
417        object
418    }
419}
420
421impl<'a, T: Clone> From<&'a [T]> for JsonValue
422where
423    T: Into<JsonValue>,
424{
425    fn from(value: &'a [T]) -> Self {
426        let mut array = JsonValue::new_array();
427        for v in value {
428            array.push(v.clone().into())
429        };
430        array
431    }
432}
433
434impl<T> From<Option<T>> for JsonValue
435where
436    T: Into<JsonValue>,
437{
438    fn from(value: Option<T>) -> Self {
439        match value {
440            None => { JsonValue::Null }
441            Some(v) => { v.into() }
442        }
443    }
444}
445
446impl Into<Box<dyn Error>> for JsonValue {
447    fn into(self) -> Box<dyn Error> {
448        Box::from(self.to_string())
449    }
450}
451
452
453impl Into<mh_json::JsonValue> for JsonValue {
454    fn into(self) -> mh_json::JsonValue {
455        match self {
456            JsonValue::Null => mh_json::Null,
457            JsonValue::String(s) => mh_json::JsonValue::String(s),
458            JsonValue::Number(n) => {
459                match n {
460                    Number::U64(u) => { mh_json::JsonValue::Number(mh_json::number::Number::from(u)) }
461                    Number::I64(i) => { mh_json::JsonValue::Number(mh_json::number::Number::from(i)) }
462                    Number::F64(f) => { mh_json::JsonValue::Number(mh_json::number::Number::from(f)) }
463                }
464            }
465            JsonValue::Boolean(b) => mh_json::JsonValue::Boolean(b),
466            JsonValue::Object(o) => o.into(),
467            JsonValue::Array(a) => a.into()
468        }
469    }
470}
reqrio_json/json_impl.rs

reqrio_json/
json_impl.rs
