serde-xdr 0.6.0

XDR serialization and deserialization for 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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

use {
    self::variant_deserializer::VariantDeserializer,
    super::{
        super::errors::{
            CompatDeserializationError, DeserializationError, Result,
        },
        Deserializer,
    },
    byteorder::ReadBytesExt,
    serde::de::{
        value::U32Deserializer, DeserializeSeed, EnumAccess, IntoDeserializer,
    },
};

pub struct EnumDeserializer<'a, 'r, R>
where
    'r: 'a,
    R: ReadBytesExt + 'r,
{
    enum_name: &'static str,
    variant: u32,
    variant_name: &'static str,
    deserializer: &'a mut Deserializer<'r, R>,
}

impl<'a, 'r, R> EnumDeserializer<'a, 'r, R>
where
    'r: 'a,
    R: ReadBytesExt + 'r,
{
    pub fn new(
        enum_name: &'static str,
        variant: u32,
        variant_name: &'static str,
        deserializer: &'a mut Deserializer<'r, R>,
    ) -> Self {
        EnumDeserializer {
            enum_name,
            variant,
            variant_name,
            deserializer,
        }
    }
}

impl<'a, 'de, 'r, R> EnumAccess<'de> for EnumDeserializer<'a, 'r, R>
where
    'r: 'a,
    R: ReadBytesExt + 'r,
{
    type Error = CompatDeserializationError;
    type Variant = VariantDeserializer<'a, 'r, R>;

    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
    where
        V: DeserializeSeed<'de>,
    {
        let variant_code_deserializer: U32Deserializer<Self::Error> =
            self.variant.into_deserializer();

        let value =
            seed.deserialize(variant_code_deserializer)
                .map_err(|error| {
                    deserialize_enum_error(
                        self.enum_name,
                        self.variant_name,
                        error,
                    )
                })?;

        let variant_deserializer = VariantDeserializer::new(
            self.enum_name,
            self.variant_name,
            self.deserializer,
        );

        Ok((value, variant_deserializer))
    }
}

fn deserialize_enum_error(
    enum_name: &str,
    variant_name: &str,
    cause: CompatDeserializationError,
) -> DeserializationError {
    DeserializationError::failure(
        format!("enum variant {}::{}", enum_name, variant_name),
        cause,
    )
}

mod variant_deserializer;

#[cfg(test)]
mod tests;