compris 0.0.11

Composite Primitive Schema (CPS) for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

use super::{
    super::{super::normal::*, errors::*},
    deserializer::*,
};

use {serde::de, std::slice::*};

//
// MapAsListDeserializer
//

pub(crate) struct MapAsListDeserializer<'de, AnnotatedT> {
    iterator: Iter<'de, Variant<AnnotatedT>>,
    current_entry: Option<(&'de Variant<AnnotatedT>, &'de Variant<AnnotatedT>)>,
}

impl<'de, AnnotatedT> MapAsListDeserializer<'de, AnnotatedT> {
    pub(crate) fn new(list: &'de List<AnnotatedT>) -> Self {
        Self { iterator: list.inner.iter(), current_entry: None }
    }

    fn next(&mut self) -> Result<(), DeserializeError> {
        let current_entry = self.iterator.next();

        match current_entry {
            Some(current_entry) => {
                self.current_entry = current_entry.to_pair();
                if self.current_entry.is_none() {
                    return Err(DeserializeError::incompatible_variant(current_entry));
                }
            }

            None => {
                self.current_entry = None;
            }
        }

        Ok(())
    }
}

impl<'de, AnnotatedT> de::MapAccess<'de> for MapAsListDeserializer<'de, AnnotatedT> {
    type Error = DeserializeError;

    fn next_key_seed<SeedT>(&mut self, seed: SeedT) -> Result<Option<SeedT::Value>, Self::Error>
    where
        SeedT: de::DeserializeSeed<'de>,
    {
        self.next()?;
        match self.current_entry {
            Some((key, _)) => Ok(Some(seed.deserialize(&mut Deserializer::new(key))?)),
            None => Ok(None),
        }
    }

    fn next_value_seed<SeedT>(&mut self, seed: SeedT) -> Result<SeedT::Value, Self::Error>
    where
        SeedT: de::DeserializeSeed<'de>,
    {
        match self.current_entry {
            Some((_, value)) => Ok(seed.deserialize(&mut Deserializer::new(value))?),
            None => Err(DeserializeError::NoMoreItems), // this shouldn't happen, but still
        }
    }
}