messy_json 0.2.3

JSON Parser for dynamically structured documents
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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

use super::*;

// This code has been **heavily** inspired by the code written in the [serde](serde) crate

struct MessyJsonRawMapKeyDeserializer<'de> {
    key: Cow<'de, str>,
}

impl<'de> Deserializer<'de> for MessyJsonRawMapKeyDeserializer<'de> {
    type Error = serde::de::value::Error;

    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: Visitor<'de>,
    {
        match self.key {
            Cow::Owned(x) => visitor.visit_string(x),
            Cow::Borrowed(x) => visitor.visit_borrowed_str(x),
        }
    }

    serde::forward_to_deserialize_any! {
        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
        bytes byte_buf option unit unit_struct newtype_struct seq tuple
        tuple_struct map struct enum identifier ignored_any
    }
}

pub fn visit_object<'de, V>(
    object: BTreeMap<Cow<'de, str>, MessyJsonValueRaw<'de>>,
    visitor: V,
) -> Result<V::Value, serde::de::value::Error>
where
    V: Visitor<'de>,
{
    let len = object.len();
    let mut deserializer = MessyJsonRawMapDeserializer::new(object);
    let map = visitor.visit_map(&mut deserializer)?;
    let remaining = deserializer.iter.len();
    if remaining == 0 {
        Ok(map)
    } else {
        Err(serde::de::Error::invalid_length(
            len,
            &"fewer elements in map",
        ))
    }
}

pub struct MessyJsonRawMapDeserializer<'de> {
    iter: <BTreeMap<Cow<'de, str>, MessyJsonValueRaw<'de>> as IntoIterator>::IntoIter,
    value: Option<MessyJsonValueRaw<'de>>,
}

impl<'de> MessyJsonRawMapDeserializer<'de> {
    pub fn new(map: BTreeMap<Cow<'de, str>, MessyJsonValueRaw<'de>>) -> Self {
        MessyJsonRawMapDeserializer {
            iter: map.into_iter(),
            value: None,
        }
    }
}

impl<'de> MapAccess<'de> for MessyJsonRawMapDeserializer<'de> {
    type Error = serde::de::value::Error;

    fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
    where
        T: DeserializeSeed<'de>,
    {
        match self.iter.next() {
            Some((key, value)) => {
                self.value = Some(value);
                let key_de = MessyJsonRawMapKeyDeserializer { key };
                seed.deserialize(key_de).map(Some)
            }
            None => Ok(None),
        }
    }

    fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
    where
        T: DeserializeSeed<'de>,
    {
        match self.value.take() {
            Some(value) => seed.deserialize(value),
            None => Err(serde::de::Error::custom("value is missing")),
        }
    }

    fn size_hint(&self) -> Option<usize> {
        match self.iter.size_hint() {
            (lower, Some(upper)) if lower == upper => Some(upper),
            _ => None,
        }
    }
}

impl<'de> serde::Deserializer<'de> for MessyJsonRawMapDeserializer<'de> {
    type Error = serde::de::value::Error;

    #[inline]
    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: Visitor<'de>,
    {
        visitor.visit_map(self)
    }

    serde::forward_to_deserialize_any! {
        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
        bytes byte_buf option unit unit_struct newtype_struct seq tuple
        tuple_struct map struct enum identifier ignored_any
    }
}