miniserde/json/
value.rs

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

miniserde/json/
value.rs
