buni-rs 1.2.0

Reference Buni serializer / deserializer in Rust
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

use alloc::boxed::Box;
use alloc::string::{String, ToString};
use nom::error::ErrorKind;
use nom::Input;
#[cfg(feature = "serde")]
use serde_core::de;
use core::fmt;
use core::fmt::{Debug, Display, Formatter};

#[derive(Debug)]
pub enum DeserializeError<I: Input + Debug + Display> {
    Message(String),
    ParseError(Option<I>, ErrorKind),
    WrappedParseError(Box<Self>, Option<I>, ErrorKind),
    ConversionError(String),

    ExpectedInteger,
    EmptyString,
    ExpectedString,
    ExpectedList,
    ExpectedListOrNull,
    ExpectedListOrString,
    ExpectedAnnotatedList,
    UnexpectedNamedList,
    NotSupported,
    OutOfOrder,
}

impl<I: Input + Debug + Display> core::error::Error for DeserializeError<I> {}

#[cfg(feature = "serde")]
impl<I: Input + Debug + Display> de::Error for DeserializeError<I> {
    fn custom<T: Display>(msg: T) -> Self {
        DeserializeError::Message(msg.to_string())
    }
}

impl<I: Input + Debug + Display> nom::error::ParseError<I> for DeserializeError<I> {
    fn from_error_kind(input: I, kind: ErrorKind) -> Self {
        DeserializeError::ParseError(Some(input), kind)
    }

    fn append(input: I, kind: ErrorKind, other: DeserializeError<I>) -> DeserializeError<I> {
        DeserializeError::WrappedParseError(Box::new(other), Some(input), kind)
    }
}

impl<I: Input + Debug + Display> Display for DeserializeError<I> {
    fn fmt(&self, formatter: &mut Formatter) -> fmt::Result {
        match self {
            DeserializeError::Message(msg) => write!(formatter, "serde message: {}", msg),
            DeserializeError::ParseError(input, kind) => {
                match input {
                    None => write!(formatter, "parse error: {}", kind.description()),
                    Some(input) => write!(formatter, "parse error: {} for input {}", kind.description(), input)
                }
            },
            DeserializeError::WrappedParseError(err, input, kind) => {
                match input {
                    None => write!(formatter, "parse error: {} (wrapped: {})", kind.description(), err.to_string()),
                    Some(input) => write!(formatter, "parse error: {} for input {} (wrapped: {})", kind.description(), input, err.to_string())
                }
            },
            DeserializeError::ConversionError(err) => write!(formatter, "type conversion error: {}", err),

            DeserializeError::ExpectedInteger => write!(formatter, "expected integer"),
            DeserializeError::EmptyString => write!(formatter, "empty string"),
            DeserializeError::ExpectedString => write!(formatter, "expected string"),
            DeserializeError::ExpectedList => write!(formatter, "expected list"),
            DeserializeError::ExpectedListOrNull => write!(formatter, "expected list or null"),
            DeserializeError::ExpectedListOrString => write!(formatter, "expected list or string"),
            DeserializeError::ExpectedAnnotatedList => write!(formatter, "expected annotated list"),
            DeserializeError::UnexpectedNamedList => write!(formatter, "unexpected named list"),
            DeserializeError::NotSupported => write!(formatter, "not supported"),
            DeserializeError::OutOfOrder => write!(formatter, "deserialization functions invoked out of order")
        }
    }
}

impl<I: Input + Debug + Display> DeserializeError<I> {
    pub fn map_to_conversion_error<E: Display>(e: E) -> Self {
        DeserializeError::ConversionError(e.to_string())
    }
}