source_kv/
de.rs

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

source_kv/
de.rs
