[−][src]Struct reool::RedisPool
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]
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]
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,
fn get<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn keys<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn set<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
fn set_multiple<'a, K, V, RV>(
&'a mut self,
items: &'a [(K, V)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
items: &'a [(K, V)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
value: V,
seconds: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
value: V,
milliseconds: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
fn set_nx<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
fn mset_nx<'a, K, V, RV>(
&'a mut self,
items: &'a [(K, V)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
items: &'a [(K, V)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
fn getset<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
fn getrange<'a, K, RV>(
&'a mut self,
key: K,
from: isize,
to: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
offset: isize,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
fn del<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn exists<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn expire<'a, K, RV>(
&'a mut self,
key: K,
seconds: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn expire_at<'a, K, RV>(
&'a mut self,
key: K,
ts: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn pexpire<'a, K, RV>(
&'a mut self,
key: K,
ms: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn pexpire_at<'a, K, RV>(
&'a mut self,
key: K,
ts: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn persist<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn ttl<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn pttl<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn rename<'a, K, RV>(
&'a mut self,
key: K,
new_key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn rename_nx<'a, K, RV>(
&'a mut self,
key: K,
new_key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn append<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
fn incr<'a, K, V, RV>(
&'a mut self,
key: K,
delta: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
delta: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
fn setbit<'a, K, RV>(
&'a mut self,
key: K,
offset: usize,
value: bool
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn getbit<'a, K, RV>(
&'a mut self,
key: K,
offset: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn bitcount<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn bit_and<'a, K, RV>(
&'a mut self,
dstkey: K,
srckeys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn bit_or<'a, K, RV>(
&'a mut self,
dstkey: K,
srckeys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn bit_xor<'a, K, RV>(
&'a mut self,
dstkey: K,
srckeys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn bit_not<'a, K, RV>(
&'a mut self,
dstkey: K,
srckey: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn strlen<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn hget<'a, K, F, RV>(
&'a mut self,
key: K,
field: F
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
F: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn hdel<'a, K, F, RV>(
&'a mut self,
key: K,
field: F
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
F: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> where
F: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
field: F,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
F: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
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>> where
F: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
field: F,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
F: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
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>> where
F: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
items: &'a [(F, V)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
F: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
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>> where
D: 'a + ToRedisArgs + Send + Sync,
F: 'a + ToRedisArgs + Send + Sync,
K: '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>> where
D: 'a + ToRedisArgs + Send + Sync,
F: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn hexists<'a, K, F, RV>(
&'a mut self,
key: K,
field: F
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
F: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn hkeys<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn hvals<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn hgetall<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn hlen<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn blpop<'a, K, RV>(
&'a mut self,
key: K,
timeout: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn brpop<'a, K, RV>(
&'a mut self,
key: K,
timeout: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn brpoplpush<'a, K, RV>(
&'a mut self,
srckey: K,
dstkey: K,
timeout: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn lindex<'a, K, RV>(
&'a mut self,
key: K,
index: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> where
K: 'a + ToRedisArgs + Send + Sync,
P: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
pivot: P,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
P: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
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>> where
K: 'a + ToRedisArgs + Send + Sync,
P: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
pivot: P,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
P: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
fn llen<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn lpop<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn lpush<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
fn lpush_exists<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
fn lrange<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
count: isize,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
fn ltrim<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
index: isize,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
fn rpop<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn rpoplpush<'a, K, RV>(
&'a mut self,
key: K,
dstkey: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn rpush<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
fn rpush_exists<'a, K, V, RV>(
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
value: V
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
fn sadd<'a, K, M, RV>(
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn scard<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn sdiff<'a, K, RV>(
&'a mut self,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn sdiffstore<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn sinter<'a, K, RV>(
&'a mut self,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn sinterstore<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn sismember<'a, K, M, RV>(
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn smembers<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
srckey: K,
dstkey: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn spop<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn srandmember<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn srandmember_multiple<'a, K, RV>(
&'a mut self,
key: K,
count: usize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn srem<'a, K, M, RV>(
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn sunion<'a, K, RV>(
&'a mut self,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn sunionstore<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
S: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
member: M,
score: S
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
S: 'a + ToRedisArgs + Send + Sync,
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>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
S: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
items: &'a [(S, M)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
S: 'a + ToRedisArgs + Send + Sync,
fn zcard<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> where
D: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
member: M,
delta: D
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
D: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zinterstore<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zinterstore_min<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zinterstore_max<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
L: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zpopmax<'a, K, RV>(
&'a mut self,
key: K,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zpopmin<'a, K, RV>(
&'a mut self,
key: K,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zrange<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
max: MM,
min: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zrank<'a, K, M, RV>(
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zrem<'a, K, M, RV>(
&'a mut self,
key: K,
members: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
members: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zremrangebyrank<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
min: M,
max: MM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zrevrange<'a, K, RV>(
&'a mut self,
key: K,
start: isize,
stop: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
max: MM,
min: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
max: MM,
min: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
MM: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zrevrank<'a, K, M, RV>(
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zscore<'a, K, M, RV>(
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
member: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zunionstore<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zunionstore_min<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn zunionstore_max<'a, K, RV>(
&'a mut self,
dstkey: K,
keys: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn pfadd<'a, K, E, RV>(
&'a mut self,
key: K,
element: E
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
E: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn pfcount<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn pfmerge<'a, K, RV>(
&'a mut self,
dstkey: K,
srckeys: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn publish<'a, K, E, RV>(
&'a mut self,
channel: K,
message: E
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
E: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn acl_load<RV>(
&'a mut self
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
RV: FromRedisValue,
[src]
&'a mut self
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
RV: FromRedisValue,
fn acl_save<RV>(
&'a mut self
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
RV: FromRedisValue,
[src]
&'a mut self
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
RV: FromRedisValue,
fn acl_list<RV>(
&'a mut self
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
RV: FromRedisValue,
[src]
&'a mut self
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
RV: FromRedisValue,
fn acl_users<RV>(
&'a mut self
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
RV: FromRedisValue,
[src]
&'a mut self
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
RV: FromRedisValue,
fn acl_getuser<'a, K, RV>(
&'a mut self,
username: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
username: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn acl_setuser<'a, K, RV>(
&'a mut self,
username: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
username: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn acl_deluser<'a, K, RV>(
&'a mut self,
usernames: &'a [K]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn acl_cat<RV>(
&'a mut self
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
RV: FromRedisValue,
[src]
&'a mut self
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
RV: FromRedisValue,
fn acl_cat_categoryname<'a, K, RV>(
&'a mut self,
categoryname: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
categoryname: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn acl_genpass<RV>(
&'a mut self
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
RV: FromRedisValue,
[src]
&'a mut self
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
RV: FromRedisValue,
fn acl_genpass_bits<RV>(
&'a mut self,
bits: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
RV: FromRedisValue,
[src]
&'a mut self,
bits: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
RV: FromRedisValue,
fn acl_whoami<RV>(
&'a mut self
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
RV: FromRedisValue,
[src]
&'a mut self
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
RV: FromRedisValue,
fn acl_log<RV>(
&'a mut self,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
RV: FromRedisValue,
[src]
&'a mut self,
count: isize
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
RV: FromRedisValue,
fn acl_log_reset<RV>(
&'a mut self
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
RV: FromRedisValue,
[src]
&'a mut self
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
RV: FromRedisValue,
fn acl_help<RV>(
&'a mut self
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
RV: FromRedisValue,
[src]
&'a mut self
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
RV: FromRedisValue,
fn geo_add<'a, K, M, RV>(
&'a mut self,
key: K,
members: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
members: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> where
K: 'a + ToRedisArgs + Send + Sync,
M1: 'a + ToRedisArgs + Send + Sync,
M2: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
member1: M1,
member2: M2,
unit: Unit
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M1: 'a + ToRedisArgs + Send + Sync,
M2: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn geo_hash<'a, K, M, RV>(
&'a mut self,
key: K,
members: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
members: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn geo_pos<'a, K, M, RV>(
&'a mut self,
key: K,
members: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
members: M
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
member: M,
radius: f64,
unit: Unit,
options: RadiusOptions
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
M: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> where
G: 'a + ToRedisArgs + Send + Sync,
I: '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>> where
G: 'a + ToRedisArgs + Send + Sync,
I: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> where
F: 'a + ToRedisArgs + Send + Sync,
ID: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
id: ID,
items: &'a [(F, V)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
F: 'a + ToRedisArgs + Send + Sync,
ID: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
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>> where
BTM: 'a + ToRedisArgs + Send + Sync,
ID: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
id: ID,
map: BTM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
BTM: 'a + ToRedisArgs + Send + Sync,
ID: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> where
F: 'a + ToRedisArgs + Send + Sync,
ID: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
maxlen: StreamMaxlen,
id: ID,
items: &'a [(F, V)]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
F: 'a + ToRedisArgs + Send + Sync,
ID: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
V: 'a + ToRedisArgs + Send + Sync,
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>> where
BTM: 'a + ToRedisArgs + Send + Sync,
ID: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K,
maxlen: StreamMaxlen,
id: ID,
map: BTM
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
BTM: 'a + ToRedisArgs + Send + Sync,
ID: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> where
C: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
ID: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
MIT: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[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>> where
C: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
ID: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
MIT: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> where
C: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
ID: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
MIT: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[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>> where
C: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
ID: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
MIT: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn xdel<'a, K, ID, RV>(
&'a mut self,
key: K,
ids: &'a [ID]
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
ID: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> where
G: 'a + ToRedisArgs + Send + Sync,
ID: '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>> where
G: 'a + ToRedisArgs + Send + Sync,
ID: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> where
G: 'a + ToRedisArgs + Send + Sync,
ID: '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>> where
G: 'a + ToRedisArgs + Send + Sync,
ID: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> where
G: 'a + ToRedisArgs + Send + Sync,
ID: '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>> where
G: 'a + ToRedisArgs + Send + Sync,
ID: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn xgroup_destroy<'a, K, G, RV>(
&'a mut self,
key: K,
group: G
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
G: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> 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>> where
C: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn xinfo_consumers<'a, K, G, RV>(
&'a mut self,
key: K,
group: G
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
G: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn xinfo_groups<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn xinfo_stream<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn xlen<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn xpending<'a, K, G, RV>(
&'a mut self,
key: K,
group: G
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
G: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> where
C: 'a + ToRedisArgs + Send + Sync,
E: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
S: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
group: G,
start: S,
end: E,
count: C
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
C: 'a + ToRedisArgs + Send + Sync,
E: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
S: 'a + ToRedisArgs + Send + Sync,
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>> where
C: 'a + ToRedisArgs + Send + Sync,
CN: 'a + ToRedisArgs + Send + Sync,
E: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
S: '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>> where
C: 'a + ToRedisArgs + Send + Sync,
CN: 'a + ToRedisArgs + Send + Sync,
E: 'a + ToRedisArgs + Send + Sync,
G: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
S: 'a + ToRedisArgs + Send + Sync,
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>> where
E: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
S: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
start: S,
end: E
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
E: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
S: 'a + ToRedisArgs + Send + Sync,
fn xrange_all<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> where
C: 'a + ToRedisArgs + Send + Sync,
E: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
S: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
start: S,
end: E,
count: C
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
C: 'a + ToRedisArgs + Send + Sync,
E: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
S: 'a + ToRedisArgs + Send + Sync,
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>> 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>> where
ID: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> 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>> where
ID: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> where
E: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
S: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
end: E,
start: S
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
E: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
S: 'a + ToRedisArgs + Send + Sync,
fn xrevrange_all<'a, K, RV>(
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
[src]
&'a mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
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>> where
C: 'a + ToRedisArgs + Send + Sync,
E: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
S: 'a + ToRedisArgs + Send + Sync,
[src]
&'a mut self,
key: K,
end: E,
start: S,
count: C
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> where
C: 'a + ToRedisArgs + Send + Sync,
E: 'a + ToRedisArgs + Send + Sync,
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
S: 'a + ToRedisArgs + Send + Sync,
fn xtrim<'a, K, RV>(
&'a mut self,
key: K,
maxlen: StreamMaxlen
) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send>> 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>> where
K: 'a + ToRedisArgs + Send + Sync,
RV: FromRedisValue,
fn scan<RV>(
&mut self
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<RV>, RedisError>> + Send>> where
RV: FromRedisValue,
[src]
&mut self
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<RV>, RedisError>> + Send>> where
RV: FromRedisValue,
fn scan_match<P, RV>(
&mut self,
pattern: P
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<RV>, RedisError>> + Send>> where
P: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
pattern: P
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<RV>, RedisError>> + Send>> where
P: ToRedisArgs,
RV: FromRedisValue,
fn hscan<K, RV>(
&mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<RV>, RedisError>> + Send>> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<RV>, RedisError>> + Send>> where
K: ToRedisArgs,
RV: FromRedisValue,
fn hscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<RV>, RedisError>> + Send>> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
pattern: P
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<RV>, RedisError>> + Send>> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
fn sscan<K, RV>(
&mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<RV>, RedisError>> + Send>> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<RV>, RedisError>> + Send>> where
K: ToRedisArgs,
RV: FromRedisValue,
fn sscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<RV>, RedisError>> + Send>> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
pattern: P
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<RV>, RedisError>> + Send>> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
fn zscan<K, RV>(
&mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<RV>, RedisError>> + Send>> where
K: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<RV>, RedisError>> + Send>> where
K: ToRedisArgs,
RV: FromRedisValue,
fn zscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<RV>, RedisError>> + Send>> where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
[src]
&mut self,
key: K,
pattern: P
) -> Pin<Box<dyn Future<Output = Result<AsyncIter<RV>, RedisError>> + Send>> where
K: ToRedisArgs,
P: 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,
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.
fn to_owned(&self) -> T
[src]
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.
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.
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>,