messagepack-serde 0.2.4

messagepack for `no_std` with `serde`
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

use messagepack_core::io::IoRead;
use serde::de;

use super::{Deserializer, Error, error::CoreError};

pub struct Enum<'a, R> {
    de: &'a mut Deserializer<R>,
}

impl<'a, R> Enum<'a, R> {
    pub fn new(de: &'a mut Deserializer<R>) -> Self {
        Enum { de }
    }
}

impl<'de, 'a, R> de::EnumAccess<'de> for Enum<'a, R>
where
    'de: 'a,
    R: IoRead<'de>,
{
    type Error = Error<R::Error>;

    type Variant = Self;

    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
    where
        V: de::DeserializeSeed<'de>,
    {
        let val = seed.deserialize(self.de.as_mut())?;

        Ok((val, self))
    }
}

impl<'de, 'a, R> de::VariantAccess<'de> for Enum<'a, R>
where
    'de: 'a,
    R: IoRead<'de>,
{
    type Error = Error<R::Error>;

    fn unit_variant(self) -> Result<(), Self::Error> {
        // Unit variant should handle before
        Err(CoreError::UnexpectedFormat.into())
    }

    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
    where
        T: de::DeserializeSeed<'de>,
    {
        seed.deserialize(self.de.as_mut())
    }

    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: de::Visitor<'de>,
    {
        de::Deserializer::deserialize_seq(self.de, visitor)
    }

    fn struct_variant<V>(
        self,
        _fields: &'static [&'static str],
        visitor: V,
    ) -> Result<V::Value, Self::Error>
    where
        V: de::Visitor<'de>,
    {
        de::Deserializer::deserialize_map(self.de, visitor)
    }
}