Trait CommandSender

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

The trait CommandSender implements methods to send redis commands and receive the response synchronously.

Each methods returns a:

Result<R: From<RedisResult>, RedisError>

It means that when calling a method from this trait you need to specify the type you want R to be. For example:

let result: String = try!(client.set("key", "value"));

Required Methods

fn append<R: From<RedisResult>, K: ToString, V: ToString>( &mut self, key: K, value: V, ) -> Result<R, RedisError>

fn auth<R: From<RedisResult>, P: ToString>( &mut self, password: P, ) -> Result<R, RedisError>

fn bgrewriteaof<R: From<RedisResult>>(&mut self) -> Result<R, RedisError>

fn bgsave<R: From<RedisResult>>(&mut self) -> Result<R, RedisError>

fn bitcount<R: From<RedisResult>, K: ToString>( &mut self, key: K, ) -> Result<R, RedisError>

fn bitcount_range<R: From<RedisResult>, K: ToString>( &mut self, key: K, start_range: i64, end_range: i64, ) -> Result<R, RedisError>

fn blpop<R: From<RedisResult>, K: ToString>( &mut self, key: K, timeout: u32, ) -> Result<R, RedisError>

fn mblpop<R: From<RedisResult>, K: ToString>( &mut self, keys: Vec<K>, timeout: u32, ) -> Result<R, RedisError>

fn brpop<R: From<RedisResult>, K: ToString>( &mut self, key: K, timeout: u32, ) -> Result<R, RedisError>

fn mbrpop<R: From<RedisResult>, K: ToString>( &mut self, keys: Vec<K>, timeout: u32, ) -> Result<R, RedisError>

fn brpoplpush<R: From<RedisResult>, S: ToString, D: ToString>( &mut self, source: S, dest: D, timeout: u32, ) -> Result<R, RedisError>

fn decr<R: From<RedisResult>, K: ToString>( &mut self, key: K, ) -> Result<R, RedisError>

fn decrby<R: From<RedisResult>, K: ToString>( &mut self, key: K, increment: i64, ) -> Result<R, RedisError>

fn del<R: From<RedisResult>, K: ToString>( &mut self, key: K, ) -> Result<R, RedisError>

fn mdel<R: From<RedisResult>, K: ToString>( &mut self, keys: Vec<K>, ) -> Result<R, RedisError>

fn discard<R: From<RedisResult>>(&mut self) -> Result<R, RedisError>

fn echo<R: From<RedisResult>, K: ToString>( &mut self, msg: K, ) -> Result<R, RedisError>

fn exec<R: From<RedisResult>>(&mut self) -> Result<R, RedisError>

fn exists<R: From<RedisResult>, K: ToString>( &mut self, key: K, ) -> Result<R, RedisError>

fn mexists<R: From<RedisResult>, K: ToString>( &mut self, keys: Vec<K>, ) -> Result<R, RedisError>

fn expire<R: From<RedisResult>, K: ToString>( &mut self, key: K, expiry: i64, ) -> Result<R, RedisError>

fn expireat<R: From<RedisResult>, K: ToString>( &mut self, key: K, timestamp: i64, ) -> Result<R, RedisError>

fn get<R: From<RedisResult>, K: ToString>( &mut self, key: K, ) -> Result<R, RedisError>

fn getrange<R: From<RedisResult>, K: ToString>( &mut self, key: K, start_range: i64, end_range: i64, ) -> Result<R, RedisError>

fn hdel<R: From<RedisResult>, K: ToString, F: ToString>( &mut self, key: K, field: F, ) -> Result<R, RedisError>

fn hmdel<R: From<RedisResult>, K: ToString, V: ToString>( &mut self, key: K, fields: Vec<V>, ) -> Result<R, RedisError>

fn hexists<R: From<RedisResult>, K: ToString, F: ToString>( &mut self, key: K, field: F, ) -> Result<R, RedisError>

fn hget<R: From<RedisResult>, K: ToString, F: ToString>( &mut self, key: K, field: F, ) -> Result<R, RedisError>

fn hgetall<R: From<RedisResult>, K: ToString>( &mut self, key: K, ) -> Result<R, RedisError>

fn hincrby<R: From<RedisResult>, K: ToString, F: ToString>( &mut self, key: K, field: F, increment: i64, ) -> Result<R, RedisError>

fn hincrbyfloat<R: From<RedisResult>, K: ToString, F: ToString>( &mut self, key: K, field: F, increment: f64, ) -> Result<R, RedisError>

fn hkeys<R: From<RedisResult>, K: ToString>( &mut self, key: K, ) -> Result<R, RedisError>

fn hlen<R: From<RedisResult>, K: ToString>( &mut self, key: K, ) -> Result<R, RedisError>

fn hmget<R: From<RedisResult>, K: ToString, F: ToString>( &mut self, key: K, fields: Vec<F>, ) -> Result<R, RedisError>

fn hmset<R: From<RedisResult>, K: ToString>( &mut self, key: K, fields: HashMap<String, K>, ) -> Result<R, RedisError>

