[−][src]Enum reool::ConnectionFlavour
Variants
RedisRs(Connection, Arc<String>)
Trait Implementations
impl ConnectionLike for ConnectionFlavour
[src]
fn req_packed_command<'a>(&'a mut self, cmd: &'a Cmd) -> RedisFuture<'a, Value>
[src]
fn req_packed_commands<'a>(
&'a mut self,
pipeline: &'a Pipeline,
offset: usize,
count: usize
) -> RedisFuture<'a, Vec<Value>>
[src]
&'a mut self,
pipeline: &'a Pipeline,
offset: usize,
count: usize
) -> RedisFuture<'a, Vec<Value>>
fn get_db(&self) -> i64
[src]
impl Poolable for ConnectionFlavour
[src]
fn connected_to(&self) -> &str
[src]
Auto Trait Implementations
impl !RefUnwindSafe for ConnectionFlavour
impl Send for ConnectionFlavour
impl !Sync for ConnectionFlavour
impl Unpin for ConnectionFlavour
impl !UnwindSafe for ConnectionFlavour
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> AsyncCommands for T where
T: ConnectionLike + Send + ?Sized,
[src]
T: ConnectionLike + Send + ?Sized,
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 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 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,
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, 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>,