Struct l337_redis::AsyncConnection [−][src]
pub struct AsyncConnection { pub conn: MultiplexedConnection, // some fields omitted }
Fields
conn: MultiplexedConnection
Methods from Deref<Target = MultiplexedConnection>
Trait Implementations
impl AsMut<MultiplexedConnection> for AsyncConnection
[src]
impl AsMut<MultiplexedConnection> for AsyncConnection
[src]fn as_mut(&mut self) -> &mut MultiplexedConnection
[src]
impl AsRef<MultiplexedConnection> for AsyncConnection
[src]
impl AsRef<MultiplexedConnection> for AsyncConnection
[src]fn as_ref(&self) -> &MultiplexedConnection
[src]
impl ConnectionLike for AsyncConnection
[src]
impl ConnectionLike for AsyncConnection
[src]fn req_packed_command<'a>(&'a mut self, cmd: &'a Cmd) -> RedisFuture<'a, Value>
[src]
fn req_packed_commands<'a>(
&'a mut self,
cmd: &'a Pipeline,
offset: usize,
count: usize
) -> RedisFuture<'a, Vec<Value>>
[src]
&'a mut self,
cmd: &'a Pipeline,
offset: usize,
count: usize
) -> RedisFuture<'a, Vec<Value>>
fn get_db(&self) -> i64
[src]
impl Deref for AsyncConnection
[src]
impl Deref for AsyncConnection
[src]type Target = MultiplexedConnection
The resulting type after dereferencing.
fn deref(&self) -> &Self::Target
[src]
impl Drop for AsyncConnection
[src]
impl Drop for AsyncConnection
[src]Auto Trait Implementations
impl !RefUnwindSafe for AsyncConnection
impl !RefUnwindSafe for AsyncConnection
impl Send for AsyncConnection
impl Send for AsyncConnection
impl Sync for AsyncConnection
impl Sync for AsyncConnection
impl Unpin for AsyncConnection
impl Unpin for AsyncConnection
impl !UnwindSafe for AsyncConnection
impl !UnwindSafe for AsyncConnection
Blanket Implementations
impl<T> AsyncCommands for T where
T: ConnectionLike + Send,
[src]
impl<T> AsyncCommands for T where
T: ConnectionLike + Send,
[src]pub fn get<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn keys<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn set<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn set_multiple<'a, K, V, RV>(
&'a mut self,
items: &'a [(K, V)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
items: &'a [(K, V)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn set_ex<'a, K, V, RV>(
&'a mut self,
key: K,
value: V,
seconds: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
value: V,
seconds: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn pset_ex<'a, K, V, RV>(
&'a mut self,
key: K,
value: V,
milliseconds: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
value: V,
milliseconds: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn set_nx<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn mset_nx<'a, K, V, RV>(
&'a mut self,
items: &'a [(K, V)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
items: &'a [(K, V)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn getset<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn getrange<'a, K, RV>(
&'a mut self,
key: K,
from: isize,
to: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
from: isize,
to: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn setrange<'a, K, V, RV>(
&'a mut self,
key: K,
offset: isize,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
offset: isize,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn del<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn exists<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn expire<'a, K, RV>(
&'a mut self,
key: K,
seconds: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
seconds: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn expire_at<'a, K, RV>(
&'a mut self,
key: K,
ts: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
ts: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn pexpire<'a, K, RV>(
&'a mut self,
key: K,
ms: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
ms: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn pexpire_at<'a, K, RV>(
&'a mut self,
key: K,
ts: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
ts: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn persist<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn ttl<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn pttl<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn rename<'a, K, RV>(
&'a mut self,
key: K,
new_key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
new_key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn rename_nx<'a, K, RV>(
&'a mut self,
key: K,
new_key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
new_key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn unlink<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn append<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn incr<'a, K, V, RV>(
&'a mut self,
key: K,
delta: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
delta: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn decr<'a, K, V, RV>(
&'a mut self,
key: K,
delta: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
delta: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn setbit<'a, K, RV>(
&'a mut self,
key: K,
offset: usize,
value: bool
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
offset: usize,
value: bool
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn getbit<'a, K, RV>(
&'a mut self,
key: K,
offset: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
offset: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn bitcount<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn bitcount_range<'a, K, RV>(
&'a mut self,
key: K,
start: usize,
end: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
start: usize,
end: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn bit_and<'a, K, RV>(
&'a mut self,
dstkey: K,
srckeys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
dstkey: K,
srckeys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn bit_or<'a, K, RV>(
&'a mut self,
dstkey: K,
srckeys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
dstkey: K,
srckeys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn bit_xor<'a, K, RV>(
&'a mut self,
dstkey: K,
srckeys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
dstkey: K,
srckeys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn bit_not<'a, K, RV>(
&'a mut self,
dstkey: K,
srckey: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
dstkey: K,
srckey: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn strlen<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn hget<'a, K, F, RV>(
&'a mut self,
key: K,
field: F
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
F: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
field: F
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
F: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn hdel<'a, K, F, RV>(
&'a mut self,
key: K,
field: F
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
F: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
field: F
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
F: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn hset<'a, K, F, V, RV>(
&'a mut self,
key: K,
field: F,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
F: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
field: F,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
F: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn hset_nx<'a, K, F, V, RV>(
&'a mut self,
key: K,
field: F,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
F: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
field: F,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
F: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn hset_multiple<'a, K, F, V, RV>(
&'a mut self,
key: K,
items: &'a [(F, V)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
F: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
items: &'a [(F, V)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
F: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn hincr<'a, K, F, D, RV>(
&'a mut self,
key: K,
field: F,
delta: D
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
F: 'a + ToRedisArgs + Send + Sync,
D: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
field: F,
delta: D
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
F: 'a + ToRedisArgs + Send + Sync,
D: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn hexists<'a, K, F, RV>(
&'a mut self,
key: K,
field: F
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
F: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
field: F
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
F: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn hkeys<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn hvals<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn hgetall<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn hlen<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn blpop<'a, K, RV>(
&'a mut self,
key: K,
timeout: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
timeout: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn brpop<'a, K, RV>(
&'a mut self,
key: K,
timeout: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
timeout: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn brpoplpush<'a, K, RV>(
&'a mut self,
srckey: K,
dstkey: K,
timeout: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
srckey: K,
dstkey: K,
timeout: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn lindex<'a, K, RV>(
&'a mut self,
key: K,
index: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
index: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn linsert_before<'a, K, P, V, RV>(
&'a mut self,
key: K,
pivot: P,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
P: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
pivot: P,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
P: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn linsert_after<'a, K, P, V, RV>(
&'a mut self,
key: K,
pivot: P,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
P: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
pivot: P,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
P: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn llen<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn lpop<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn lpos<'a, K, V, RV>(
&'a mut self,
key: K,
value: V,
options: LposOptions
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
value: V,
options: LposOptions
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn lpush<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn lpush_exists<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn lrange<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn lrem<'a, K, V, RV>(
&'a mut self,
key: K,
count: isize,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
count: isize,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn ltrim<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn lset<'a, K, V, RV>(
&'a mut self,
key: K,
index: isize,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
index: isize,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn rpop<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn rpoplpush<'a, K, RV>(
&'a mut self,
key: K,
dstkey: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
dstkey: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn rpush<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn rpush_exists<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn sadd<'a, K, M, RV>(
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn scard<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn sdiff<'a, K, RV>(
&'a mut self,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn sdiffstore<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
dstkey: K,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn sinter<'a, K, RV>(
&'a mut self,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn sinterstore<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
dstkey: K,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn sismember<'a, K, M, RV>(
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn smembers<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn smove<'a, K, M, RV>(
&'a mut self,
srckey: K,
dstkey: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
srckey: K,
dstkey: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn spop<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn srandmember<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn srandmember_multiple<'a, K, RV>(
&'a mut self,
key: K,
count: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
count: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn srem<'a, K, M, RV>(
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn sunion<'a, K, RV>(
&'a mut self,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn sunionstore<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
dstkey: K,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn zadd<'a, K, S, M, RV>(
&'a mut self,
key: K,
member: M,
score: S
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
member: M,
score: S
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn zadd_multiple<'a, K, S, M, RV>(
&'a mut self,
key: K,
items: &'a [(S, M)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
items: &'a [(S, M)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn zcard<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn zcount<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
pub fn zincr<'a, K, M, D, RV>(
&'a mut self,
key: K,
member: M,
delta: D
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
D: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
member: M,
delta: D
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
D: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn zinterstore<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn zinterstore_min<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn zinterstore_max<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn zlexcount<'a, K, L, RV>(
&'a mut self,
key: K,
min: L,
max: L
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
L: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
min: L,
max: L
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
L: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn zpopmax<'a, K, RV>(
&'a mut self,
key: K,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn zpopmin<'a, K, RV>(
&'a mut self,
key: K,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn zrange<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn zrange_withscores<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn zrangebylex<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
pub fn zrangebylex_limit<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
pub fn zrevrangebylex<'a, K, MM, M, RV>(
&'a mut self,
key: K,
max: MM,
min: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
max: MM,
min: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
pub fn zrevrangebylex_limit<'a, K, MM, M, RV>(
&'a mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
pub fn zrangebyscore<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
pub fn zrangebyscore_withscores<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
pub fn zrangebyscore_limit<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
pub fn zrangebyscore_limit_withscores<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
pub fn zrank<'a, K, M, RV>(
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn zrem<'a, K, M, RV>(
&'a mut self,
key: K,
members: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
members: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn zrembylex<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
pub fn zremrangebyrank<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn zrembyscore<'a, K, M, MM, RV>(
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
pub fn zrevrange<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn zrevrange_withscores<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn zrevrangebyscore<'a, K, MM, M, RV>(
&'a mut self,
key: K,
max: MM,
min: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
max: MM,
min: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
pub fn zrevrangebyscore_withscores<'a, K, MM, M, RV>(
&'a mut self,
key: K,
max: MM,
min: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
max: MM,
min: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
pub fn zrevrangebyscore_limit<'a, K, MM, M, RV>(
&'a mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
pub fn zrevrangebyscore_limit_withscores<'a, K, MM, M, RV>(
&'a mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
MM: 'a + ToRedisArgs + Send + Sync,
pub fn zrevrank<'a, K, M, RV>(
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn zscore<'a, K, M, RV>(
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn zunionstore<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn zunionstore_min<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn zunionstore_max<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn pfadd<'a, K, E, RV>(
&'a mut self,
key: K,
element: E
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
E: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
element: E
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
E: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn pfcount<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn pfmerge<'a, K, RV>(
&'a mut self,
dstkey: K,
srckeys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
dstkey: K,
srckeys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn publish<'a, K, E, RV>(
&'a mut self,
channel: K,
message: E
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
E: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
channel: K,
message: E
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
E: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn acl_load<RV>(
&'a mut self
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
RV: FromRedisValue,
[src]
&'a mut self
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
RV: FromRedisValue,
pub fn acl_save<RV>(
&'a mut self
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
RV: FromRedisValue,
[src]
&'a mut self
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
RV: FromRedisValue,
pub fn acl_list<RV>(
&'a mut self
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
RV: FromRedisValue,
[src]
&'a mut self
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
RV: FromRedisValue,
pub fn acl_users<RV>(
&'a mut self
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
RV: FromRedisValue,
[src]
&'a mut self
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
RV: FromRedisValue,
pub fn acl_getuser<'a, K, RV>(
&'a mut self,
username: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
username: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn acl_setuser<'a, K, RV>(
&'a mut self,
username: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
username: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn acl_setuser_rules<'a, K, RV>(
&'a mut self,
username: K,
rules: &'a [Rule]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
username: K,
rules: &'a [Rule]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn acl_deluser<'a, K, RV>(
&'a mut self,
usernames: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
usernames: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn acl_cat<RV>(
&'a mut self
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
RV: FromRedisValue,
[src]
&'a mut self
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
RV: FromRedisValue,
pub fn acl_cat_categoryname<'a, K, RV>(
&'a mut self,
categoryname: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
categoryname: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn acl_genpass<RV>(
&'a mut self
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
RV: FromRedisValue,
[src]
&'a mut self
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
RV: FromRedisValue,
pub fn acl_genpass_bits<RV>(
&'a mut self,
bits: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
RV: FromRedisValue,
[src]
&'a mut self,
bits: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
RV: FromRedisValue,
pub fn acl_whoami<RV>(
&'a mut self
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
RV: FromRedisValue,
[src]
&'a mut self
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
RV: FromRedisValue,
pub fn acl_log<RV>(
&'a mut self,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
RV: FromRedisValue,
[src]
&'a mut self,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
RV: FromRedisValue,
pub fn acl_log_reset<RV>(
&'a mut self
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
RV: FromRedisValue,
[src]
&'a mut self
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
RV: FromRedisValue,
pub fn acl_help<RV>(
&'a mut self
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
RV: FromRedisValue,
[src]
&'a mut self
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
RV: FromRedisValue,
pub fn geo_add<'a, K, M, RV>(
&'a mut self,
key: K,
members: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
members: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn geo_dist<'a, K, M1, M2, RV>(
&'a mut self,
key: K,
member1: M1,
member2: M2,
unit: Unit
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
M1: 'a + ToRedisArgs + Send + Sync,
M2: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
member1: M1,
member2: M2,
unit: Unit
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
M1: 'a + ToRedisArgs + Send + Sync,
M2: 'a + ToRedisArgs + Send + Sync,
pub fn geo_hash<'a, K, M, RV>(
&'a mut self,
key: K,
members: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
members: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn geo_pos<'a, K, M, RV>(
&'a mut self,
key: K,
members: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
members: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn geo_radius<'a, K, RV>(
&'a mut self,
key: K,
longitude: f64,
latitude: f64,
radius: f64,
unit: Unit,
options: RadiusOptions
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
longitude: f64,
latitude: f64,
radius: f64,
unit: Unit,
options: RadiusOptions
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn geo_radius_by_member<'a, K, M, RV>(
&'a mut self,
key: K,
member: M,
radius: f64,
unit: Unit,
options: RadiusOptions
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
member: M,
radius: f64,
unit: Unit,
options: RadiusOptions
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn xack<'a, K, G, I, RV>(
&'a mut self,
key: K,
group: G,
ids: &'a [I]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
I: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
group: G,
ids: &'a [I]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
I: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn xadd<'a, K, ID, F, V, RV>(
&'a mut self,
key: K,
id: ID,
items: &'a [(F, V)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
F: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
ID: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
id: ID,
items: &'a [(F, V)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
F: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
ID: 'a + ToRedisArgs + Send + Sync,
pub fn xadd_map<'a, K, ID, BTM, RV>(
&'a mut self,
key: K,
id: ID,
map: BTM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
ID: 'a + ToRedisArgs + Send + Sync,
BTM: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
id: ID,
map: BTM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
ID: 'a + ToRedisArgs + Send + Sync,
BTM: 'a + ToRedisArgs + Send + Sync,
pub fn xadd_maxlen<'a, K, ID, F, V, RV>(
&'a mut self,
key: K,
maxlen: StreamMaxlen,
id: ID,
items: &'a [(F, V)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
F: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
ID: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
maxlen: StreamMaxlen,
id: ID,
items: &'a [(F, V)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
F: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
ID: 'a + ToRedisArgs + Send + Sync,
pub fn xadd_maxlen_map<'a, K, ID, BTM, RV>(
&'a mut self,
key: K,
maxlen: StreamMaxlen,
id: ID,
map: BTM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
ID: 'a + ToRedisArgs + Send + Sync,
BTM: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
maxlen: StreamMaxlen,
id: ID,
map: BTM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
ID: 'a + ToRedisArgs + Send + Sync,
BTM: 'a + ToRedisArgs + Send + Sync,
pub fn xclaim<'a, K, G, C, MIT, ID, RV>(
&'a mut self,
key: K,
group: G,
consumer: C,
min_idle_time: MIT,
ids: &'a [ID]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
C: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
ID: 'a + ToRedisArgs + Send + Sync,
MIT: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
group: G,
consumer: C,
min_idle_time: MIT,
ids: &'a [ID]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
C: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
ID: 'a + ToRedisArgs + Send + Sync,
MIT: 'a + ToRedisArgs + Send + Sync,
pub fn xclaim_options<'a, K, G, C, MIT, ID, RV>(
&'a mut self,
key: K,
group: G,
consumer: C,
min_idle_time: MIT,
ids: &'a [ID],
options: StreamClaimOptions
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
C: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
ID: 'a + ToRedisArgs + Send + Sync,
MIT: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
group: G,
consumer: C,
min_idle_time: MIT,
ids: &'a [ID],
options: StreamClaimOptions
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
C: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
ID: 'a + ToRedisArgs + Send + Sync,
MIT: 'a + ToRedisArgs + Send + Sync,
pub fn xdel<'a, K, ID, RV>(
&'a mut self,
key: K,
ids: &'a [ID]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
ID: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
ids: &'a [ID]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
ID: 'a + ToRedisArgs + Send + Sync,
pub fn xgroup_create<'a, K, G, ID, RV>(
&'a mut self,
key: K,
group: G,
id: ID
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
ID: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
group: G,
id: ID
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
ID: 'a + ToRedisArgs + Send + Sync,
pub fn xgroup_create_mkstream<'a, K, G, ID, RV>(
&'a mut self,
key: K,
group: G,
id: ID
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
ID: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
group: G,
id: ID
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
ID: 'a + ToRedisArgs + Send + Sync,
pub fn xgroup_setid<'a, K, G, ID, RV>(
&'a mut self,
key: K,
group: G,
id: ID
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
ID: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
group: G,
id: ID
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
ID: 'a + ToRedisArgs + Send + Sync,
pub fn xgroup_destroy<'a, K, G, RV>(
&'a mut self,
key: K,
group: G
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
group: G
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn xgroup_delconsumer<'a, K, G, C, RV>(
&'a mut self,
key: K,
group: G,
consumer: C
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
C: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
group: G,
consumer: C
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
C: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn xinfo_consumers<'a, K, G, RV>(
&'a mut self,
key: K,
group: G
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
group: G
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn xinfo_groups<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn xinfo_stream<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn xlen<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn xpending<'a, K, G, RV>(
&'a mut self,
key: K,
group: G
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
group: G
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn xpending_count<'a, K, G, S, E, C, RV>(
&'a mut self,
key: K,
group: G,
start: S,
end: E,
count: C
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
C: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
E: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
group: G,
start: S,
end: E,
count: C
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
C: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
E: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn xpending_consumer_count<'a, K, G, S, E, C, CN, RV>(
&'a mut self,
key: K,
group: G,
start: S,
end: E,
count: C,
consumer: CN
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
C: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
E: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
CN: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
group: G,
start: S,
end: E,
count: C,
consumer: CN
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
C: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
E: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
CN: 'a + ToRedisArgs + Send + Sync,
pub fn xrange<'a, K, S, E, RV>(
&'a mut self,
key: K,
start: S,
end: E
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
E: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
start: S,
end: E
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
E: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn xrange_all<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn xrange_count<'a, K, S, E, C, RV>(
&'a mut self,
key: K,
start: S,
end: E,
count: C
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
C: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
E: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
start: S,
end: E,
count: C
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
C: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
E: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn xread<'a, K, ID, RV>(
&'a mut self,
keys: &'a [K],
ids: &'a [ID]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
ID: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
keys: &'a [K],
ids: &'a [ID]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
ID: 'a + ToRedisArgs + Send + Sync,
pub fn xread_options<'a, K, ID, RV>(
&'a mut self,
keys: &'a [K],
ids: &'a [ID],
options: StreamReadOptions
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
ID: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
keys: &'a [K],
ids: &'a [ID],
options: StreamReadOptions
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
ID: 'a + ToRedisArgs + Send + Sync,
pub fn xrevrange<'a, K, E, S, RV>(
&'a mut self,
key: K,
end: E,
start: S
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
E: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
end: E,
start: S
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
E: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn xrevrange_all<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn xrevrange_count<'a, K, E, S, C, RV>(
&'a mut self,
key: K,
end: E,
start: S,
count: C
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
C: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
E: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
end: E,
start: S,
count: C
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
C: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
E: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn xtrim<'a, K, RV>(
&'a mut self,
key: K,
maxlen: StreamMaxlen
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
maxlen: StreamMaxlen
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
pub fn scan<RV>(
&mut self
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where
RV: FromRedisValue,
[src]
&mut self
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where
RV: FromRedisValue,
pub fn scan_match<P, RV>(
&mut self,
pattern: P
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where
P: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
pattern: P
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where
P: ToRedisArgs,
RV: FromRedisValue,
pub fn hscan<K, RV>(
&mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where
K: ToRedisArgs,
RV: FromRedisValue,
pub fn hscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
pattern: P
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
pub fn sscan<K, RV>(
&mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where
K: ToRedisArgs,
RV: FromRedisValue,
pub fn sscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
pattern: P
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
pub fn zscan<K, RV>(
&mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where
K: ToRedisArgs,
RV: FromRedisValue,
pub fn zscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
pattern: P
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,