fn hset<R: From<RedisResult>, K: ToString, F: ToString, V: ToString>( &mut self, key: K, field: F, value: V, ) -> Result<R, RedisError>

fn hstrlen<R: From<RedisResult>, K: ToString, F: ToString>( &mut self, key: K, field: F, ) -> Result<R, RedisError>

fn hsetnx<R: From<RedisResult>, K: ToString, F: ToString, V: ToString>( &mut self, key: K, field: F, value: V, ) -> Result<R, RedisError>

fn hvals<R: From<RedisResult>, K: ToString>( &mut self, key: K, ) -> Result<R, RedisError>

fn lindex<R: From<RedisResult>, K: ToString>( &mut self, key: K, index: i32, ) -> Result<R, RedisError>

fn linsert_after<R: From<RedisResult>, K: ToString, P: ToString, V: ToString>( &mut self, key: K, pivot: P, value: V, ) -> Result<R, RedisError>

fn linsert_before<R: From<RedisResult>, K: ToString, P: ToString, V: ToString>( &mut self, key: K, pivot: P, value: V, ) -> Result<R, RedisError>

fn llen<R: From<RedisResult>, K: ToString>( &mut self, key: K, ) -> Result<R, RedisError>

fn lpop<R: From<RedisResult>, K: ToString>( &mut self, key: K, ) -> Result<R, RedisError>

fn lpush<R: From<RedisResult>, K: ToString, V: ToString>( &mut self, key: K, value: V, ) -> Result<R, RedisError>

fn mlpush<R: From<RedisResult>, K: ToString, V: ToString>( &mut self, key: K, values: Vec<V>, ) -> Result<R, RedisError>

fn lpushx<R: From<RedisResult>, K: ToString, V: ToString>( &mut self, key: K, value: V, ) -> Result<R, RedisError>

fn lrange<R: From<RedisResult>, K: ToString>( &mut self, key: K, start: i32, end: i32, ) -> Result<R, RedisError>

fn lrem<R: From<RedisResult>, K: ToString, V: ToString>( &mut self, key: K, count: i32, value: V, ) -> Result<R, RedisError>

fn lset<R: From<RedisResult>, K: ToString, V: ToString>( &mut self, key: K, index: i32, value: V, ) -> Result<R, RedisError>

fn ltrim<R: From<RedisResult>, K: ToString>( &mut self, key: K, start: i32, end: i32, ) -> Result<R, RedisError>

fn multi<R: From<RedisResult>>(&mut self) -> Result<R, RedisError>

fn rename<R: From<RedisResult>, K: ToString, N: ToString>( &mut self, key: K, new_key: N, ) -> Result<R, RedisError>

fn renamenx<R: From<RedisResult>, K: ToString, N: ToString>( &mut self, key: K, new_key: N, ) -> Result<R, RedisError>

fn rpop<R: From<RedisResult>, K: ToString>( &mut self, key: K, ) -> Result<R, RedisError>

fn rpoplpush<R: From<RedisResult>, S: ToString, D: ToString>( &mut self, source: S, dest: D, ) -> Result<R, RedisError>

fn rpush<R: From<RedisResult>, K: ToString, V: ToString>( &mut self, key: K, value: V, ) -> Result<R, RedisError>

fn mrpush<R: From<RedisResult>, K: ToString, V: ToString>( &mut self, key: K, values: Vec<V>, ) -> Result<R, RedisError>

fn rpushx<R: From<RedisResult>, K: ToString, V: ToString>( &mut self, key: K, value: V, ) -> Result<R, RedisError>

fn sadd<R: From<RedisResult>, K: ToString, M: ToString>( &mut self, key: K, member: M, ) -> Result<R, RedisError>

fn msadd<R: From<RedisResult>, K: ToString, M: ToString>( &mut self, key: K, members: Vec<M>, ) -> Result<R, RedisError>

fn sadd_binary<R: From<RedisResult>, K: ToString>( &mut self, key: K, member: &[u8], ) -> Result<R, RedisError>

fn scard<R: From<RedisResult>, K: ToString>( &mut self, key: K, ) -> Result<R, RedisError>

fn select<R: From<RedisResult>>( &mut self, db_index: i32, ) -> Result<R, RedisError>

fn set<R: From<RedisResult>, K: ToString, V: ToString>( &mut self, key: K, value: V, ) -> Result<R, RedisError>

fn set_binary<R: From<RedisResult>, K: ToString>( &mut self, key: K, value: &[u8], ) -> Result<R, RedisError>

fn setex<R: From<RedisResult>, K: ToString, V: ToString>( &mut self, key: K, value: V, expiry: i64, ) -> Result<R, RedisError>

fn psetex<R: From<RedisResult>, K: ToString, V: ToString>( &mut self, key: K, value: V, expiry: i64, ) -> Result<R, RedisError>

fn setnx<R: From<RedisResult>, K: ToString, V: ToString>( &mut self, key: K, value: V, ) -> Result<R, RedisError>

fn setxx<R: From<RedisResult>, K: ToString, V: ToString>( &mut self, key: K, value: V, ) -> Result<R, RedisError>

