simple_serde 2.0.0

A wrapper around multiple serde libraries making it easy to encode and decode multiple 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
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
116
117
118
119
120
121
122
123
124
125

use super::super::Error;

#[cfg(not(tarpaulin_include))]
impl Eq for Error {}

#[cfg(not(tarpaulin_include))]
impl PartialEq for Error {
    fn eq(&self, other: &Self) -> bool {
        match self {
            Error::Infallible => match other {
                Error::Infallible => true,
                _ => false,
            },
            Error::ByteToUTF8ConversionFailure(e) => match other {
                Error::ByteToUTF8ConversionFailure(ee) => format!("{}", e) == format!("{}", ee),
                _ => false,
            },
            Error::UnknownContentTypeMatchFromStr(e) => match other {
                Error::UnknownContentTypeMatchFromStr(ee) => format!("{}", e) == format!("{}", ee),
                _ => false,
            },
            Error::BsonSerializationFailure(e) => match other {
                Error::BsonSerializationFailure(ee) => format!("{}", e) == format!("{}", ee),
                _ => false,
            },
            Error::BsonDeserializationFailure(e) => match other {
                Error::BsonDeserializationFailure(ee) => format!("{}", e) == format!("{}", ee),
                _ => false,
            },
            Error::CborFailure(e) => match other {
                Error::CborFailure(ee) => format!("{}", e) == format!("{}", ee),
                _ => false,
            },
            Error::FlexBuffersSerializationFailure(e) => match other {
                Error::FlexBuffersSerializationFailure(ee) => format!("{}", e) == format!("{}", ee),
                _ => false,
            },
            Error::FlexBuffersDeserializationFailure(e) => match other {
                Error::FlexBuffersDeserializationFailure(ee) => {
                    format!("{}", e) == format!("{}", ee)
                }
                _ => false,
            },
            Error::JsonError(e) => match other {
                Error::JsonError(ee) => format!("{}", e) == format!("{}", ee),
                _ => false,
            },
            Error::Json5Error(e) => match other {
                Error::Json5Error(ee) => format!("{}", e) == format!("{}", ee),
                _ => false,
            },
            Error::LexprError(e) => match other {
                Error::LexprError(ee) => format!("{}", e) == format!("{}", ee),
                _ => false,
            },
            Error::MessagePackEncodeError(e) => match other {
                Error::MessagePackEncodeError(ee) => format!("{}", e) == format!("{}", ee),
                _ => false,
            },
            Error::MessagePackDecodeError(e) => match other {
                Error::MessagePackDecodeError(ee) => format!("{}", e) == format!("{}", ee),
                _ => false,
            },
            Error::PickleError(e) => match other {
                Error::PickleError(ee) => format!("{}", e) == format!("{}", ee),
                _ => false,
            },
            Error::PostcardError(e) => match other {
                Error::PostcardError(ee) => format!("{}", e) == format!("{}", ee),
                _ => false,
            },
            Error::RonError(e) => match other {
                Error::RonError(ee) => format!("{}", e) == format!("{}", ee),
                _ => false,
            },
            Error::TomlSerializationFailure(e) => match other {
                Error::TomlSerializationFailure(ee) => format!("{}", e) == format!("{}", ee),
                _ => false,
            },
            Error::TomlDeserializationFailure(e) => match other {
                Error::TomlDeserializationFailure(ee) => format!("{}", e) == format!("{}", ee),
                _ => false,
            },
            Error::QueryStringEncodingFailure(e) => match other {
                Error::QueryStringEncodingFailure(ee) => format!("{:?}", e) == format!("{:?}", ee),
                _ => false,
            },
            Error::YamlError(e) => match other {
                Error::YamlError(ee) => format!("{}", e) == format!("{}", ee),
                _ => false,
            },
            #[cfg(feature = "accept-limited-xml-serialize")]
            Error::XmlError(e) => match other {
                Error::XmlError(ee) => format!("{:?}", e) == format!("{:?}", ee),
                _ => false,
            },
            Error::TypeDoesNotSupportSerialization(e) => match other {
                Error::TypeDoesNotSupportSerialization(ee) => {
                    format!("{:?}", e) == format!("{:?}", ee)
                }
                _ => false,
            },
            #[cfg(feature = "http")]
            Error::FailedConvertingHeaderValueToContentType(e) => match other {
                Error::FailedConvertingHeaderValueToContentType(ee) => {
                    format!("{}", e) == format!("{}", ee)
                }
                _ => false,
            },
            #[cfg(feature = "http")]
            Error::InvalidHeaderValue(e) => match other {
                Error::InvalidHeaderValue(ee) => format!("{}", e) == format!("{}", ee),
                _ => false,
            },
            Error::RonDecodeError(e) => match other {
                Error::RonDecodeError(ee) => format!("{}", e) == format!("{}", ee),
                _ => false,
            },
            Error::NoSerializersDeserializersSet => match other {
                Error::NoSerializersDeserializersSet => true,
                _ => false,
            },
        }
    }
}