meilies 0.2.0

The RESP and MeiliES protocol 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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

use std::string::FromUtf8Error;
use std::fmt;
use super::RespValue;

pub trait FromResp: Sized {
    type Error;
    fn from_resp(value: RespValue) -> Result<Self, Self::Error>;
}

impl FromResp for RespValue {
    type Error = (); // FIXME replace with never (!)

    fn from_resp(value: RespValue) -> Result<Self, <Self as FromResp>::Error> {
        Ok(value)
    }
}

#[derive(Debug)]
pub enum RespStringConvertError {
    InvalidRespType,
    InvalidUtf8String(FromUtf8Error),
}

impl fmt::Display for RespStringConvertError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        use RespStringConvertError::*;
        match self {
            InvalidRespType => {
                write!(f, "invalid RESP type found, expected String, Error or BulkString")
            },
            InvalidUtf8String(e) => write!(f, "invalid UTF8 string; {}", e),
        }
    }
}

impl FromResp for String {
    type Error = RespStringConvertError;

    fn from_resp(value: RespValue) -> Result<Self, Self::Error> {
        use RespStringConvertError::*;
        match value {
            RespValue::SimpleString(string) => Ok(string),
            RespValue::Error(string) => Ok(string),
            RespValue::BulkString(bytes) => String::from_utf8(bytes).map_err(InvalidUtf8String),
            _ => Err(InvalidRespType),
        }
    }
}

#[derive(Debug)]
pub enum RespIntConvertError {
    InvalidRespType,
}

impl fmt::Display for RespIntConvertError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            RespIntConvertError::InvalidRespType => {
                write!(f, "invalid RESP type found, expected Integer")
            },
        }
    }
}

impl FromResp for i64 {
    type Error = RespIntConvertError;

    fn from_resp(value: RespValue) -> Result<Self, Self::Error> {
        match value {
            RespValue::Integer(integer) => Ok(integer),
            _ => Err(RespIntConvertError::InvalidRespType),
        }
    }
}

#[derive(Debug)]
pub enum RespBytesConvertError {
    InvalidRespType,
}

impl fmt::Display for RespBytesConvertError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            RespBytesConvertError::InvalidRespType => {
                write!(f, "invalid RESP type found, expected String, Error or BulkString")
            },
        }
    }
}

impl FromResp for Vec<u8> {
    type Error = RespBytesConvertError;

    fn from_resp(value: RespValue) -> Result<Self, Self::Error> {
        match value {
            RespValue::SimpleString(string) => Ok(string.into_bytes()),
            RespValue::Error(string) => Ok(string.into_bytes()),
            RespValue::BulkString(bytes) => Ok(bytes),
            _ => Err(RespBytesConvertError::InvalidRespType),
        }
    }
}

#[derive(Debug)]
pub enum RespVecConvertError<E> {
    InvalidRespType,
    InnerRespConvertError(E),
}

impl<E: fmt::Display> fmt::Display for RespVecConvertError<E> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        use RespVecConvertError::*;
        match self {
            InvalidRespType => {
                write!(f, "invalid RESP type found, expected Array")
            },
            InnerRespConvertError(e) => {
                write!(f, "inner RESP type convertion error: {}", e)
            },
        }
    }
}

impl<T: FromResp> FromResp for Vec<T> {
    type Error = RespVecConvertError<T::Error>;

    fn from_resp(value: RespValue) -> Result<Self, Self::Error> {
        use RespVecConvertError::*;
        match value {
            RespValue::Array(array) => {
                let result: Result<Vec<_>, _> = array.into_iter().map(|e| T::from_resp(e)).collect();
                result.map_err(InnerRespConvertError)
            },
            _ => Err(InvalidRespType),
        }
    }
}

impl<T: FromResp> FromResp for Option<T> {
    type Error = T::Error;

    fn from_resp(value: RespValue) -> Result<Self, Self::Error> {
        match value {
            RespValue::Nil => Ok(None),
            other => T::from_resp(other).map(Some),
        }
    }
}

impl<T: FromResp> FromResp for Result<T, String> {
    type Error = T::Error;

    fn from_resp(value: RespValue) -> Result<Self, Self::Error> {
        match value {
            RespValue::Error(string) => Ok(Err(string)),
            other => T::from_resp(other).map(Ok),
        }
    }
}