Struct reool::PoolConnection [−][src]
A connection that has been taken from the pool.
The connection returns when dropped unless there was an error.
Pooled connection implements redis::async::ConnectionLike
to easily integrate with code that already uses redis-rs
.
Implementations
impl<T: Poolable> PoolConnection<T>
[src]
pub fn default_command_timeout<TO: Into<DefaultCommandTimeout>>(
&mut self,
timeout: TO
)
[src]
&mut self,
timeout: TO
)
Trait Implementations
impl<T: Poolable> ConnectionLike for PoolConnection<T> where
T: ConnectionLike,
[src]
T: ConnectionLike,
fn req_packed_command<'a>(&'a mut self, cmd: &'a Cmd) -> RedisFuture<'a, Value>
[src]
fn req_packed_commands<'a>(
&'a mut self,
pipeline: &'a Pipeline,
offset: usize,
count: usize
) -> RedisFuture<'a, Vec<Value>>
[src]
&'a mut self,
pipeline: &'a Pipeline,
offset: usize,
count: usize
) -> RedisFuture<'a, Vec<Value>>
fn get_db(&self) -> i64
[src]
impl<T: Poolable> Drop for PoolConnection<T>
[src]
Auto Trait Implementations
impl<T = ConnectionFlavour> !RefUnwindSafe for PoolConnection<T>
impl<T> Send for PoolConnection<T>
impl<T> Sync for PoolConnection<T> where
T: Sync,
T: Sync,
impl<T> Unpin for PoolConnection<T> where
T: Unpin,
T: Unpin,
impl<T = ConnectionFlavour> !UnwindSafe for PoolConnection<T>
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> AsyncCommands for T where
T: ConnectionLike + Send,
[src]
T: ConnectionLike + Send,
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
F: 'a + ToRedisArgs + Send + Sync,
K: '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
F: 'a + ToRedisArgs + Send + Sync,
K: '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
F: 'a + ToRedisArgs + Send + Sync,
K: '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
F: 'a + ToRedisArgs + Send + Sync,
K: '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
F: 'a + ToRedisArgs + Send + Sync,
K: '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
F: 'a + ToRedisArgs + Send + Sync,
K: '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
F: 'a + ToRedisArgs + Send + Sync,
K: '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
F: 'a + ToRedisArgs + Send + Sync,
K: '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
F: 'a + ToRedisArgs + Send + Sync,
K: '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
F: 'a + ToRedisArgs + Send + Sync,
K: '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
F: 'a + ToRedisArgs + Send + Sync,
K: '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
F: 'a + ToRedisArgs + Send + Sync,
K: '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
F: 'a + ToRedisArgs + Send + Sync,
K: '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
F: 'a + ToRedisArgs + Send + Sync,
K: '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
P: 'a + ToRedisArgs + Send + Sync,
K: '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
P: 'a + ToRedisArgs + Send + Sync,
K: '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
P: 'a + ToRedisArgs + Send + Sync,
K: '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
P: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
D: '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
M: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
D: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
E: 'a + ToRedisArgs + Send + Sync,
K: '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
E: 'a + ToRedisArgs + Send + Sync,
K: '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
E: 'a + ToRedisArgs + Send + Sync,
K: '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
E: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
M: 'a + ToRedisArgs + Send + Sync,
K: '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
I: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
K: '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
I: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
K: '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
F: 'a + ToRedisArgs + Send + Sync,
ID: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
id: ID,
items: &'a [(F, V)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
F: 'a + ToRedisArgs + Send + Sync,
ID: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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
ID: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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
ID: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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
F: 'a + ToRedisArgs + Send + Sync,
ID: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[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
F: 'a + ToRedisArgs + Send + Sync,
ID: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
V: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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
ID: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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
ID: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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,
ID: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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,
ID: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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,
ID: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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,
ID: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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
ID: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
ids: &'a [ID]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
ID: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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
ID: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
group: G,
id: ID
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
ID: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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
ID: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
group: G,
id: ID
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
ID: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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
ID: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
group: G,
id: ID
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
ID: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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
G: 'a + ToRedisArgs + Send + Sync,
K: '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
G: 'a + ToRedisArgs + Send + Sync,
K: '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,
G: 'a + ToRedisArgs + Send + Sync,
K: '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,
G: 'a + ToRedisArgs + Send + Sync,
K: '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
G: 'a + ToRedisArgs + Send + Sync,
K: '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
G: 'a + ToRedisArgs + Send + Sync,
K: '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
G: 'a + ToRedisArgs + Send + Sync,
K: '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
G: 'a + ToRedisArgs + Send + Sync,
K: '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,
E: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
K: '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,
E: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
K: '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,
E: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
K: '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,
E: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
K: '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
E: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
K: '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
E: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
K: '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,
E: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
K: '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,
E: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
K: '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
ID: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
keys: &'a [K],
ids: &'a [ID]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
ID: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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
ID: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
keys: &'a [K],
ids: &'a [ID],
options: StreamReadOptions
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where
ID: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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
E: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
K: '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
E: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
K: '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,
E: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
K: '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,
E: 'a + ToRedisArgs + Send + Sync,
S: 'a + ToRedisArgs + Send + Sync,
K: '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
P: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
pattern: P
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where
P: ToRedisArgs,
K: 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
P: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
pattern: P
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where
P: ToRedisArgs,
K: 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
P: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
pattern: P
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where
P: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
V: MultiLane<T>,