Trait redis_client::commands::CommandSenderAsync
[−]
[src]
pub trait CommandSenderAsync { 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; }
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: Fn(Result<RedisResult, RedisError>), K: ToString, V: ToString>(
&mut self,
key: K,
value: V,
callback: G
) -> Result<(), RedisError> where
G: Send + 'static,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&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,
&mut self,
key: K,
start_range: i64,
end_range: i64,
callback: G
) -> Result<(), RedisError> where
G: Send + 'static,
Implementors
impl CommandSenderAsync for RedisClientAsync