miniserde_miku/json/
value.rs

1use crate::de::{Deserialize, Map, Seq, Visitor};
2use crate::error::Result;
3use crate::json::{Array, Number, Object};
4use crate::private;
5use crate::ser::{Fragment, Serialize};
6use crate::Place;
7use alloc::borrow::{Cow, ToOwned};
8use alloc::boxed::Box;
9use alloc::string::String;
10use core::mem;
11use core::str;
12
13/// Any valid JSON value.
14///
15/// This type has a non-recursive drop implementation so it is safe to build
16/// arbitrarily deeply nested instances.
17///
18/// ```rust
19/// use miniserde::json::{Array, Value};
20///
21/// let mut value = Value::Null;
22#[cfg_attr(not(miri), doc = "for _ in 0..100000 {")]
23#[cfg_attr(miri, doc = "for _ in 0..40 {")]
24///     let mut array = Array::new();
25///     array.push(value);
26///     value = Value::Array(array);
27/// }
28/// // no stack overflow when `value` goes out of scope
29/// ```
30#[derive(Clone, Debug)]
31pub enum Value {
32    Null,
33    Bool(bool),
34    Number(Number),
35    String(String),
36    Array(Array),
37    Object(Object),
38}
39
40impl Default for Value {
41    /// The default value is null.
42    fn default() -> Self {
43        Value::Null
44    }
45}
46
47impl Serialize for Value {
48    fn begin(&self) -> Fragment {
49        match self {
50            Value::Null => Fragment::Null,
51            Value::Bool(b) => Fragment::Bool(*b),
52            Value::Number(Number::U64(n)) => Fragment::U64(*n),
53            Value::Number(Number::I64(n)) => Fragment::I64(*n),
54            Value::Number(Number::F64(n)) => Fragment::F64(*n),
55            Value::String(s) => Fragment::Str(Cow::Borrowed(s)),
56            Value::Array(array) => private::stream_slice(array),
57            Value::Object(object) => private::stream_object(object),
58        }
59    }
60}
61
62impl Deserialize for Value {
63    fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
64        impl Visitor for Place<Value> {
65            fn null(&mut self) -> Result<()> {
66                self.out = Some(Value::Null);
67                Ok(())
68            }
69
70            fn boolean(&mut self, b: bool) -> Result<()> {
71                self.out = Some(Value::Bool(b));
72                Ok(())
73            }
74
75            fn string(&mut self, s: &str) -> Result<()> {
76                self.out = Some(Value::String(s.to_owned()));
77                Ok(())
78            }
79
80            fn negative(&mut self, n: i64) -> Result<()> {
81                self.out = Some(Value::Number(Number::I64(n)));
82                Ok(())
83            }
84
85            fn nonnegative(&mut self, n: u64) -> Result<()> {
86                self.out = Some(Value::Number(Number::U64(n)));
87                Ok(())
88            }
89
90            fn float(&mut self, n: f64) -> Result<()> {
91                self.out = Some(Value::Number(Number::F64(n)));
92                Ok(())
93            }
94
95            fn seq(&mut self) -> Result<Box<dyn Seq + '_>> {
96                Ok(Box::new(ArrayBuilder {
97                    out: &mut self.out,
98                    array: Array::new(),
99                    element: None,
100                }))
101            }
102
103            fn map(&mut self) -> Result<Box<dyn Map + '_>> {
104                Ok(Box::new(ObjectBuilder {
105                    out: &mut self.out,
106                    object: Object::new(),
107                    key: None,
108                    value: None,
109                }))
110            }
111        }
112
113        struct ArrayBuilder<'a> {
114            out: &'a mut Option<Value>,
115            array: Array,
116            element: Option<Value>,
117        }
118
119        impl<'a> ArrayBuilder<'a> {
120            fn shift(&mut self) {
121                if let Some(e) = self.element.take() {
122                    self.array.push(e);
123                }
124            }
125        }
126
127        impl<'a> Seq for ArrayBuilder<'a> {
128            fn element(&mut self) -> Result<&mut dyn Visitor> {
129                self.shift();
130                Ok(Deserialize::begin(&mut self.element))
131            }
132
133            fn finish(&mut self) -> Result<()> {
134                self.shift();
135                *self.out = Some(Value::Array(mem::replace(&mut self.array, Array::new())));
136                Ok(())
137            }
138        }
139
140        struct ObjectBuilder<'a> {
141            out: &'a mut Option<Value>,
142            object: Object,
143            key: Option<String>,
144            value: Option<Value>,
145        }
146
147        impl<'a> ObjectBuilder<'a> {
148            fn shift(&mut self) {
149                if let (Some(k), Some(v)) = (self.key.take(), self.value.take()) {
150                    self.object.insert(k, v);
151                }
152            }
153        }
154
155        impl<'a> Map for ObjectBuilder<'a> {
156            fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
157                self.shift();
158                self.key = Some(k.to_owned());
159                Ok(Deserialize::begin(&mut self.value))
160            }
161
162            fn finish(&mut self) -> Result<()> {
163                self.shift();
164                *self.out = Some(Value::Object(mem::replace(&mut self.object, Object::new())));
165                Ok(())
166            }
167        }
168
169        Place::new(out)
170    }
171}
miniserde_miku/json/value.rs

miniserde_miku/json/
value.rs
