decoder 0.0.3

A decoder library for your types
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

mod map;

pub use map::Map;

use crate::Error;
pub(crate) use decoder_value::Value as Raw;

use serde::Serialize;
use serde::de;
use serde::ser;

/// A generic value.
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Value(pub(crate) Raw);

pub(crate) fn to_value(data: impl Serialize) -> Result<Value, Error> {
    decoder_value::to_value(data)
        .map(Value)
        .map_err(Error::deserializer)
}

impl From<Raw> for Value {
    fn from(value: Raw) -> Self {
        Self(value)
    }
}

impl From<Map> for Value {
    fn from(map: Map) -> Self {
        Self(Raw::Map(map.raw))
    }
}

impl<'de> de::Deserialize<'de> for Value {
    fn deserialize<D: de::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
        Raw::deserialize(d).map(Self)
    }
}

impl de::IntoDeserializer<'_, decoder_value::DeserializerError> for Value {
    type Deserializer = Raw;

    fn into_deserializer(self) -> Raw {
        self.0
    }
}

impl ser::Serialize for Value {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: ser::Serializer,
    {
        self.0.serialize(serializer)
    }
}