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
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

use crate::RespInternalValue;


/// Make a Redis command represents array of `BulkString`s
/// wrapped into `RedisCommand`.
///
/// # Example
///
/// ```
/// use redis_asio::command;
/// let cmd = redis_asio::command("SET").arg("foo").arg("bar");
/// ```
pub fn command(cmd: &str) -> RedisCommand {
    RedisCommand::cmd(cmd)
}

/// Enumeration of base types that can be put into
/// `RedisCommand` chain as argument.
pub enum RedisArgument {
    Int(i64),
    String(String),
    Bytes(Vec<u8>),
}

/// Redis command wrapper represents array of `BulkString`s
#[derive(Clone)]
pub struct RedisCommand {
    args: Vec<RespInternalValue>,
}

/// Trait interface requires to implement method to convert base type
/// into `RedisArgument`.
///
/// # Example
/// ```
/// use redis_asio::{RedisArgument, IntoRedisArgument, command};
///
/// struct ClientStruct { pub data: String }
///
/// impl IntoRedisArgument for ClientStruct {
///     fn into_redis_argument(self) -> RedisArgument {
///         RedisArgument::String(self.data)
///     }
/// }
///
/// let value = ClientStruct { data: "Hello, world".to_string() };
/// let cmd = command("SET").arg("foo").arg(value);
/// ```
pub trait IntoRedisArgument {
    fn into_redis_argument(self) -> RedisArgument;
}

impl RedisCommand {
    pub(crate) fn new() -> RedisCommand {
        RedisCommand { args: Vec::new() }
    }

    /// Method is used by `redis::command()`.
    pub(crate) fn cmd(cmd: &str) -> RedisCommand {
        RedisCommand {
            args: vec![RespInternalValue::BulkString(cmd.as_bytes().to_vec())]
        }
    }

    /// Add new argument into `RedisCommand` and move the one back.
    /// The argument should implement the `IntoRedisArgument` trait.
    pub fn arg<T: IntoRedisArgument>(mut self, arg: T) -> RedisCommand {
        self.args.push(arg.into_redis_argument().into_resp_value());
        self
    }

    /// Add new argument into `RedisCommand` through object changing.
    /// The argument should implement the `IntoRedisArgument` trait.
    pub fn arg_mut<T: IntoRedisArgument>(&mut self, arg: T) {
        self.args.push(arg.into_redis_argument().into_resp_value());
    }

    /// Append the other `RedisCommand`'s arguments into self arguments.
    pub fn append(&mut self, mut other: RedisCommand) {
        self.args.append(&mut other.args);
    }

    // TODO make it pub(crate) maybe.
    /// Convert the self into `RespInternalValue`.
    pub fn into_resp_value(self) -> RespInternalValue {
        RespInternalValue::Array(self.args)
    }
}

impl RedisArgument {
    pub(crate) fn into_resp_value(self) -> RespInternalValue {
        match self {
            RedisArgument::Int(x) => RespInternalValue::BulkString(x.to_string().into()),
            RedisArgument::String(x) => RespInternalValue::BulkString(x.into()),
            RedisArgument::Bytes(x) => RespInternalValue::BulkString(x),
        }
    }
}

impl IntoRedisArgument for RedisArgument {
    fn into_redis_argument(self) -> RedisArgument {
        self
    }
}

impl IntoRedisArgument for &str {
    fn into_redis_argument(self) -> RedisArgument {
        RedisArgument::String(self.to_string())
    }
}

impl IntoRedisArgument for String {
    fn into_redis_argument(self) -> RedisArgument {
        RedisArgument::String(self)
    }
}

impl IntoRedisArgument for Vec<u8> {
    fn into_redis_argument(self) -> RedisArgument {
        RedisArgument::Bytes(self)
    }
}

macro_rules! declare_to_int_argument {
    ($itype:ty) => {
        impl IntoRedisArgument for $itype {
            fn into_redis_argument(self) -> RedisArgument {
                RedisArgument::Int(self as i64)
            }
        }
    };
}

declare_to_int_argument!(u8);
declare_to_int_argument!(i8);
declare_to_int_argument!(u16);
declare_to_int_argument!(i16);
declare_to_int_argument!(u32);
declare_to_int_argument!(i32);
declare_to_int_argument!(i64);
declare_to_int_argument!(u64);
declare_to_int_argument!(usize);