Struct redis_client::redis::RedisClientAsync

pub struct RedisClientAsync { /* fields omitted */ }

Methods

impl RedisClientAsync

A RedisClientAsync is a structure to send command to redis and receive the response asynchronously.

When creating a RedisClientAsync it will automatically create a connection. Therefore when it is created it uses the host and the port.

Example:

let mut client = try!(redis_client::RedisClientAsync::new("127.0.0.1", "6379"));

fn new(
    host: &'static str,
    port: &'static str
) -> Result<RedisClientAsync, RedisError>

fn exec_redis_pipeline_command_async<F>(
    &mut self,
    redis_command: &mut RedisCommand,
    callback: F
) -> Result<(), RedisError> where
    F: Fn(Result<Vec<RedisResult>, RedisError>),
    F: Send + 'static, 

Execute a redis pipeline command. The callback will be called once the command execution is over and the pump method is called. The return value indicates if the command was successfully launched.

fn exec_redis_command_async<F>(
    &mut self,
    redis_command: &mut RedisCommand,
    callback: F
) -> Result<(), RedisError> where
    F: Fn(Result<RedisResult, RedisError>),
    F: Send + 'static, 

Execute a redis command. The callback will be called once the command execution is over and the pump method is called. The return value indicates if the command was successfully launched.

fn pump(&mut self) -> Result<(), RedisError>

Pump the result and execute the callbacks with them. If no result are ready this function will return.

Trait Implementations

impl CommandSenderAsync for RedisClientAsync

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, 

impl Debug for RedisClientAsync

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Display for RedisClientAsync

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.