deseresp 0.1.2

deseresp is an implementation of serializer and deserializer for Redis's RESP3 format using serde framework.
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

/// Serialize or Deserialize error
#[derive(Debug)]
pub enum Error {
    /// Error coming from underlying io
    IO(std::io::Error),
    /// Unexpected EOF encountered
    EOF,
    /// Expected a marker of one type but received something else
    ExpectedMarker(&'static str),
    /// Expected a value of one type but received something else
    ExpectedValue(&'static str),
    /// Received an unexpected value
    UnexpectedValue(&'static str),
    /// Failed to convert the underlying bytes to utf8, value return the offset right before the
    /// invalid utf8
    UTF8(usize),
    /// Failed to parse a float value
    Parse,
    /// Received a NaN
    NaN,
    /// Custom error from serialize/deserialize
    Custom(String),
}

impl Error {
    pub fn io(err: std::io::Error) -> Self {
        Error::IO(err)
    }

    pub fn eof() -> Self {
        Error::EOF
    }

    pub fn expected_marker(expecting: &'static str) -> Self {
        Error::ExpectedMarker(expecting)
    }

    /// expect some value but got something else
    pub fn expected_value(expecting: &'static str) -> Self {
        Error::ExpectedValue(expecting)
    }

    pub fn unexpected_value(unexpected: &'static str) -> Self {
        Error::UnexpectedValue(unexpected)
    }

    pub fn utf8(valid_up_to: usize) -> Self {
        Error::UTF8(valid_up_to)
    }

    pub fn overflow() -> Self {
        Error::Parse
    }

    pub fn parse() -> Self {
        Error::Parse
    }

    pub fn nan() -> Self {
        Error::NaN
    }
}

impl std::fmt::Display for Error {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "TODO")
    }
}

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

impl serde::de::Error for Error {
    fn custom<T>(msg: T) -> Self
    where
        T: std::fmt::Display,
    {
        Error::Custom(msg.to_string())
    }
}

/// Result from serialize/deserialize
pub type Result<T> = std::result::Result<T, Error>;