Struct RedisClientAsync

pub struct RedisClientAsync { /* private fields */ }

Implementations

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"));

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

pub fn exec_redis_pipeline_command_async<F>( &mut self, redis_command: &mut RedisCommand, callback: F, ) -> Result<(), RedisError>

where F: Fn(Result<Vec<RedisResult>, RedisError>) + 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.

pub fn exec_redis_command_async<F>( &mut self, redis_command: &mut RedisCommand, callback: F, ) -> Result<(), RedisError>

where F: Fn(Result<RedisResult, RedisError>) + 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.

pub 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, 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>),

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.