Struct reool::RedisPool [−][src]
A pool to one or more Redis instances.
This is the core type of this library.
Overview
Each RedisPool
consist of one or more sub pools whereas each sub pool is only
ever connected to one Redis node.
So the number of sub pools is usually the number of nodes to connect to. Furthermore the number of sub pools can be increased via the configuration.
Reool
uses a stream to enqueue checkouts. Furthermore the number of buffered checkout
requests is always limited. Having multiple sub pools will increase the number of
checkout requests that can be enqueued.
When having more that one sub pool Reool
will retry checkout attempts on different
sub pools.
ConnectionLike
The pool itself implements ConnectionLike
. This is a convinience functionality
for executing a single redis command. The checkout will be done with the DefaultCheckoutMode
defined for the pool. Furthermore ConnectionLike::get_db
will always return -1.
Implementations
impl RedisPool
[src]
impl<T: Poolable> RedisPool<T>
[src]
pub fn no_pool() -> Self
[src]
pub fn check_out_default<'a>(
&'a self
) -> impl Future<Output = Result<PoolConnection<T>, CheckoutError>> + 'a
[src]
&'a self
) -> impl Future<Output = Result<PoolConnection<T>, CheckoutError>> + 'a
Checkout a new connection and if the request has to be enqueued use a timeout as defined by the pool as a default.
pub async fn check_out<M: Into<CheckoutMode>>(
&self,
mode: M
) -> Result<PoolConnection<T>, CheckoutError>
[src]
&self,
mode: M
) -> Result<PoolConnection<T>, CheckoutError>
Checkout a new connection and choose whether to wait for a connection or not
as defined by the CheckoutMode
.
pub fn default_command_timeout<TO: Into<DefaultCommandTimeout>>(
&self,
default_command_timeout: TO
) -> Self
[src]
&self,
default_command_timeout: TO
) -> Self
Creates a clone with the given default command timeout.
This creates a new instance since mutating this might go unnoticed as callers which pass the pool as a mutable reference would not expect this value to be changed by downstream code as passing this mutably is mostly for the purpose of directly executing Redis commands.
pub fn connected_to(&self) -> Vec<String>
[src]
pub fn state(&self) -> PoolState
[src]
pub fn ping_nodes<TO: Into<Timeout>>(
&self,
timeout: TO
) -> BoxFuture<'_, Vec<Ping>>
[src]
&self,
timeout: TO
) -> BoxFuture<'_, Vec<Ping>>
Ping all the nodes which this pool is connected to.
timeout
is the maximum time allowed for a ping.
This method only fails with ()
if the underlying connection
does not support pinging. All other errors will be contained
in the returned Ping
struct.
Trait Implementations
impl<T: Poolable> Clone for RedisPool<T>
[src]
fn clone(&self) -> Self
[src]
pub fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl ConnectionLike for RedisPool
[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]
Auto Trait Implementations
impl<T = ConnectionFlavour> !RefUnwindSafe for RedisPool<T>
impl<T> Send for RedisPool<T>
impl<T> Sync for RedisPool<T>
impl<T> Unpin for RedisPool<T>
impl<T = ConnectionFlavour> !UnwindSafe for RedisPool<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> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
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>,