fn setex_nx<R: From<RedisResult>, K: ToString, V: ToString>( &mut self, key: K, value: V, expiry: i64, ) -> Result<R, RedisError>

fn setex_xx<R: From<RedisResult>, K: ToString, V: ToString>( &mut self, key: K, value: V, expiry: i64, ) -> Result<R, RedisError>

fn psetex_nx<R: From<RedisResult>, K: ToString, V: ToString>( &mut self, key: K, value: V, expiry: i64, ) -> Result<R, RedisError>

fn psetex_xx<R: From<RedisResult>, K: ToString, V: ToString>( &mut self, key: K, value: V, expiry: i64, ) -> Result<R, RedisError>

fn setbit<R: From<RedisResult>, K: ToString>( &mut self, key: K, offset: u32, bit: u8, ) -> Result<R, RedisError>

fn setrange<R: From<RedisResult>, K: ToString, V: ToString>( &mut self, key: K, offset: u32, value: V, ) -> Result<R, RedisError>

fn sismember<R: From<RedisResult>, K: ToString, M: ToString>( &mut self, key: K, member: M, ) -> Result<R, RedisError>

fn smembers<R: From<RedisResult>, K: ToString>( &mut self, key: K, ) -> Result<R, RedisError>

fn spop<R: From<RedisResult>, K: ToString>( &mut self, key: K, ) -> Result<R, RedisError>

fn spop_count<R: From<RedisResult>, K: ToString>( &mut self, key: K, count: u32, ) -> Result<R, RedisError>

fn srem<R: From<RedisResult>, K: ToString, M: ToString>( &mut self, key: K, member: M, ) -> Result<R, RedisError>

fn msrem<R: From<RedisResult>, K: ToString, M: ToString>( &mut self, key: K, members: Vec<M>, ) -> Result<R, RedisError>

fn strlen<R: From<RedisResult>, K: ToString>( &mut self, key: K, ) -> Result<R, RedisError>

fn ttl<R: From<RedisResult>, K: ToString>( &mut self, key: K, ) -> Result<R, RedisError>

fn unwatch<R: From<RedisResult>>(&mut self) -> Result<R, RedisError>

fn watch<R: From<RedisResult>, K: ToString>( &mut self, key: K, ) -> Result<R, RedisError>

fn mwatch<R: From<RedisResult>, K: ToString>( &mut self, keys: Vec<K>, ) -> Result<R, RedisError>

fn zadd<R: From<RedisResult>, K: ToString, V: ToString>( &mut self, key: K, score: f64, member: V, ) -> Result<R, RedisError>

fn zadd_binary<R: From<RedisResult>, K: ToString>( &mut self, key: K, score: f64, member: &[u8], ) -> Result<R, RedisError>

fn zaddnx<R: From<RedisResult>, K: ToString, V: ToString>( &mut self, key: K, score: f64, member: V, ) -> Result<R, RedisError>

fn zaddxx<R: From<RedisResult>, K: ToString, V: ToString>( &mut self, key: K, score: f64, member: V, ) -> Result<R, RedisError>

fn zaddnx_ch<R: From<RedisResult>, K: ToString, V: ToString>( &mut self, key: K, score: f64, member: V, ) -> Result<R, RedisError>

fn zaddxx_ch<R: From<RedisResult>, K: ToString, V: ToString>( &mut self, key: K, score: f64, member: V, ) -> Result<R, RedisError>

fn zcard<R: From<RedisResult>, K: ToString>( &mut self, key: K, ) -> Result<R, RedisError>

fn zcount<R: From<RedisResult>, K: ToString, S: ToString, E: ToString>( &mut self, key: K, start_range: S, end_range: E, ) -> Result<R, RedisError>

fn zincrby<R: From<RedisResult>, K: ToString, V: ToString>( &mut self, key: K, increment: f64, member: V, ) -> Result<R, RedisError>

fn zlexcount<R: From<RedisResult>, K: ToString, S: ToString, E: ToString>( &mut self, key: K, min: S, max: E, ) -> Result<R, RedisError>

fn zrem<R: From<RedisResult>, K: ToString, M: ToString>( &mut self, key: K, member: M, ) -> Result<R, RedisError>

fn mzrem<R: From<RedisResult>, K: ToString, M: ToString>( &mut self, key: K, members: Vec<M>, ) -> Result<R, RedisError>

fn zrange<R: From<RedisResult>, K: ToString>( &mut self, key: K, start_range: i64, end_range: i64, ) -> Result<R, RedisError>

fn zrange_with_scores<R: From<RedisResult>, K: ToString>( &mut self, key: K, start_range: i64, end_range: i64, ) -> Result<R, RedisError>

fn zrevrange<R: From<RedisResult>, K: ToString>( &mut self, key: K, start_range: i64, end_range: i64, ) -> Result<R, RedisError>

fn zrevrange_with_scores<R: From<RedisResult>, K: ToString>( &mut self, key: K, start_range: i64, end_range: i64, ) -> Result<R, RedisError>

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl CommandSender for RedisClient