serde-libconfigasaurus 0.3.0

Serde serialization and deserialization for libconfig format
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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

//! Error types for libconfig serialization and deserialization

use std::fmt::{self, Display};

use serde::{de, ser};

/// A Result type alias where the error is `libconfig::Error`
pub type Result<T> = std::result::Result<T, Error>;

/// Errors that can occur when serializing or deserializing libconfig data
#[derive(Debug)]
pub enum Error {
    /// A custom error message from Serde
    Message(String),

    /// Unexpected end of input
    Eof,

    /// Syntax error in the input
    Syntax,

    /// Expected a boolean value
    ExpectedBoolean,

    /// Expected an integer value
    ExpectedInteger,

    /// Expected a float value
    ExpectedFloat,

    /// Expected a string value
    ExpectedString,

    /// Expected an array
    ExpectedArray,

    /// Expected a comma in an array
    ExpectedArrayComma,

    /// Expected end of array
    ExpectedArrayEnd,

    /// Expected a semicolon after array
    ExpectedArraySemicolon,

    /// Expected a list
    ExpectedList,

    /// Expected a comma in a list
    ExpectedListComma,

    /// Expected end of list
    ExpectedListEnd,

    /// Expected a group (struct)
    ExpectedGroup,

    /// Expected an equals sign or colon
    ExpectedEquals,

    /// Expected a semicolon
    ExpectedSemicolon,

    /// Expected a comma or semicolon
    ExpectedCommaOrSemicolon,

    /// Expected end of group
    ExpectedGroupEnd,

    /// Expected an identifier
    ExpectedIdentifier,

    /// Trailing characters after parsing
    TrailingCharacters,

    /// Heterogeneous arrays are not supported
    HeterogeneousArray,

    /// Invalid escape sequence
    InvalidEscape,

    /// Invalid number format
    InvalidNumber,

    /// Maps with non-string keys are not supported
    KeyMustBeAString,

    /// Unit type not supported at top level
    UnitNotSupported,

    /// Type not supported
    TypeNotSupported(String),
}

impl ser::Error for Error {
    fn custom<T: Display>(msg: T) -> Self {
        Error::Message(msg.to_string())
    }
}

impl de::Error for Error {
    fn custom<T: Display>(msg: T) -> Self {
        Error::Message(msg.to_string())
    }
}

impl Display for Error {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Error::Message(msg) => formatter.write_str(msg),
            Error::Eof => formatter.write_str("unexpected end of input"),
            Error::Syntax => formatter.write_str("syntax error"),
            Error::ExpectedBoolean => formatter.write_str("expected boolean"),
            Error::ExpectedInteger => formatter.write_str("expected integer"),
            Error::ExpectedFloat => formatter.write_str("expected float"),
            Error::ExpectedString => formatter.write_str("expected string"),
            Error::ExpectedArray => formatter.write_str("expected array"),
            Error::ExpectedArrayComma => formatter.write_str("expected comma in array"),
            Error::ExpectedArrayEnd => formatter.write_str("expected end of array"),
            Error::ExpectedArraySemicolon => formatter.write_str("expected semicolon after array"),
            Error::ExpectedList => formatter.write_str("expected list"),
            Error::ExpectedListComma => formatter.write_str("expected comma in list"),
            Error::ExpectedListEnd => formatter.write_str("expected end of list"),
            Error::ExpectedGroup => formatter.write_str("expected group"),
            Error::ExpectedEquals => formatter.write_str("expected '=' or ':'"),
            Error::ExpectedSemicolon => formatter.write_str("expected semicolon"),
            Error::ExpectedCommaOrSemicolon => formatter.write_str("expected comma or semicolon"),
            Error::ExpectedGroupEnd => formatter.write_str("expected end of group"),
            Error::ExpectedIdentifier => formatter.write_str("expected identifier"),
            Error::TrailingCharacters => formatter.write_str("trailing characters"),
            Error::HeterogeneousArray => formatter.write_str("heterogeneous arrays not supported"),
            Error::InvalidEscape => formatter.write_str("invalid escape sequence"),
            Error::InvalidNumber => formatter.write_str("invalid number"),
            Error::KeyMustBeAString => formatter.write_str("map keys must be strings"),
            Error::UnitNotSupported => formatter.write_str("unit type not supported"),
            Error::TypeNotSupported(ty) => write!(formatter, "type not supported: {}", ty),
        }
    }
}

impl std::error::Error for Error {}