redis-asio 0.1.0-alpha

Asynchronous Redis driver based on tokio
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

use super::{RedisResult, RedisValue, RedisError, RedisErrorKind};


/// Internal set of types that are immediately parsed to and from RESP binary packets.
/// Represents RESP protocol: "https://redis.io/topics/protocol".
#[derive(PartialEq, Eq, Debug, Clone)]
pub enum RespInternalValue {
    Nil,
    Error(String),
    Status(String),
    Int(i64),
    BulkString(Vec<u8>),
    Array(Vec<RespInternalValue>),
}

impl RespInternalValue {
    pub fn from_redis_value(value: RedisValue) -> RespInternalValue {
        match value {
            RedisValue::Nil => RespInternalValue::Nil,
            RedisValue::Ok => RespInternalValue::Status("OK".to_string()),
            RedisValue::Status(x) => RespInternalValue::Status(x),
            RedisValue::Int(x) => RespInternalValue::Int(x),
            RedisValue::BulkString(x) => RespInternalValue::BulkString(x),
            RedisValue::Array(x) =>
                RespInternalValue::Array(
                    x.into_iter()
                        .map(|val| RespInternalValue::from_redis_value(val))
                        .collect())
        }
    }

    pub fn into_redis_value(self) -> RedisResult<RedisValue> {
        match self {
            RespInternalValue::Nil => Ok(RedisValue::Nil),
            RespInternalValue::Error(x) => Err(RedisError::new(RedisErrorKind::ReceiveError, x)),
            RespInternalValue::Status(x) => match x.as_str() {
                "OK" => Ok(RedisValue::Ok),
                _ => Ok(RedisValue::Status(x))
            },
            RespInternalValue::Int(x) => Ok(RedisValue::Int(x)),
            RespInternalValue::BulkString(x) => Ok(RedisValue::BulkString(x)),
            RespInternalValue::Array(x) => {
                let mut res: Vec<RedisValue> = Vec::with_capacity(x.len());
                for val in x.into_iter() {
                    res.push(val.into_redis_value()?);
                }
                Ok(RedisValue::Array(res))
            }
        }
    }
}