Struct redis_client::redis::RedisClientAsync [] [src]

pub struct RedisClientAsync {
    // some 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

impl Display for RedisClientAsync

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