1use crate::prelude::*;
2use serde::de::{self, Deserialize, Visitor};
3use serde::Deserializer;
4use std::collections::HashMap;
5use std::fmt;
6
7impl<'de> Deserialize<'de> for Value {
8 fn deserialize<D>(deserializer: D) -> Result<Value, D::Error>
9 where
10 D: Deserializer<'de>,
11 {
12 struct ValueVisitor;
13
14 impl<'de> Visitor<'de> for ValueVisitor {
15 type Value = Value;
16
17 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
18 formatter.write_str("any valid value")
19 }
20
21 fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E>
22 where
23 E: de::Error,
24 {
25 Ok(Number::from(v).to_value())
26 }
27
28 fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
29 where
30 E: de::Error,
31 {
32 Ok(Number::from(v).to_value())
33 }
34
35 fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
36 where
37 E: de::Error,
38 {
39 Ok(Number::from(v).to_value())
40 }
41
42 fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
43 where
44 E: de::Error,
45 {
46 Ok(Number::from(v).to_value())
47 }
48
49 fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
50 where
51 E: de::Error,
52 {
53 Ok(Number::from(v).to_value())
54 }
55
56 fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
57 where
58 E: de::Error,
59 {
60 Ok(Number::from(v).to_value())
61 }
62
63 fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
64 where
65 E: de::Error,
66 {
67 Ok(Number::from(v).to_value())
68 }
69
70 fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
71 where
72 E: de::Error,
73 {
74 Ok(Number::from(v).to_value())
75 }
76
77 fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E>
78 where
79 E: de::Error,
80 {
81 Ok(Number::from(v).to_value())
82 }
83
84 fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
85 where
86 E: de::Error,
87 {
88 Ok(Number::from(v).to_value())
89 }
90
91 fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
92 where
93 E: de::Error,
94 {
95 Ok(Number::from(v).to_value())
96 }
97
98 fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
99 where
100 E: de::Error,
101 {
102 Ok(Number::from(v).to_value())
103 }
104
105 fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
106 where
107 E: de::Error,
108 {
109 Ok(Value::Boolean(v))
110 }
111
112 fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
113 where
114 E: de::Error,
115 {
116 Ok(StringB::from(v).to_value())
117 }
118
119 fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
120 where
121 E: de::Error,
122 {
123 Ok(StringB::from(v).to_value())
124 }
125
126 fn visit_map<A>(self, mut access: A) -> Result<Self::Value, A::Error>
127 where
128 A: de::MapAccess<'de>,
129 {
130 let mut map: HashMap<String, Value> = HashMap::default();
131
132 while let Some((key, value)) = access.next_entry()? {
133 map.insert(key, value);
134 }
135
136 Ok(Object::from(map).to_value())
137 }
138
139 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
140 where
141 A: de::SeqAccess<'de>,
142 {
143 let mut vec: Vec<Value> = Vec::new();
144 while let Some(value) = seq.next_element()? {
146 vec.push(value);
147 }
148
149 Ok(Array::from(vec).to_value())
150 }
151
152 fn visit_none<E>(self) -> Result<Self::Value, E>
153 where
154 E: de::Error,
155 {
156 Ok(Value::Null)
157 }
158
159 fn visit_unit<E>(self) -> Result<Self::Value, E>
160 where
161 E: de::Error,
162 {
163 Ok(Value::Null)
164 }
165
166 fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
167 where
168 D: Deserializer<'de>,
169 {
170 Deserialize::deserialize(deserializer)
171 }
172
173 fn visit_char<E>(self, v: char) -> Result<Self::Value, E>
174 where
175 E: de::Error,
176 {
177 self.visit_str(v.encode_utf8(&mut [0u8; 4]))
178 }
179
180 fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
181 where
182 E: de::Error,
183 {
184 self.visit_str(v)
185 }
186
187 fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
188 where
189 E: de::Error,
190 {
191 Err(de::Error::invalid_type(de::Unexpected::Bytes(v), &self))
192 }
193
194 fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E>
195 where
196 E: de::Error,
197 {
198 self.visit_bytes(v)
199 }
200
201 fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
202 where
203 E: de::Error,
204 {
205 self.visit_bytes(&v)
206 }
207
208 fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
209 where
210 D: Deserializer<'de>,
211 {
212 let _ = deserializer;
213 Err(de::Error::invalid_type(de::Unexpected::Option, &self))
214 }
215
216 fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
217 where
218 A: de::EnumAccess<'de>,
219 {
220 let _ = data;
221 Err(de::Error::invalid_type(de::Unexpected::Enum, &self))
222 }
223
224 }
225
226 deserializer.deserialize_any(ValueVisitor)
227 }
228
229 fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
230 where
231 D: Deserializer<'de>,
232 {
233 *place = Deserialize::deserialize(deserializer)?;
234 Ok(())
235 }
236}