Trait redis_client::commands::CommandSenderAsync [−] [src]

pub trait CommandSenderAsync {
    fn append<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, value: V, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn auth<G: Fn(Result<RedisResult, RedisError>), P: ToString>(&mut self, password: P, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn bgrewriteaof<G: Fn(Result<RedisResult, RedisError>)>(&mut self, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn bgsave<G: Fn(Result<RedisResult, RedisError>)>(&mut self, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn bitcount<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn bitcount_range<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, start_range: i64, end_range: i64, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn blpop<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, timeout: u32, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn mblpop<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, keys: Vec<K>, timeout: u32, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn brpop<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, timeout: u32, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn mbrpop<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, keys: Vec<K>, timeout: u32, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn brpoplpush<G: Fn(Result<RedisResult, RedisError>), S: ToString, D: ToString>(&mut self, source: S, dest: D, timeout: u32, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn decr<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn decrby<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, increment: i64, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn del<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn mdel<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, keys: Vec<K>, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn discard<G: Fn(Result<RedisResult, RedisError>)>(&mut self, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn echo<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, msg: K, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn exec<G: Fn(Result<RedisResult, RedisError>)>(&mut self, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn exists<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn mexists<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, keys: Vec<K>, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn expire<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, expiry: i64, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn expireat<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, timestamp: i64, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn get<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn getrange<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, start_range: i64, end_range: i64, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn hdel<G: Fn(Result<RedisResult, RedisError>), K: ToString, F: ToString>(&mut self, key: K, field: F, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn hmdel<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, fields: Vec<V>, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn hexists<G: Fn(Result<RedisResult, RedisError>), K: ToString, F: ToString>(&mut self, key: K, field: F, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn hget<G: Fn(Result<RedisResult, RedisError>), K: ToString, F: ToString>(&mut self, key: K, field: F, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn hgetall<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn hincrby<G: Fn(Result<RedisResult, RedisError>), K: ToString, F: ToString>(&mut self, key: K, field: F, increment: i64, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn hincrbyfloat<G: Fn(Result<RedisResult, RedisError>), K: ToString, F: ToString>(&mut self, key: K, field: F, increment: f64, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn hkeys<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn hlen<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn hmget<G: Fn(Result<RedisResult, RedisError>), K: ToString, F: ToString>(&mut self, key: K, fields: Vec<F>, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn hmset<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, fields: HashMap<String, K>, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn hset<G: Fn(Result<RedisResult, RedisError>), K: ToString, F: ToString, V: ToString>(&mut self, key: K, field: F, value: V, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn hstrlen<G: Fn(Result<RedisResult, RedisError>), K: ToString, F: ToString>(&mut self, key: K, field: F, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn hsetnx<G: Fn(Result<RedisResult, RedisError>), K: ToString, F: ToString, V: ToString>(&mut self, key: K, field: F, value: V, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn hvals<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn lindex<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, index: i32, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn linsert_after<G: Fn(Result<RedisResult, RedisError>), K: ToString, P: ToString, V: ToString>(&mut self, key: K, pivot: P, value: V, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn linsert_before<G: Fn(Result<RedisResult, RedisError>), K: ToString, P: ToString, V: ToString>(&mut self, key: K, pivot: P, value: V, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn llen<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn lpop<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn lpush<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, value: V, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn mlpush<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, values: Vec<V>, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn lpushx<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, value: V, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn lrange<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, start: i32, end: i32, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn lrem<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, count: i32, value: V, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn lset<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, index: i32, value: V, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn ltrim<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, start: i32, end: i32, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn multi<G: Fn(Result<RedisResult, RedisError>)>(&mut self, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn rename<G: Fn(Result<RedisResult, RedisError>), K: ToString, N: ToString>(&mut self, key: K, new_key: N, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn renamenx<G: Fn(Result<RedisResult, RedisError>), K: ToString, N: ToString>(&mut self, key: K, new_key: N, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn rpop<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn rpoplpush<G: Fn(Result<RedisResult, RedisError>), S: ToString, D: ToString>(&mut self, source: S, dest: D, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn rpush<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, value: V, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn mrpush<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, values: Vec<V>, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn rpushx<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, value: V, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn sadd<G: Fn(Result<RedisResult, RedisError>), K: ToString, M: ToString>(&mut self, key: K, member: M, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn msadd<G: Fn(Result<RedisResult, RedisError>), K: ToString, M: ToString>(&mut self, key: K, members: Vec<M>, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn sadd_binary<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, member: &[u8], callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn scard<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn select<G: Fn(Result<RedisResult, RedisError>)>(&mut self, db_index: i32, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn set<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, value: V, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn set_binary<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, value: &[u8], callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn setex<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, value: V, expiry: i64, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn psetex<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, value: V, expiry: i64, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn setnx<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, value: V, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn setxx<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, value: V, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn setex_nx<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, value: V, expiry: i64, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn setex_xx<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, value: V, expiry: i64, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn psetex_nx<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, value: V, expiry: i64, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn psetex_xx<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, value: V, expiry: i64, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn setbit<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, offset: u32, bit: u8, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn setrange<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, offset: u32, value: V, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn sismember<G: Fn(Result<RedisResult, RedisError>), K: ToString, M: ToString>(&mut self, key: K, member: M, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn smembers<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn spop<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn spop_count<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, count: u32, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn srem<G: Fn(Result<RedisResult, RedisError>), K: ToString, M: ToString>(&mut self, key: K, member: M, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn msrem<G: Fn(Result<RedisResult, RedisError>), K: ToString, M: ToString>(&mut self, key: K, members: Vec<M>, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn strlen<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn ttl<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn unwatch<G: Fn(Result<RedisResult, RedisError>)>(&mut self, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn watch<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn mwatch<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, keys: Vec<K>, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn zadd<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, score: f64, member: V, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn zadd_binary<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, score: f64, member: &[u8], callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn zaddnx<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, score: f64, member: V, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn zaddxx<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, score: f64, member: V, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn zaddnx_ch<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, score: f64, member: V, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn zaddxx_ch<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, score: f64, member: V, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn zcard<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn zcount<G: Fn(Result<RedisResult, RedisError>), K: ToString, S: ToString, E: ToString>(&mut self, key: K, start_range: S, end_range: E, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn zincrby<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, increment: f64, member: V, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn zlexcount<G: Fn(Result<RedisResult, RedisError>), K: ToString, S: ToString, E: ToString>(&mut self, key: K, min: S, max: E, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn zrem<G: Fn(Result<RedisResult, RedisError>), K: ToString, M: ToString>(&mut self, key: K, member: M, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn mzrem<G: Fn(Result<RedisResult, RedisError>), K: ToString, M: ToString>(&mut self, key: K, members: Vec<M>, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn zrange<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, start_range: i64, end_range: i64, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn zrange_with_scores<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, start_range: i64, end_range: i64, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn zrevrange<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, start_range: i64, end_range: i64, callback: G) -> Result<(), RedisError> where G: Send + 'static;
    fn zrevrange_with_scores<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, start_range: i64, end_range: i64, callback: G) -> Result<(), RedisError> where G: Send + 'static;
}

The trait CommandSenderAsync implements methods to send redis commands and receive the response asynchronously.

Each methods returns a:

Result<(), RedisError>

It means that when calling a method from this trait if the Result is an error, the command execution failed to start. Otherwise it means that the command execution was successfully launched.

Each method will contained a callback argument:

Fn(Result<RedisResult, RedisError>)

Once the command execution is over, it will be called once the pump method is called.

All commands execution are made in a background thread.

Required Methods

`fn append<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, value: V, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn auth<G: Fn(Result<RedisResult, RedisError>), P: ToString>(&mut self, password: P, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn bgrewriteaof<G: Fn(Result<RedisResult, RedisError>)>(&mut self, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn bgsave<G: Fn(Result<RedisResult, RedisError>)>(&mut self, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn bitcount<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn bitcount_range<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, start_range: i64, end_range: i64, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn blpop<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, timeout: u32, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn mblpop<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, keys: Vec<K>, timeout: u32, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn brpop<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, timeout: u32, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn mbrpop<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, keys: Vec<K>, timeout: u32, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn brpoplpush<G: Fn(Result<RedisResult, RedisError>), S: ToString, D: ToString>(&mut self, source: S, dest: D, timeout: u32, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn decr<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn decrby<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, increment: i64, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn del<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn mdel<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, keys: Vec<K>, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn discard<G: Fn(Result<RedisResult, RedisError>)>(&mut self, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn echo<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, msg: K, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn exec<G: Fn(Result<RedisResult, RedisError>)>(&mut self, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn exists<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn mexists<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, keys: Vec<K>, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn expire<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, expiry: i64, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn expireat<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, timestamp: i64, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn get<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn getrange<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, start_range: i64, end_range: i64, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn hdel<G: Fn(Result<RedisResult, RedisError>), K: ToString, F: ToString>(&mut self, key: K, field: F, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn hmdel<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, fields: Vec<V>, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn hexists<G: Fn(Result<RedisResult, RedisError>), K: ToString, F: ToString>(&mut self, key: K, field: F, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn hget<G: Fn(Result<RedisResult, RedisError>), K: ToString, F: ToString>(&mut self, key: K, field: F, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn hgetall<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn hincrby<G: Fn(Result<RedisResult, RedisError>), K: ToString, F: ToString>(&mut self, key: K, field: F, increment: i64, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn hincrbyfloat<G: Fn(Result<RedisResult, RedisError>), K: ToString, F: ToString>(&mut self, key: K, field: F, increment: f64, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn hkeys<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn hlen<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn hmget<G: Fn(Result<RedisResult, RedisError>), K: ToString, F: ToString>(&mut self, key: K, fields: Vec<F>, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn hmset<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, fields: HashMap<String, K>, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn hset<G: Fn(Result<RedisResult, RedisError>), K: ToString, F: ToString, V: ToString>(&mut self, key: K, field: F, value: V, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn hstrlen<G: Fn(Result<RedisResult, RedisError>), K: ToString, F: ToString>(&mut self, key: K, field: F, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn hsetnx<G: Fn(Result<RedisResult, RedisError>), K: ToString, F: ToString, V: ToString>(&mut self, key: K, field: F, value: V, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn hvals<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn lindex<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, index: i32, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn linsert_after<G: Fn(Result<RedisResult, RedisError>), K: ToString, P: ToString, V: ToString>(&mut self, key: K, pivot: P, value: V, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn linsert_before<G: Fn(Result<RedisResult, RedisError>), K: ToString, P: ToString, V: ToString>(&mut self, key: K, pivot: P, value: V, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn llen<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn lpop<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn lpush<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, value: V, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn mlpush<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, values: Vec<V>, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn lpushx<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, value: V, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn lrange<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, start: i32, end: i32, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn lrem<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, count: i32, value: V, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn lset<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, index: i32, value: V, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn ltrim<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, start: i32, end: i32, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn multi<G: Fn(Result<RedisResult, RedisError>)>(&mut self, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn rename<G: Fn(Result<RedisResult, RedisError>), K: ToString, N: ToString>(&mut self, key: K, new_key: N, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn renamenx<G: Fn(Result<RedisResult, RedisError>), K: ToString, N: ToString>(&mut self, key: K, new_key: N, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn rpop<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn rpoplpush<G: Fn(Result<RedisResult, RedisError>), S: ToString, D: ToString>(&mut self, source: S, dest: D, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn rpush<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, value: V, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn mrpush<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, values: Vec<V>, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn rpushx<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, value: V, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn sadd<G: Fn(Result<RedisResult, RedisError>), K: ToString, M: ToString>(&mut self, key: K, member: M, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn msadd<G: Fn(Result<RedisResult, RedisError>), K: ToString, M: ToString>(&mut self, key: K, members: Vec<M>, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn sadd_binary<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, member: &[u8], callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn scard<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn select<G: Fn(Result<RedisResult, RedisError>)>(&mut self, db_index: i32, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn set<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, value: V, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn set_binary<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, value: &[u8], callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn setex<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, value: V, expiry: i64, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn psetex<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, value: V, expiry: i64, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn setnx<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, value: V, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn setxx<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, value: V, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn setex_nx<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, value: V, expiry: i64, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn setex_xx<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, value: V, expiry: i64, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn psetex_nx<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, value: V, expiry: i64, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn psetex_xx<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, value: V, expiry: i64, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn setbit<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, offset: u32, bit: u8, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn setrange<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, offset: u32, value: V, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn sismember<G: Fn(Result<RedisResult, RedisError>), K: ToString, M: ToString>(&mut self, key: K, member: M, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn smembers<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn spop<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn spop_count<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, count: u32, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn srem<G: Fn(Result<RedisResult, RedisError>), K: ToString, M: ToString>(&mut self, key: K, member: M, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn msrem<G: Fn(Result<RedisResult, RedisError>), K: ToString, M: ToString>(&mut self, key: K, members: Vec<M>, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn strlen<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn ttl<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn unwatch<G: Fn(Result<RedisResult, RedisError>)>(&mut self, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn watch<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn mwatch<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, keys: Vec<K>, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn zadd<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, score: f64, member: V, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn zadd_binary<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, score: f64, member: &[u8], callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn zaddnx<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, score: f64, member: V, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn zaddxx<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, score: f64, member: V, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn zaddnx_ch<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, score: f64, member: V, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn zaddxx_ch<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, score: f64, member: V, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn zcard<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn zcount<G: Fn(Result<RedisResult, RedisError>), K: ToString, S: ToString, E: ToString>(&mut self, key: K, start_range: S, end_range: E, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn zincrby<G: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(&mut self, key: K, increment: f64, member: V, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn zlexcount<G: Fn(Result<RedisResult, RedisError>), K: ToString, S: ToString, E: ToString>(&mut self, key: K, min: S, max: E, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn zrem<G: Fn(Result<RedisResult, RedisError>), K: ToString, M: ToString>(&mut self, key: K, member: M, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn mzrem<G: Fn(Result<RedisResult, RedisError>), K: ToString, M: ToString>(&mut self, key: K, members: Vec<M>, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn zrange<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, start_range: i64, end_range: i64, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn zrange_with_scores<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, start_range: i64, end_range: i64, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn zrevrange<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, start_range: i64, end_range: i64, callback: G) -> Result<(), RedisError> where G: Send + 'static`

`fn zrevrange_with_scores<G: Fn(Result<RedisResult, RedisError>), K: ToString>(&mut self, key: K, start_range: i64, end_range: i64, callback: G) -> Result<(), RedisError> where G: Send + 'static`

Implementors

impl CommandSenderAsync for RedisClientAsync