source_kv/
de.rs

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

source_kv/
de.rs
