1use indexmap::IndexMap;
2use serde::de::{self, Visitor, DeserializeSeed, MapAccess, SeqAccess};
3use crate::error::{Error, Result};
4
5#[derive(Debug, Clone, PartialEq)]
6pub enum Value {
7 Str(String),
8 Obj(IndexMap<String, Vec<Value>>),
9}
10
11impl Value {
12 pub fn as_str(&self) -> Option<&str> {
13 match self {
14 Value::Str(s) => Some(s),
15 _ => None,
16 }
17 }
18}
19
20pub struct Deserializer<'de> {
21 input: &'de str,
22 cursor: usize,
23 line: usize,
24 column: usize,
25}
26
27impl<'de> Deserializer<'de> {
28 pub fn from_str(input: &'de str) -> Self {
29 Deserializer {
30 input,
31 cursor: 0,
32 line: 1,
33 column: 1,
34 }
35 }
36
37 fn peek_char(&self) -> Option<char> {
38 self.input[self.cursor..].chars().next()
39 }
40
41 fn next_char(&mut self) -> Option<char> {
42 let c = self.peek_char()?;
43 self.cursor += c.len_utf8();
44
45 if c == '\n' {
46 self.line += 1;
47 self.column = 1;
48 } else {
49 self.column += 1;
50 }
51
52 Some(c)
53 }
54
55 fn skip_whitespace(&mut self) {
56 while let Some(c) = self.peek_char() {
57 if c.is_whitespace() {
58 self.next_char();
59 } else if c == '/' {
60 if self.input[self.cursor..].starts_with("//") {
61 while let Some(nc) = self.next_char() {
62 if nc == '\n' {
63 break;
64 }
65 }
66 } else {
67 break;
68 }
69 } else {
70 break;
71 }
72 }
73 }
74
75 fn parse_string(&mut self) -> Result<String> {
76 self.skip_whitespace();
77 match self.peek_char() {
78 Some('"') => {
79 self.next_char();
80 let mut s = String::with_capacity(32);
81 let mut escaped = false;
82
83 while let Some(c) = self.next_char() {
84 if escaped {
85 s.push('\\');
86 s.push(c);
87 escaped = false;
88 } else if c == '\\' {
89 escaped = true;
90 } else if c == '"' {
91 return Ok(s);
92 } else {
93 s.push(c);
94 }
95 }
96 Err(self.error("Unexpected end of file while parsing quoted string"))
97 }
98 Some(c) if !c.is_whitespace() && c != '{' && c != '}' => {
99 let start = self.cursor;
101
102 while let Some(ch) = self.peek_char() {
103 if ch.is_whitespace() || ch == '{' || ch == '}' || ch == '"' {
104 break;
105 }
106 self.next_char();
107 }
108 let end = self.cursor;
109 Ok(self.input[start..end].to_string())
110 }
111 Some(c) => Err(self.error(&format!("Unexpected character: '{}'", c))),
112 None => Err(Error::Eof),
113 }
114 }
115
116 pub fn parse_value(&mut self) -> Result<Value> {
117 self.skip_whitespace();
118 match self.peek_char() {
119 Some('{') => {
120 self.next_char();
121 let obj = self.parse_map_content()?;
122 Ok(Value::Obj(obj))
123 }
124 _ => {
125 let s = self.parse_string()?;
126 Ok(Value::Str(s))
127 }
128 }
129 }
130
131 pub fn parse_map_content(&mut self) -> Result<IndexMap<String, Vec<Value>>> {
132 let mut map = IndexMap::new();
133 loop {
134 self.skip_whitespace();
135 match self.peek_char() {
136 Some('}') => {
137 self.next_char();
138 return Ok(map);
139 }
140 None => {
141 return Err(self.error("Expected '}', found EOF"));
142 }
143 _ => {
144 let key = self.parse_string()?.to_lowercase();
145 let value = self.parse_value()?;
146 map.entry(key).or_insert_with(Vec::new).push(value);
147 }
148 }
149 }
150 }
151
152 pub fn parse_root(&mut self) -> Result<Value> {
153 let mut map = IndexMap::new();
154 loop {
155 self.skip_whitespace();
156 if self.peek_char().is_none() {
157 break;
158 }
159 let key = match self.parse_string() {
160 Ok(k) => k,
161 Err(Error::Eof) => break,
162 Err(e) => return Err(e),
163 };
164 let value = self.parse_value()?;
165 map.entry(key).or_insert_with(Vec::new).push(value);
166 }
167 Ok(Value::Obj(map))
168 }
169
170 fn error(&self, msg: &str) -> Error {
171 Error::Syntax {
172 line: self.line,
173 column: self.column,
174 msg: msg.to_string(),
175 }
176 }
177}
178
179pub fn from_str<'a, T>(s: &'a str) -> Result<T>
180where
181 T: de::DeserializeOwned,
182{
183 let mut deserializer = Deserializer::from_str(s);
184 let root_value = deserializer.parse_root()?;
185 let mut value_deserializer = ValueDeserializer { value: root_value };
186 T::deserialize(&mut value_deserializer)
187}
188
189struct ValueDeserializer {
190 value: Value,
191}
192
193impl<'a, 'de> de::Deserializer<'de> for &'a mut ValueDeserializer {
194 type Error = Error;
195
196 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
197 where
198 V: Visitor<'de>,
199 {
200 match &self.value {
201 Value::Str(s) => visitor.visit_str(s),
202 Value::Obj(_) => visitor.visit_map(ValueMapAccess::new(&self.value)),
203 }
204 }
205
206 fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
207 where
208 V: Visitor<'de>,
209 {
210 match &self.value {
211 Value::Str(s) => visitor.visit_str(s),
212 _ => Err(Error::ExpectedString),
213 }
214 }
215
216 fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
217 where
218 V: Visitor<'de>,
219 {
220 self.deserialize_str(visitor)
221 }
222
223 fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
224 where
225 V: Visitor<'de>,
226 {
227 match &self.value {
228 Value::Str(s) => {
229 if s == "1" { visitor.visit_bool(true) }
230 else if s == "0" { visitor.visit_bool(false) }
231 else {
232 match s.parse::<bool>() {
233 Ok(b) => visitor.visit_bool(b),
234 Err(_) => Err(Error::Message(format!("Invalid bool: {}", s))),
235 }
236 }
237 },
238 _ => Err(Error::ExpectedString),
239 }
240 }
241
242 fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> {
243 match &self.value {
244 Value::Str(s) => visitor.visit_i32(s.parse().map_err(Error::IntParse)?),
245 _ => Err(Error::ExpectedString),
246 }
247 }
248 fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> {
249 match &self.value { Value::Str(s) => visitor.visit_i8(s.parse().map_err(Error::IntParse)?), _ => Err(Error::ExpectedString) }
250 }
251 fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> {
252 match &self.value { Value::Str(s) => visitor.visit_i16(s.parse().map_err(Error::IntParse)?), _ => Err(Error::ExpectedString) }
253 }
254 fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> {
255 match &self.value { Value::Str(s) => visitor.visit_i64(s.parse().map_err(Error::IntParse)?), _ => Err(Error::ExpectedString) }
256 }
257 fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> {
258 match &self.value { Value::Str(s) => visitor.visit_u8(s.parse().map_err(Error::IntParse)?), _ => Err(Error::ExpectedString) }
259 }
260 fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> {
261 match &self.value { Value::Str(s) => visitor.visit_u16(s.parse().map_err(Error::IntParse)?), _ => Err(Error::ExpectedString) }
262 }
263 fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> {
264 match &self.value { Value::Str(s) => visitor.visit_u32(s.parse().map_err(Error::IntParse)?), _ => Err(Error::ExpectedString) }
265 }
266 fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> {
267 match &self.value { Value::Str(s) => visitor.visit_u64(s.parse().map_err(Error::IntParse)?), _ => Err(Error::ExpectedString) }
268 }
269 fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> {
270 match &self.value { Value::Str(s) => visitor.visit_f32(s.parse().map_err(Error::FloatParse)?), _ => Err(Error::ExpectedString) }
271 }
272 fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> {
273 match &self.value { Value::Str(s) => visitor.visit_f64(s.parse().map_err(Error::FloatParse)?), _ => Err(Error::ExpectedString) }
274 }
275
276 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
277 where
278 V: Visitor<'de>,
279 {
280 visitor.visit_some(self)
281 }
282
283 fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
284 where
285 V: Visitor<'de>,
286 {
287 visitor.visit_unit()
288 }
289
290 fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
291 where
292 V: Visitor<'de>,
293 {
294 visitor.visit_newtype_struct(self)
295 }
296
297 fn deserialize_seq<V>(self, _visitor: V) -> Result<V::Value>
298 where
299 V: Visitor<'de>,
300 {
301 Err(Error::Message("deserialize_seq called on single Value".into()))
302 }
303
304 fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
305 where
306 V: Visitor<'de>,
307 {
308 match &self.value {
309 Value::Obj(_) => visitor.visit_map(ValueMapAccess::new(&self.value)),
310 _ => Err(Error::ExpectedObjectStart),
311 }
312 }
313
314 fn deserialize_struct<V>(
315 self,
316 _name: &'static str,
317 _fields: &'static [&'static str],
318 visitor: V,
319 ) -> Result<V::Value>
320 where
321 V: Visitor<'de>,
322 {
323 self.deserialize_map(visitor)
324 }
325
326 fn deserialize_enum<V>(
327 self,
328 _name: &'static str,
329 _variants: &'static [&'static str],
330 _visitor: V,
331 ) -> Result<V::Value>
332 where
333 V: Visitor<'de>,
334 {
335 Err(Error::Message("Enum deserialization not supported".into()))
336 }
337
338 fn deserialize_bytes<V>(self, _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::Message("Bytes not supported".into())) }
339 fn deserialize_byte_buf<V>(self, _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::Message("Bytes not supported".into())) }
340 fn deserialize_char<V>(self, _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::Message("Char not supported".into())) }
341 fn deserialize_unit_struct<V>(self, _name: &'static str, _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::Message("Unit struct not supported".into())) }
342 fn deserialize_tuple<V>(self, _len: usize, _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::Message("Tuple not supported".into())) }
343 fn deserialize_tuple_struct<V>(self, _name: &'static str, _len: usize, _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::Message("Tuple struct not supported".into())) }
344 fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> { self.deserialize_str(visitor) }
345 fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> { self.deserialize_any(visitor) }
346}
347
348
349struct ValueMapAccess<'a> {
350 iter: indexmap::map::Iter<'a, String, Vec<Value>>,
351 next_value: Option<&'a Vec<Value>>,
352}
353
354impl<'a> ValueMapAccess<'a> {
355 fn new(value: &'a Value) -> Self {
356 match value {
357 Value::Obj(map) => ValueMapAccess {
358 iter: map.iter(),
359 next_value: None,
360 },
361 _ => panic!("ValueMapAccess created for non-Obj"),
362 }
363 }
364}
365
366impl<'a, 'de> MapAccess<'de> for ValueMapAccess<'a> {
367 type Error = Error;
368
369 fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
370 where
371 K: DeserializeSeed<'de>,
372 {
373 match self.iter.next() {
374 Some((key, value)) => {
375 self.next_value = Some(value);
376 let mut key_deserializer = KeyDeserializer { key };
377 seed.deserialize(&mut key_deserializer).map(Some)
378 }
379 None => Ok(None),
380 }
381 }
382
383 fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
384 where
385 V: DeserializeSeed<'de>,
386 {
387 match self.next_value.take() {
388 Some(vec) => {
389 let mut deserializer = VecValueDeserializer { vec };
390 seed.deserialize(&mut deserializer)
391 }
392 None => Err(Error::Message("next_value called before next_key".into())),
393 }
394 }
395}
396
397struct KeyDeserializer<'a> {
398 key: &'a str,
399}
400
401impl<'a, 'de> de::Deserializer<'de> for &'a mut KeyDeserializer<'a> {
402 type Error = Error;
403 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> { visitor.visit_str(self.key) }
404 fn deserialize_str<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> { visitor.visit_str(self.key) }
405 fn deserialize_string<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> { visitor.visit_str(self.key) }
406 fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> { visitor.visit_str(self.key) }
407 fn deserialize_bool<V>(self, _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::ExpectedKey) }
408 fn deserialize_i8<V>(self, _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::ExpectedKey) }
409 fn deserialize_i16<V>(self, _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::ExpectedKey) }
410 fn deserialize_i32<V>(self, _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::ExpectedKey) }
411 fn deserialize_i64<V>(self, _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::ExpectedKey) }
412 fn deserialize_u8<V>(self, _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::ExpectedKey) }
413 fn deserialize_u16<V>(self, _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::ExpectedKey) }
414 fn deserialize_u32<V>(self, _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::ExpectedKey) }
415 fn deserialize_u64<V>(self, _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::ExpectedKey) }
416 fn deserialize_f32<V>(self, _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::ExpectedKey) }
417 fn deserialize_f64<V>(self, _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::ExpectedKey) }
418 fn deserialize_char<V>(self, _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::ExpectedKey) }
419 fn deserialize_bytes<V>(self, _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::ExpectedKey) }
420 fn deserialize_byte_buf<V>(self, _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::ExpectedKey) }
421 fn deserialize_option<V>(self, _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::ExpectedKey) }
422 fn deserialize_unit<V>(self, _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::ExpectedKey) }
423 fn deserialize_unit_struct<V>(self, _name: &'static str, _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::ExpectedKey) }
424 fn deserialize_newtype_struct<V>(self, _name: &'static str, _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::ExpectedKey) }
425 fn deserialize_seq<V>(self, _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::ExpectedKey) }
426 fn deserialize_tuple<V>(self, _len: usize, _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::ExpectedKey) }
427 fn deserialize_tuple_struct<V>(self, _name: &'static str, _len: usize, _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::ExpectedKey) }
428 fn deserialize_map<V>(self, _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::ExpectedKey) }
429 fn deserialize_struct<V>(self, _name: &'static str, _fields: &'static [&'static str], _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::ExpectedKey) }
430 fn deserialize_enum<V>(self, _name: &'static str, _variants: &'static [&'static str], _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::ExpectedKey) }
431 fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> { self.deserialize_any(visitor) }
432}
433
434struct VecValueDeserializer<'a> {
435 vec: &'a Vec<Value>,
436}
437
438impl<'a, 'de> de::Deserializer<'de> for &'a mut VecValueDeserializer<'a> {
439 type Error = Error;
440
441 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
442 where
443 V: Visitor<'de>,
444 {
445 if self.vec.len() == 1 {
446 let mut de = ValueDeserializer { value: self.vec[0].clone() };
447 de.deserialize_any(visitor)
448 } else {
449 self.deserialize_seq(visitor)
450 }
451 }
452
453 fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
454 where
455 V: Visitor<'de>,
456 {
457 visitor.visit_seq(ValueSeqAccess { iter: self.vec.iter() })
458 }
459
460 fn deserialize_str<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> {
461 if self.vec.len() == 1 {
462 let mut de = ValueDeserializer { value: self.vec[0].clone() };
463 de.deserialize_str(visitor)
464 } else {
465 Err(Error::Message("Expected single string, found sequence".into()))
466 }
467 }
468
469 fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> {
470 if self.vec.len() == 1 { let mut de = ValueDeserializer { value: self.vec[0].clone() }; de.deserialize_bool(visitor) } else { Err(Error::Message("Expected scalar".into())) }
471 }
472 fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> {
473 if self.vec.len() == 1 { let mut de = ValueDeserializer { value: self.vec[0].clone() }; de.deserialize_i32(visitor) } else { Err(Error::Message("Expected scalar".into())) }
474 }
475 fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> {
476 if self.vec.len() == 1 { let mut de = ValueDeserializer { value: self.vec[0].clone() }; de.deserialize_f32(visitor) } else { Err(Error::Message("Expected scalar".into())) }
477 }
478
479 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> {
480 if self.vec.is_empty() {
481 visitor.visit_none()
482 } else if self.vec.len() == 1 {
483 visitor.visit_some(self)
484 } else {
485 visitor.visit_some(self)
486 }
487 }
488
489 fn deserialize_struct<V>(self, name: &'static str, fields: &'static [&'static str], visitor: V) -> Result<V::Value> where V: Visitor<'de> {
490 if self.vec.len() == 1 {
491 let mut de = ValueDeserializer { value: self.vec[0].clone() };
492 de.deserialize_struct(name, fields, visitor)
493 } else {
494 Err(Error::Message("Expected struct, found sequence".into()))
495 }
496 }
497
498 fn deserialize_map<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> {
499 if self.vec.len() == 1 {
500 let mut de = ValueDeserializer { value: self.vec[0].clone() };
501 de.deserialize_map(visitor)
502 } else {
503 Err(Error::Message("Expected map, found sequence".into()))
504 }
505 }
506
507 fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> { self.deserialize_i32(visitor) }
508 fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> { self.deserialize_i32(visitor) }
509 fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> { self.deserialize_i32(visitor) }
510 fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> { self.deserialize_i32(visitor) }
511 fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> { self.deserialize_i32(visitor) }
512 fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> { self.deserialize_i32(visitor) }
513 fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> { self.deserialize_i32(visitor) }
514 fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> { self.deserialize_f32(visitor) }
515 fn deserialize_string<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> { self.deserialize_str(visitor) }
516 fn deserialize_char<V>(self, _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::Message("Char not supported".into())) }
517 fn deserialize_bytes<V>(self, _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::Message("Bytes not supported".into())) }
518 fn deserialize_byte_buf<V>(self, _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::Message("Bytes not supported".into())) }
519 fn deserialize_unit<V>(self, _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::Message("Unit not supported".into())) }
520 fn deserialize_unit_struct<V>(self, _name: &'static str, _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::Message("Unit struct not supported".into())) }
521 fn deserialize_newtype_struct<V>(self, _name: &'static str, _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::Message("Newtype struct not supported".into())) }
522 fn deserialize_tuple<V>(self, _len: usize, _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::Message("Tuple not supported".into())) }
523 fn deserialize_tuple_struct<V>(self, _name: &'static str, _len: usize, _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::Message("Tuple struct not supported".into())) }
524 fn deserialize_enum<V>(self, _name: &'static str, _variants: &'static [&'static str], _visitor: V) -> Result<V::Value> where V: Visitor<'de> { Err(Error::Message("Enum not supported".into())) }
525 fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> { self.deserialize_str(visitor) }
526 fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> { self.deserialize_any(visitor) }
527
528}
529
530struct ValueSeqAccess<'a> {
531 iter: std::slice::Iter<'a, Value>,
532}
533
534impl<'a, 'de> SeqAccess<'de> for ValueSeqAccess<'a> {
535 type Error = Error;
536
537 fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
538 where
539 T: DeserializeSeed<'de>,
540 {
541 match self.iter.next() {
542 Some(value) => {
543 let mut deserializer = ValueDeserializer { value: value.clone() };
544 seed.deserialize(&mut deserializer).map(Some)
545 }
546 None => Ok(None),
547 }
548 }
549}