Trait CommandSenderAsync

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

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, K: ToString, V: ToString>( &mut self, key: K, value: V, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn auth<G, P: ToString>( &mut self, password: P, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn bgrewriteaof<G>(&mut self, callback: G) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn bgsave<G>(&mut self, callback: G) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn bitcount<G, K: ToString>( &mut self, key: K, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn blpop<G, K: ToString>( &mut self, key: K, timeout: u32, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn brpop<G, K: ToString>( &mut self, key: K, timeout: u32, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn decr<G, K: ToString>( &mut self, key: K, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn decrby<G, K: ToString>( &mut self, key: K, increment: i64, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn del<G, K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn mdel<G, K: ToString>( &mut self, keys: Vec<K>, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn discard<G>(&mut self, callback: G) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn echo<G, K: ToString>( &mut self, msg: K, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn exec<G>(&mut self, callback: G) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn exists<G, K: ToString>( &mut self, key: K, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn mexists<G, K: ToString>( &mut self, keys: Vec<K>, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn expire<G, K: ToString>( &mut self, key: K, expiry: i64, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn expireat<G, K: ToString>( &mut self, key: K, timestamp: i64, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn get<G, K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn hdel<G, K: ToString, F: ToString>( &mut self, key: K, field: F, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn hexists<G, K: ToString, F: ToString>( &mut self, key: K, field: F, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn hget<G, K: ToString, F: ToString>( &mut self, key: K, field: F, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn hgetall<G, K: ToString>( &mut self, key: K, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn hkeys<G, K: ToString>( &mut self, key: K, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn hlen<G, K: ToString>( &mut self, key: K, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn hstrlen<G, K: ToString, F: ToString>( &mut self, key: K, field: F, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn hvals<G, K: ToString>( &mut self, key: K, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn lindex<G, K: ToString>( &mut self, key: K, index: i32, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn llen<G, K: ToString>( &mut self, key: K, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn lpop<G, K: ToString>( &mut self, key: K, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn lpush<G, K: ToString, V: ToString>( &mut self, key: K, value: V, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn lpushx<G, K: ToString, V: ToString>( &mut self, key: K, value: V, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn multi<G>(&mut self, callback: G) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn rename<G, K: ToString, N: ToString>( &mut self, key: K, new_key: N, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn renamenx<G, K: ToString, N: ToString>( &mut self, key: K, new_key: N, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn rpop<G, K: ToString>( &mut self, key: K, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn rpoplpush<G, S: ToString, D: ToString>( &mut self, source: S, dest: D, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn rpush<G, K: ToString, V: ToString>( &mut self, key: K, value: V, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn rpushx<G, K: ToString, V: ToString>( &mut self, key: K, value: V, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn sadd<G, K: ToString, M: ToString>( &mut self, key: K, member: M, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn scard<G, K: ToString>( &mut self, key: K, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn select<G>(&mut self, db_index: i32, callback: G) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn set<G, K: ToString, V: ToString>( &mut self, key: K, value: V, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn setnx<G, K: ToString, V: ToString>( &mut self, key: K, value: V, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn setxx<G, K: ToString, V: ToString>( &mut self, key: K, value: V, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn sismember<G, K: ToString, M: ToString>( &mut self, key: K, member: M, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn smembers<G, K: ToString>( &mut self, key: K, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn spop<G, K: ToString>( &mut self, key: K, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn spop_count<G, K: ToString>( &mut self, key: K, count: u32, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn srem<G, K: ToString, M: ToString>( &mut self, key: K, member: M, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn strlen<G, K: ToString>( &mut self, key: K, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn ttl<G, K: ToString>(&mut self, key: K, callback: G) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn unwatch<G>(&mut self, callback: G) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn watch<G, K: ToString>( &mut self, key: K, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn mwatch<G, K: ToString>( &mut self, keys: Vec<K>, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn zcard<G, K: ToString>( &mut self, key: K, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn zcount<G, 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(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

fn zrem<G, K: ToString, M: ToString>( &mut self, key: K, member: M, callback: G, ) -> Result<(), RedisError>

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, RedisError>),

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

where G: Send + 'static + Fn(Result<RedisResult, 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 CommandSenderAsync for RedisClientAsync