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

pub trait CommandSender {
    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

Implementors