struct PeekMutGuard<'a, T: Ord> {
peek: Option<PeekMut<'a, T>>,
unused: &'a mut LinkedList<T>,
}
Expand description
This is a wrapper for the PeekMut
of heap.
Several panics due to future cancellation are caused by calling drop
on the PeekMut
when
futures holding the PeekMut
are cancelled and dropped. Dropping a PeekMut
will accidentally
cause a comparison between the top node and the node below, and may call key()
for top node
iterators that are in some intermediate inconsistent states.
When a PeekMut
is wrapped by this guard, when the guard is dropped, PeekMut::pop
will be
called on the PeekMut
, and the popped node will be added to the linked list that collects the
unused nodes. In this way, when the future holding the guard is dropped, the PeekMut
will not
be called drop
, and there will not be unexpected key()
called for heap comparison.
In normal usage, when we finished using the PeekMut
, we should explicitly call guard.used()
in every branch carefully. When we want to pop the PeekMut
, we can simply call guard.pop()
.
Fields§
§peek: Option<PeekMut<'a, T>>
§unused: &'a mut LinkedList<T>
Implementations§
Source§impl<'a, T: Ord> PeekMutGuard<'a, T>
impl<'a, T: Ord> PeekMutGuard<'a, T>
Sourcefn peek_mut(
heap: &'a mut BinaryHeap<T>,
unused: &'a mut LinkedList<T>,
) -> Option<Self>
fn peek_mut( heap: &'a mut BinaryHeap<T>, unused: &'a mut LinkedList<T>, ) -> Option<Self>
Call peek_mut
on the top of heap and return a guard over the PeekMut
if the heap is not
empty.
Trait Implementations§
Source§impl<T: Ord> Deref for PeekMutGuard<'_, T>
impl<T: Ord> Deref for PeekMutGuard<'_, T>
Source§impl<T: Ord> DerefMut for PeekMutGuard<'_, T>
impl<T: Ord> DerefMut for PeekMutGuard<'_, T>
Auto Trait Implementations§
impl<'a, T> Freeze for PeekMutGuard<'a, T>
impl<'a, T> RefUnwindSafe for PeekMutGuard<'a, T>where
T: RefUnwindSafe,
impl<'a, T> Send for PeekMutGuard<'a, T>where
T: Send,
impl<'a, T> Sync for PeekMutGuard<'a, T>where
T: Sync,
impl<'a, T> Unpin for PeekMutGuard<'a, T>
impl<'a, T> !UnwindSafe for PeekMutGuard<'a, T>
Blanket Implementations§
§impl<T, A, P> Access<T> for P
impl<T, A, P> Access<T> for P
§impl<T> AsAny for T
impl<T> AsAny for T
§fn any_ref(&self) -> &(dyn Any + Send + Sync + 'static)
fn any_ref(&self) -> &(dyn Any + Send + Sync + 'static)
dyn Any
reference to the object: Read more§fn as_any(self: Arc<T>) -> Arc<dyn Any + Send + Sync>
fn as_any(self: Arc<T>) -> Arc<dyn Any + Send + Sync>
Arc<dyn Any>
reference to the object: Read more§fn into_any(self: Box<T>) -> Box<dyn Any + Send + Sync>
fn into_any(self: Box<T>) -> Box<dyn Any + Send + Sync>
Box<dyn Any>
: Read more§fn type_name(&self) -> &'static str
fn type_name(&self) -> &'static str
std::any::type_name
, since Any
does not provide it and
Any::type_id
is useless as a debugging aid (its Debug
is just a mess of hex digits).Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
§impl<T> Commands for Twhere
T: ConnectionLike,
impl<T> Commands for Twhere
T: ConnectionLike,
§fn get<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn get<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
MGET
.§fn mget<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn mget<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn keys<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn keys<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn set<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
fn set<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
§fn set_options<'a, K, V, RV>(
&mut self,
key: K,
value: V,
options: SetOptions,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
fn set_options<'a, K, V, RV>(
&mut self,
key: K,
value: V,
options: SetOptions,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
§fn set_multiple<'a, K, V, RV>(
&mut self,
items: &'a [(K, V)],
) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
fn set_multiple<'a, K, V, RV>(
&mut self,
items: &'a [(K, V)],
) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
§fn mset<'a, K, V, RV>(&mut self, items: &'a [(K, V)]) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
fn mset<'a, K, V, RV>(&mut self, items: &'a [(K, V)]) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
§fn set_ex<'a, K, V, RV>(
&mut self,
key: K,
value: V,
seconds: u64,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
fn set_ex<'a, K, V, RV>(
&mut self,
key: K,
value: V,
seconds: u64,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
§fn pset_ex<'a, K, V, RV>(
&mut self,
key: K,
value: V,
milliseconds: u64,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
fn pset_ex<'a, K, V, RV>(
&mut self,
key: K,
value: V,
milliseconds: u64,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
§fn set_nx<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
fn set_nx<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
§fn mset_nx<'a, K, V, RV>(
&mut self,
items: &'a [(K, V)],
) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
fn mset_nx<'a, K, V, RV>(
&mut self,
items: &'a [(K, V)],
) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
§fn getset<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
fn getset<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
§fn getrange<'a, K, RV>(
&mut self,
key: K,
from: isize,
to: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn getrange<'a, K, RV>(
&mut self,
key: K,
from: isize,
to: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn setrange<'a, K, V, RV>(
&mut self,
key: K,
offset: isize,
value: V,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
fn setrange<'a, K, V, RV>(
&mut self,
key: K,
offset: isize,
value: V,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
§fn del<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn del<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn exists<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn exists<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn key_type<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn key_type<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn expire<'a, K, RV>(&mut self, key: K, seconds: i64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn expire<'a, K, RV>(&mut self, key: K, seconds: i64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn expire_at<'a, K, RV>(&mut self, key: K, ts: i64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn expire_at<'a, K, RV>(&mut self, key: K, ts: i64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn pexpire<'a, K, RV>(&mut self, key: K, ms: i64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn pexpire<'a, K, RV>(&mut self, key: K, ms: i64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn pexpire_at<'a, K, RV>(&mut self, key: K, ts: i64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn pexpire_at<'a, K, RV>(&mut self, key: K, ts: i64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn expire_time<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn expire_time<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn pexpire_time<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn pexpire_time<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn persist<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn persist<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn ttl<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn ttl<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn pttl<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn pttl<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn get_ex<'a, K, RV>(
&mut self,
key: K,
expire_at: Expiry,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn get_ex<'a, K, RV>(
&mut self,
key: K,
expire_at: Expiry,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn get_del<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn get_del<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn rename<'a, K, N, RV>(&mut self, key: K, new_key: N) -> Result<RV, RedisError>where
K: ToRedisArgs,
N: ToRedisArgs,
RV: FromRedisValue,
fn rename<'a, K, N, RV>(&mut self, key: K, new_key: N) -> Result<RV, RedisError>where
K: ToRedisArgs,
N: ToRedisArgs,
RV: FromRedisValue,
§fn rename_nx<'a, K, N, RV>(
&mut self,
key: K,
new_key: N,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
N: ToRedisArgs,
RV: FromRedisValue,
fn rename_nx<'a, K, N, RV>(
&mut self,
key: K,
new_key: N,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
N: ToRedisArgs,
RV: FromRedisValue,
§fn unlink<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn unlink<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn append<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
fn append<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
§fn incr<'a, K, V, RV>(&mut self, key: K, delta: V) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
fn incr<'a, K, V, RV>(&mut self, key: K, delta: V) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
INCRBY
or INCRBYFLOAT
depending on the type.§fn decr<'a, K, V, RV>(&mut self, key: K, delta: V) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
fn decr<'a, K, V, RV>(&mut self, key: K, delta: V) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
§fn setbit<'a, K, RV>(
&mut self,
key: K,
offset: usize,
value: bool,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn setbit<'a, K, RV>(
&mut self,
key: K,
offset: usize,
value: bool,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn getbit<'a, K, RV>(&mut self, key: K, offset: usize) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn getbit<'a, K, RV>(&mut self, key: K, offset: usize) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn bitcount<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn bitcount<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn bitcount_range<'a, K, RV>(
&mut self,
key: K,
start: usize,
end: usize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn bitcount_range<'a, K, RV>(
&mut self,
key: K,
start: usize,
end: usize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn bit_and<'a, D, S, RV>(
&mut self,
dstkey: D,
srckeys: S,
) -> Result<RV, RedisError>where
D: ToRedisArgs,
S: ToRedisArgs,
RV: FromRedisValue,
fn bit_and<'a, D, S, RV>(
&mut self,
dstkey: D,
srckeys: S,
) -> Result<RV, RedisError>where
D: ToRedisArgs,
S: ToRedisArgs,
RV: FromRedisValue,
§fn bit_or<'a, D, S, RV>(
&mut self,
dstkey: D,
srckeys: S,
) -> Result<RV, RedisError>where
D: ToRedisArgs,
S: ToRedisArgs,
RV: FromRedisValue,
fn bit_or<'a, D, S, RV>(
&mut self,
dstkey: D,
srckeys: S,
) -> Result<RV, RedisError>where
D: ToRedisArgs,
S: ToRedisArgs,
RV: FromRedisValue,
§fn bit_xor<'a, D, S, RV>(
&mut self,
dstkey: D,
srckeys: S,
) -> Result<RV, RedisError>where
D: ToRedisArgs,
S: ToRedisArgs,
RV: FromRedisValue,
fn bit_xor<'a, D, S, RV>(
&mut self,
dstkey: D,
srckeys: S,
) -> Result<RV, RedisError>where
D: ToRedisArgs,
S: ToRedisArgs,
RV: FromRedisValue,
§fn bit_not<'a, D, S, RV>(
&mut self,
dstkey: D,
srckey: S,
) -> Result<RV, RedisError>where
D: ToRedisArgs,
S: ToRedisArgs,
RV: FromRedisValue,
fn bit_not<'a, D, S, RV>(
&mut self,
dstkey: D,
srckey: S,
) -> Result<RV, RedisError>where
D: ToRedisArgs,
S: ToRedisArgs,
RV: FromRedisValue,
§fn strlen<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn strlen<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn hget<'a, K, F, RV>(&mut self, key: K, field: F) -> Result<RV, RedisError>where
K: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
fn hget<'a, K, F, RV>(&mut self, key: K, field: F) -> Result<RV, RedisError>where
K: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
§fn hdel<'a, K, F, RV>(&mut self, key: K, field: F) -> Result<RV, RedisError>where
K: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
fn hdel<'a, K, F, RV>(&mut self, key: K, field: F) -> Result<RV, RedisError>where
K: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
§fn hset<'a, K, F, V, RV>(
&mut self,
key: K,
field: F,
value: V,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
F: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
fn hset<'a, K, F, V, RV>(
&mut self,
key: K,
field: F,
value: V,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
F: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
§fn hset_nx<'a, K, F, V, RV>(
&mut self,
key: K,
field: F,
value: V,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
F: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
fn hset_nx<'a, K, F, V, RV>(
&mut self,
key: K,
field: F,
value: V,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
F: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
§fn hset_multiple<'a, K, F, V, RV>(
&mut self,
key: K,
items: &'a [(F, V)],
) -> Result<RV, RedisError>where
K: ToRedisArgs,
F: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
fn hset_multiple<'a, K, F, V, RV>(
&mut self,
key: K,
items: &'a [(F, V)],
) -> Result<RV, RedisError>where
K: ToRedisArgs,
F: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
§fn hincr<'a, K, F, D, RV>(
&mut self,
key: K,
field: F,
delta: D,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
F: ToRedisArgs,
D: ToRedisArgs,
RV: FromRedisValue,
fn hincr<'a, K, F, D, RV>(
&mut self,
key: K,
field: F,
delta: D,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
F: ToRedisArgs,
D: ToRedisArgs,
RV: FromRedisValue,
§fn hexists<'a, K, F, RV>(&mut self, key: K, field: F) -> Result<RV, RedisError>where
K: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
fn hexists<'a, K, F, RV>(&mut self, key: K, field: F) -> Result<RV, RedisError>where
K: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
§fn httl<'a, K, F, RV>(&mut self, key: K, fields: F) -> Result<RV, RedisError>where
K: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
fn httl<'a, K, F, RV>(&mut self, key: K, fields: F) -> Result<RV, RedisError>where
K: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
§fn hpttl<'a, K, F, RV>(&mut self, key: K, fields: F) -> Result<RV, RedisError>where
K: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
fn hpttl<'a, K, F, RV>(&mut self, key: K, fields: F) -> Result<RV, RedisError>where
K: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
§fn hexpire<'a, K, F, RV>(
&mut self,
key: K,
seconds: i64,
opt: ExpireOption,
fields: F,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
fn hexpire<'a, K, F, RV>(
&mut self,
key: K,
seconds: i64,
opt: ExpireOption,
fields: F,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
§fn hexpire_at<'a, K, F, RV>(
&mut self,
key: K,
ts: i64,
opt: ExpireOption,
fields: F,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
fn hexpire_at<'a, K, F, RV>(
&mut self,
key: K,
ts: i64,
opt: ExpireOption,
fields: F,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
§fn hexpire_time<'a, K, F, RV>(
&mut self,
key: K,
fields: F,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
fn hexpire_time<'a, K, F, RV>(
&mut self,
key: K,
fields: F,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
§fn hpersist<'a, K, F, RV>(
&mut self,
key: K,
fields: F,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
fn hpersist<'a, K, F, RV>(
&mut self,
key: K,
fields: F,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
§fn hpexpire<'a, K, F, RV>(
&mut self,
key: K,
milliseconds: i64,
opt: ExpireOption,
fields: F,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
fn hpexpire<'a, K, F, RV>(
&mut self,
key: K,
milliseconds: i64,
opt: ExpireOption,
fields: F,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
§fn hpexpire_at<'a, K, F, RV>(
&mut self,
key: K,
ts: i64,
opt: ExpireOption,
fields: F,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
fn hpexpire_at<'a, K, F, RV>(
&mut self,
key: K,
ts: i64,
opt: ExpireOption,
fields: F,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
§fn hpexpire_time<'a, K, F, RV>(
&mut self,
key: K,
fields: F,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
fn hpexpire_time<'a, K, F, RV>(
&mut self,
key: K,
fields: F,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
F: ToRedisArgs,
RV: FromRedisValue,
§fn hkeys<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn hkeys<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn hvals<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn hvals<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn hgetall<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn hgetall<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn hlen<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn hlen<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn blmove<'a, S, D, RV>(
&mut self,
srckey: S,
dstkey: D,
src_dir: Direction,
dst_dir: Direction,
timeout: f64,
) -> Result<RV, RedisError>where
S: ToRedisArgs,
D: ToRedisArgs,
RV: FromRedisValue,
fn blmove<'a, S, D, RV>(
&mut self,
srckey: S,
dstkey: D,
src_dir: Direction,
dst_dir: Direction,
timeout: f64,
) -> Result<RV, RedisError>where
S: ToRedisArgs,
D: ToRedisArgs,
RV: FromRedisValue,
§fn blmpop<'a, K, RV>(
&mut self,
timeout: f64,
numkeys: usize,
key: K,
dir: Direction,
count: usize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn blmpop<'a, K, RV>(
&mut self,
timeout: f64,
numkeys: usize,
key: K,
dir: Direction,
count: usize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
count
elements from the first non-empty list key from the list of
provided key names; or blocks until one is available.§fn blpop<'a, K, RV>(&mut self, key: K, timeout: f64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn blpop<'a, K, RV>(&mut self, key: K, timeout: f64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn brpop<'a, K, RV>(&mut self, key: K, timeout: f64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn brpop<'a, K, RV>(&mut self, key: K, timeout: f64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn brpoplpush<'a, S, D, RV>(
&mut self,
srckey: S,
dstkey: D,
timeout: f64,
) -> Result<RV, RedisError>where
S: ToRedisArgs,
D: ToRedisArgs,
RV: FromRedisValue,
fn brpoplpush<'a, S, D, RV>(
&mut self,
srckey: S,
dstkey: D,
timeout: f64,
) -> Result<RV, RedisError>where
S: ToRedisArgs,
D: ToRedisArgs,
RV: FromRedisValue,
§fn lindex<'a, K, RV>(&mut self, key: K, index: isize) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn lindex<'a, K, RV>(&mut self, key: K, index: isize) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn linsert_before<'a, K, P, V, RV>(
&mut self,
key: K,
pivot: P,
value: V,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
P: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
fn linsert_before<'a, K, P, V, RV>(
&mut self,
key: K,
pivot: P,
value: V,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
P: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
§fn linsert_after<'a, K, P, V, RV>(
&mut self,
key: K,
pivot: P,
value: V,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
P: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
fn linsert_after<'a, K, P, V, RV>(
&mut self,
key: K,
pivot: P,
value: V,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
P: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
§fn llen<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn llen<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn lmove<'a, S, D, RV>(
&mut self,
srckey: S,
dstkey: D,
src_dir: Direction,
dst_dir: Direction,
) -> Result<RV, RedisError>where
S: ToRedisArgs,
D: ToRedisArgs,
RV: FromRedisValue,
fn lmove<'a, S, D, RV>(
&mut self,
srckey: S,
dstkey: D,
src_dir: Direction,
dst_dir: Direction,
) -> Result<RV, RedisError>where
S: ToRedisArgs,
D: ToRedisArgs,
RV: FromRedisValue,
§fn lmpop<'a, K, RV>(
&mut self,
numkeys: usize,
key: K,
dir: Direction,
count: usize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn lmpop<'a, K, RV>(
&mut self,
numkeys: usize,
key: K,
dir: Direction,
count: usize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
count
elements from the first non-empty list key from the list of
provided key names.§fn lpop<'a, K, RV>(
&mut self,
key: K,
count: Option<NonZero<usize>>,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn lpop<'a, K, RV>(
&mut self,
key: K,
count: Option<NonZero<usize>>,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
count
first elements of the list stored at key. Read more§fn lpos<'a, K, V, RV>(
&mut self,
key: K,
value: V,
options: LposOptions,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
fn lpos<'a, K, V, RV>(
&mut self,
key: K,
value: V,
options: LposOptions,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
§fn lpush<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
fn lpush<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
§fn lpush_exists<'a, K, V, RV>(
&mut self,
key: K,
value: V,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
fn lpush_exists<'a, K, V, RV>(
&mut self,
key: K,
value: V,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
§fn lrange<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn lrange<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn lrem<'a, K, V, RV>(
&mut self,
key: K,
count: isize,
value: V,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
fn lrem<'a, K, V, RV>(
&mut self,
key: K,
count: isize,
value: V,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
§fn ltrim<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn ltrim<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn lset<'a, K, V, RV>(
&mut self,
key: K,
index: isize,
value: V,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
fn lset<'a, K, V, RV>(
&mut self,
key: K,
index: isize,
value: V,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
§fn ping<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn ping<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
§fn ping_message<'a, K, RV>(&mut self, message: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn ping_message<'a, K, RV>(&mut self, message: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn rpop<'a, K, RV>(
&mut self,
key: K,
count: Option<NonZero<usize>>,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn rpop<'a, K, RV>(
&mut self,
key: K,
count: Option<NonZero<usize>>,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
count
last elements of the list stored at key Read more§fn rpoplpush<'a, K, D, RV>(
&mut self,
key: K,
dstkey: D,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
D: ToRedisArgs,
RV: FromRedisValue,
fn rpoplpush<'a, K, D, RV>(
&mut self,
key: K,
dstkey: D,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
D: ToRedisArgs,
RV: FromRedisValue,
§fn rpush<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
fn rpush<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
§fn rpush_exists<'a, K, V, RV>(
&mut self,
key: K,
value: V,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
fn rpush_exists<'a, K, V, RV>(
&mut self,
key: K,
value: V,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
§fn sadd<'a, K, M, RV>(&mut self, key: K, member: M) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn sadd<'a, K, M, RV>(&mut self, key: K, member: M) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
§fn scard<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn scard<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn sdiff<'a, K, RV>(&mut self, keys: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn sdiff<'a, K, RV>(&mut self, keys: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn sdiffstore<'a, D, K, RV>(
&mut self,
dstkey: D,
keys: K,
) -> Result<RV, RedisError>where
D: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
fn sdiffstore<'a, D, K, RV>(
&mut self,
dstkey: D,
keys: K,
) -> Result<RV, RedisError>where
D: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
§fn sinter<'a, K, RV>(&mut self, keys: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn sinter<'a, K, RV>(&mut self, keys: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn sinterstore<'a, D, K, RV>(
&mut self,
dstkey: D,
keys: K,
) -> Result<RV, RedisError>where
D: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
fn sinterstore<'a, D, K, RV>(
&mut self,
dstkey: D,
keys: K,
) -> Result<RV, RedisError>where
D: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
§fn sismember<'a, K, M, RV>(
&mut self,
key: K,
member: M,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn sismember<'a, K, M, RV>(
&mut self,
key: K,
member: M,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
§fn smismember<'a, K, M, RV>(
&mut self,
key: K,
members: M,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn smismember<'a, K, M, RV>(
&mut self,
key: K,
members: M,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
§fn smembers<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn smembers<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn smove<'a, S, D, M, RV>(
&mut self,
srckey: S,
dstkey: D,
member: M,
) -> Result<RV, RedisError>where
S: ToRedisArgs,
D: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn smove<'a, S, D, M, RV>(
&mut self,
srckey: S,
dstkey: D,
member: M,
) -> Result<RV, RedisError>where
S: ToRedisArgs,
D: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
§fn spop<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn spop<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn srandmember<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn srandmember<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn srandmember_multiple<'a, K, RV>(
&mut self,
key: K,
count: usize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn srandmember_multiple<'a, K, RV>(
&mut self,
key: K,
count: usize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn srem<'a, K, M, RV>(&mut self, key: K, member: M) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn srem<'a, K, M, RV>(&mut self, key: K, member: M) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
§fn sunion<'a, K, RV>(&mut self, keys: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn sunion<'a, K, RV>(&mut self, keys: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn sunionstore<'a, D, K, RV>(
&mut self,
dstkey: D,
keys: K,
) -> Result<RV, RedisError>where
D: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
fn sunionstore<'a, D, K, RV>(
&mut self,
dstkey: D,
keys: K,
) -> Result<RV, RedisError>where
D: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
§fn zadd<'a, K, S, M, RV>(
&mut self,
key: K,
member: M,
score: S,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
S: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn zadd<'a, K, S, M, RV>(
&mut self,
key: K,
member: M,
score: S,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
S: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
§fn zadd_multiple<'a, K, S, M, RV>(
&mut self,
key: K,
items: &'a [(S, M)],
) -> Result<RV, RedisError>where
K: ToRedisArgs,
S: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn zadd_multiple<'a, K, S, M, RV>(
&mut self,
key: K,
items: &'a [(S, M)],
) -> Result<RV, RedisError>where
K: ToRedisArgs,
S: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
§fn zcard<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zcard<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn zcount<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zcount<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
§fn zincr<'a, K, M, D, RV>(
&mut self,
key: K,
member: M,
delta: D,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
D: ToRedisArgs,
RV: FromRedisValue,
fn zincr<'a, K, M, D, RV>(
&mut self,
key: K,
member: M,
delta: D,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
D: ToRedisArgs,
RV: FromRedisValue,
§fn zinterstore<'a, D, K, RV>(
&mut self,
dstkey: D,
keys: K,
) -> Result<RV, RedisError>where
D: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
fn zinterstore<'a, D, K, RV>(
&mut self,
dstkey: D,
keys: K,
) -> Result<RV, RedisError>where
D: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
§fn zinterstore_min<'a, D, K, RV>(
&mut self,
dstkey: D,
keys: K,
) -> Result<RV, RedisError>where
D: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
fn zinterstore_min<'a, D, K, RV>(
&mut self,
dstkey: D,
keys: K,
) -> Result<RV, RedisError>where
D: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
§fn zinterstore_max<'a, D, K, RV>(
&mut self,
dstkey: D,
keys: K,
) -> Result<RV, RedisError>where
D: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
fn zinterstore_max<'a, D, K, RV>(
&mut self,
dstkey: D,
keys: K,
) -> Result<RV, RedisError>where
D: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
§fn zinterstore_weights<'a, D, K, W, RV>(
&mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Result<RV, RedisError>where
D: ToRedisArgs,
K: ToRedisArgs,
W: ToRedisArgs,
RV: FromRedisValue,
fn zinterstore_weights<'a, D, K, W, RV>(
&mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Result<RV, RedisError>where
D: ToRedisArgs,
K: ToRedisArgs,
W: ToRedisArgs,
RV: FromRedisValue,
Commands::zinterstore
], but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.§fn zinterstore_min_weights<'a, D, K, W, RV>(
&mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Result<RV, RedisError>where
D: ToRedisArgs,
K: ToRedisArgs,
W: ToRedisArgs,
RV: FromRedisValue,
fn zinterstore_min_weights<'a, D, K, W, RV>(
&mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Result<RV, RedisError>where
D: ToRedisArgs,
K: ToRedisArgs,
W: ToRedisArgs,
RV: FromRedisValue,
Commands::zinterstore_min
], but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.§fn zinterstore_max_weights<'a, D, K, W, RV>(
&mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Result<RV, RedisError>where
D: ToRedisArgs,
K: ToRedisArgs,
W: ToRedisArgs,
RV: FromRedisValue,
fn zinterstore_max_weights<'a, D, K, W, RV>(
&mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Result<RV, RedisError>where
D: ToRedisArgs,
K: ToRedisArgs,
W: ToRedisArgs,
RV: FromRedisValue,
Commands::zinterstore_max
], but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.§fn zlexcount<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zlexcount<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
§fn bzpopmax<'a, K, RV>(
&mut self,
key: K,
timeout: f64,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn bzpopmax<'a, K, RV>(
&mut self,
key: K,
timeout: f64,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn zpopmax<'a, K, RV>(&mut self, key: K, count: isize) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zpopmax<'a, K, RV>(&mut self, key: K, count: isize) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn bzpopmin<'a, K, RV>(
&mut self,
key: K,
timeout: f64,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn bzpopmin<'a, K, RV>(
&mut self,
key: K,
timeout: f64,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn zpopmin<'a, K, RV>(&mut self, key: K, count: isize) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zpopmin<'a, K, RV>(&mut self, key: K, count: isize) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn bzmpop_max<'a, K, RV>(
&mut self,
timeout: f64,
keys: K,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn bzmpop_max<'a, K, RV>(
&mut self,
timeout: f64,
keys: K,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn zmpop_max<'a, K, RV>(
&mut self,
keys: K,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zmpop_max<'a, K, RV>(
&mut self,
keys: K,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn bzmpop_min<'a, K, RV>(
&mut self,
timeout: f64,
keys: K,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn bzmpop_min<'a, K, RV>(
&mut self,
timeout: f64,
keys: K,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn zmpop_min<'a, K, RV>(
&mut self,
keys: K,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zmpop_min<'a, K, RV>(
&mut self,
keys: K,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn zrandmember<'a, K, RV>(
&mut self,
key: K,
count: Option<isize>,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zrandmember<'a, K, RV>(
&mut self,
key: K,
count: Option<isize>,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
count == None
)§fn zrandmember_withscores<'a, K, RV>(
&mut self,
key: K,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zrandmember_withscores<'a, K, RV>(
&mut self,
key: K,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn zrange<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zrange<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn zrange_withscores<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zrange_withscores<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn zrangebylex<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zrangebylex<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
§fn zrangebylex_limit<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zrangebylex_limit<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
§fn zrevrangebylex<'a, K, MM, M, RV>(
&mut self,
key: K,
max: MM,
min: M,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
MM: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn zrevrangebylex<'a, K, MM, M, RV>(
&mut self,
key: K,
max: MM,
min: M,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
MM: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
§fn zrevrangebylex_limit<'a, K, MM, M, RV>(
&mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
MM: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn zrevrangebylex_limit<'a, K, MM, M, RV>(
&mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
MM: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
§fn zrangebyscore<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zrangebyscore<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
§fn zrangebyscore_withscores<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zrangebyscore_withscores<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
§fn zrangebyscore_limit<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zrangebyscore_limit<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
§fn zrangebyscore_limit_withscores<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zrangebyscore_limit_withscores<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
§fn zrank<'a, K, M, RV>(&mut self, key: K, member: M) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn zrank<'a, K, M, RV>(&mut self, key: K, member: M) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
§fn zrem<'a, K, M, RV>(&mut self, key: K, members: M) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn zrem<'a, K, M, RV>(&mut self, key: K, members: M) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
§fn zrembylex<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zrembylex<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
§fn zremrangebyrank<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zremrangebyrank<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn zrembyscore<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
fn zrembyscore<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
MM: ToRedisArgs,
RV: FromRedisValue,
§fn zrevrange<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zrevrange<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn zrevrange_withscores<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zrevrange_withscores<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn zrevrangebyscore<'a, K, MM, M, RV>(
&mut self,
key: K,
max: MM,
min: M,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
MM: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn zrevrangebyscore<'a, K, MM, M, RV>(
&mut self,
key: K,
max: MM,
min: M,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
MM: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
§fn zrevrangebyscore_withscores<'a, K, MM, M, RV>(
&mut self,
key: K,
max: MM,
min: M,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
MM: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn zrevrangebyscore_withscores<'a, K, MM, M, RV>(
&mut self,
key: K,
max: MM,
min: M,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
MM: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
§fn zrevrangebyscore_limit<'a, K, MM, M, RV>(
&mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
MM: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn zrevrangebyscore_limit<'a, K, MM, M, RV>(
&mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
MM: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
§fn zrevrangebyscore_limit_withscores<'a, K, MM, M, RV>(
&mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
MM: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn zrevrangebyscore_limit_withscores<'a, K, MM, M, RV>(
&mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
MM: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
§fn zrevrank<'a, K, M, RV>(
&mut self,
key: K,
member: M,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn zrevrank<'a, K, M, RV>(
&mut self,
key: K,
member: M,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
§fn zscore<'a, K, M, RV>(&mut self, key: K, member: M) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn zscore<'a, K, M, RV>(&mut self, key: K, member: M) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
§fn zscore_multiple<'a, K, M, RV>(
&mut self,
key: K,
members: &'a [M],
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn zscore_multiple<'a, K, M, RV>(
&mut self,
key: K,
members: &'a [M],
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
§fn zunionstore<'a, D, K, RV>(
&mut self,
dstkey: D,
keys: K,
) -> Result<RV, RedisError>where
D: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
fn zunionstore<'a, D, K, RV>(
&mut self,
dstkey: D,
keys: K,
) -> Result<RV, RedisError>where
D: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
§fn zunionstore_min<'a, D, K, RV>(
&mut self,
dstkey: D,
keys: K,
) -> Result<RV, RedisError>where
D: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
fn zunionstore_min<'a, D, K, RV>(
&mut self,
dstkey: D,
keys: K,
) -> Result<RV, RedisError>where
D: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
§fn zunionstore_max<'a, D, K, RV>(
&mut self,
dstkey: D,
keys: K,
) -> Result<RV, RedisError>where
D: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
fn zunionstore_max<'a, D, K, RV>(
&mut self,
dstkey: D,
keys: K,
) -> Result<RV, RedisError>where
D: ToRedisArgs,
K: ToRedisArgs,
RV: FromRedisValue,
§fn zunionstore_weights<'a, D, K, W, RV>(
&mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Result<RV, RedisError>where
D: ToRedisArgs,
K: ToRedisArgs,
W: ToRedisArgs,
RV: FromRedisValue,
fn zunionstore_weights<'a, D, K, W, RV>(
&mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Result<RV, RedisError>where
D: ToRedisArgs,
K: ToRedisArgs,
W: ToRedisArgs,
RV: FromRedisValue,
Commands::zunionstore
], but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.§fn zunionstore_min_weights<'a, D, K, W, RV>(
&mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Result<RV, RedisError>where
D: ToRedisArgs,
K: ToRedisArgs,
W: ToRedisArgs,
RV: FromRedisValue,
fn zunionstore_min_weights<'a, D, K, W, RV>(
&mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Result<RV, RedisError>where
D: ToRedisArgs,
K: ToRedisArgs,
W: ToRedisArgs,
RV: FromRedisValue,
Commands::zunionstore_min
], but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.§fn zunionstore_max_weights<'a, D, K, W, RV>(
&mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Result<RV, RedisError>where
D: ToRedisArgs,
K: ToRedisArgs,
W: ToRedisArgs,
RV: FromRedisValue,
fn zunionstore_max_weights<'a, D, K, W, RV>(
&mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Result<RV, RedisError>where
D: ToRedisArgs,
K: ToRedisArgs,
W: ToRedisArgs,
RV: FromRedisValue,
Commands::zunionstore_max
], but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.§fn pfadd<'a, K, E, RV>(&mut self, key: K, element: E) -> Result<RV, RedisError>where
K: ToRedisArgs,
E: ToRedisArgs,
RV: FromRedisValue,
fn pfadd<'a, K, E, RV>(&mut self, key: K, element: E) -> Result<RV, RedisError>where
K: ToRedisArgs,
E: ToRedisArgs,
RV: FromRedisValue,
§fn pfcount<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn pfcount<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn pfmerge<'a, D, S, RV>(
&mut self,
dstkey: D,
srckeys: S,
) -> Result<RV, RedisError>where
D: ToRedisArgs,
S: ToRedisArgs,
RV: FromRedisValue,
fn pfmerge<'a, D, S, RV>(
&mut self,
dstkey: D,
srckeys: S,
) -> Result<RV, RedisError>where
D: ToRedisArgs,
S: ToRedisArgs,
RV: FromRedisValue,
§fn publish<'a, K, E, RV>(
&mut self,
channel: K,
message: E,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
E: ToRedisArgs,
RV: FromRedisValue,
fn publish<'a, K, E, RV>(
&mut self,
channel: K,
message: E,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
E: ToRedisArgs,
RV: FromRedisValue,
§fn spublish<'a, K, E, RV>(
&mut self,
channel: K,
message: E,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
E: ToRedisArgs,
RV: FromRedisValue,
fn spublish<'a, K, E, RV>(
&mut self,
channel: K,
message: E,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
E: ToRedisArgs,
RV: FromRedisValue,
§fn object_encoding<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn object_encoding<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn object_idletime<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn object_idletime<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn object_freq<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn object_freq<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn object_refcount<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn object_refcount<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn client_getname<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn client_getname<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
§fn client_id<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn client_id<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
§fn client_setname<'a, K, RV>(
&mut self,
connection_name: K,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn client_setname<'a, K, RV>(
&mut self,
connection_name: K,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn acl_load<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn acl_load<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
§fn acl_save<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn acl_save<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
§fn acl_list<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn acl_list<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
§fn acl_users<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn acl_users<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
§fn acl_getuser<'a, K, RV>(&mut self, username: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn acl_getuser<'a, K, RV>(&mut self, username: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn acl_setuser<'a, K, RV>(&mut self, username: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn acl_setuser<'a, K, RV>(&mut self, username: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn acl_setuser_rules<'a, K, RV>(
&mut self,
username: K,
rules: &'a [Rule],
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn acl_setuser_rules<'a, K, RV>(
&mut self,
username: K,
rules: &'a [Rule],
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn acl_deluser<'a, K, RV>(
&mut self,
usernames: &'a [K],
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn acl_deluser<'a, K, RV>(
&mut self,
usernames: &'a [K],
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn acl_dryrun<'a, K, C, A, RV>(
&mut self,
username: K,
command: C,
args: A,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
C: ToRedisArgs,
A: ToRedisArgs,
RV: FromRedisValue,
fn acl_dryrun<'a, K, C, A, RV>(
&mut self,
username: K,
command: C,
args: A,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
C: ToRedisArgs,
A: ToRedisArgs,
RV: FromRedisValue,
§fn acl_cat<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn acl_cat<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
§fn acl_cat_categoryname<'a, K, RV>(
&mut self,
categoryname: K,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn acl_cat_categoryname<'a, K, RV>(
&mut self,
categoryname: K,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn acl_genpass<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn acl_genpass<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
§fn acl_genpass_bits<'a, RV>(&mut self, bits: isize) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn acl_genpass_bits<'a, RV>(&mut self, bits: isize) -> Result<RV, RedisError>where
RV: FromRedisValue,
§fn acl_whoami<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn acl_whoami<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
§fn acl_log<'a, RV>(&mut self, count: isize) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn acl_log<'a, RV>(&mut self, count: isize) -> Result<RV, RedisError>where
RV: FromRedisValue,
§fn acl_log_reset<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn acl_log_reset<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
§fn acl_help<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn acl_help<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
§fn geo_add<'a, K, M, RV>(
&mut self,
key: K,
members: M,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn geo_add<'a, K, M, RV>(
&mut self,
key: K,
members: M,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
§fn geo_dist<'a, K, M1, M2, RV>(
&mut self,
key: K,
member1: M1,
member2: M2,
unit: Unit,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M1: ToRedisArgs,
M2: ToRedisArgs,
RV: FromRedisValue,
fn geo_dist<'a, K, M1, M2, RV>(
&mut self,
key: K,
member1: M1,
member2: M2,
unit: Unit,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M1: ToRedisArgs,
M2: ToRedisArgs,
RV: FromRedisValue,
§fn geo_hash<'a, K, M, RV>(
&mut self,
key: K,
members: M,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn geo_hash<'a, K, M, RV>(
&mut self,
key: K,
members: M,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
§fn geo_pos<'a, K, M, RV>(
&mut self,
key: K,
members: M,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn geo_pos<'a, K, M, RV>(
&mut self,
key: K,
members: M,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
§fn geo_radius<'a, K, RV>(
&mut self,
key: K,
longitude: f64,
latitude: f64,
radius: f64,
unit: Unit,
options: RadiusOptions,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn geo_radius<'a, K, RV>(
&mut self,
key: K,
longitude: f64,
latitude: f64,
radius: f64,
unit: Unit,
options: RadiusOptions,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn geo_radius_by_member<'a, K, M, RV>(
&mut self,
key: K,
member: M,
radius: f64,
unit: Unit,
options: RadiusOptions,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
fn geo_radius_by_member<'a, K, M, RV>(
&mut self,
key: K,
member: M,
radius: f64,
unit: Unit,
options: RadiusOptions,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
M: ToRedisArgs,
RV: FromRedisValue,
member
. The
member itself is always contained in the results.§fn xack<'a, K, G, I, RV>(
&mut self,
key: K,
group: G,
ids: &'a [I],
) -> Result<RV, RedisError>where
K: ToRedisArgs,
G: ToRedisArgs,
I: ToRedisArgs,
RV: FromRedisValue,
fn xack<'a, K, G, I, RV>(
&mut self,
key: K,
group: G,
ids: &'a [I],
) -> Result<RV, RedisError>where
K: ToRedisArgs,
G: ToRedisArgs,
I: ToRedisArgs,
RV: FromRedisValue,
§fn xadd<'a, K, ID, F, V, RV>(
&mut self,
key: K,
id: ID,
items: &'a [(F, V)],
) -> Result<RV, RedisError>where
K: ToRedisArgs,
ID: ToRedisArgs,
F: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
fn xadd<'a, K, ID, F, V, RV>(
&mut self,
key: K,
id: ID,
items: &'a [(F, V)],
) -> Result<RV, RedisError>where
K: ToRedisArgs,
ID: ToRedisArgs,
F: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
§fn xadd_map<'a, K, ID, BTM, RV>(
&mut self,
key: K,
id: ID,
map: BTM,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
ID: ToRedisArgs,
BTM: ToRedisArgs,
RV: FromRedisValue,
fn xadd_map<'a, K, ID, BTM, RV>(
&mut self,
key: K,
id: ID,
map: BTM,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
ID: ToRedisArgs,
BTM: ToRedisArgs,
RV: FromRedisValue,
key
.
Use *
as the id
for the current timestamp. Read more§fn xadd_options<'a, K, ID, I, RV>(
&mut self,
key: K,
id: ID,
items: I,
options: &'a StreamAddOptions,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
ID: ToRedisArgs,
I: ToRedisArgs,
RV: FromRedisValue,
fn xadd_options<'a, K, ID, I, RV>(
&mut self,
key: K,
id: ID,
items: I,
options: &'a StreamAddOptions,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
ID: ToRedisArgs,
I: ToRedisArgs,
RV: FromRedisValue,
§fn xadd_maxlen<'a, K, ID, F, V, RV>(
&mut self,
key: K,
maxlen: StreamMaxlen,
id: ID,
items: &'a [(F, V)],
) -> Result<RV, RedisError>where
K: ToRedisArgs,
ID: ToRedisArgs,
F: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
fn xadd_maxlen<'a, K, ID, F, V, RV>(
&mut self,
key: K,
maxlen: StreamMaxlen,
id: ID,
items: &'a [(F, V)],
) -> Result<RV, RedisError>where
K: ToRedisArgs,
ID: ToRedisArgs,
F: ToRedisArgs,
V: ToRedisArgs,
RV: FromRedisValue,
§fn xadd_maxlen_map<'a, K, ID, BTM, RV>(
&mut self,
key: K,
maxlen: StreamMaxlen,
id: ID,
map: BTM,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
ID: ToRedisArgs,
BTM: ToRedisArgs,
RV: FromRedisValue,
fn xadd_maxlen_map<'a, K, ID, BTM, RV>(
&mut self,
key: K,
maxlen: StreamMaxlen,
id: ID,
map: BTM,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
ID: ToRedisArgs,
BTM: ToRedisArgs,
RV: FromRedisValue,
§fn xautoclaim_options<'a, K, G, C, MIT, S, RV>(
&mut self,
key: K,
group: G,
consumer: C,
min_idle_time: MIT,
start: S,
options: StreamAutoClaimOptions,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
G: ToRedisArgs,
C: ToRedisArgs,
MIT: ToRedisArgs,
S: ToRedisArgs,
RV: FromRedisValue,
fn xautoclaim_options<'a, K, G, C, MIT, S, RV>(
&mut self,
key: K,
group: G,
consumer: C,
min_idle_time: MIT,
start: S,
options: StreamAutoClaimOptions,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
G: ToRedisArgs,
C: ToRedisArgs,
MIT: ToRedisArgs,
S: ToRedisArgs,
RV: FromRedisValue,
§fn xclaim<'a, K, G, C, MIT, ID, RV>(
&mut self,
key: K,
group: G,
consumer: C,
min_idle_time: MIT,
ids: &'a [ID],
) -> Result<RV, RedisError>where
K: ToRedisArgs,
G: ToRedisArgs,
C: ToRedisArgs,
MIT: ToRedisArgs,
ID: ToRedisArgs,
RV: FromRedisValue,
fn xclaim<'a, K, G, C, MIT, ID, RV>(
&mut self,
key: K,
group: G,
consumer: C,
min_idle_time: MIT,
ids: &'a [ID],
) -> Result<RV, RedisError>where
K: ToRedisArgs,
G: ToRedisArgs,
C: ToRedisArgs,
MIT: ToRedisArgs,
ID: ToRedisArgs,
RV: FromRedisValue,
§fn xclaim_options<'a, K, G, C, MIT, ID, RV>(
&mut self,
key: K,
group: G,
consumer: C,
min_idle_time: MIT,
ids: &'a [ID],
options: StreamClaimOptions,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
G: ToRedisArgs,
C: ToRedisArgs,
MIT: ToRedisArgs,
ID: ToRedisArgs,
RV: FromRedisValue,
fn xclaim_options<'a, K, G, C, MIT, ID, RV>(
&mut self,
key: K,
group: G,
consumer: C,
min_idle_time: MIT,
ids: &'a [ID],
options: StreamClaimOptions,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
G: ToRedisArgs,
C: ToRedisArgs,
MIT: ToRedisArgs,
ID: ToRedisArgs,
RV: FromRedisValue,
§fn xdel<'a, K, ID, RV>(
&mut self,
key: K,
ids: &'a [ID],
) -> Result<RV, RedisError>where
K: ToRedisArgs,
ID: ToRedisArgs,
RV: FromRedisValue,
fn xdel<'a, K, ID, RV>(
&mut self,
key: K,
ids: &'a [ID],
) -> Result<RV, RedisError>where
K: ToRedisArgs,
ID: ToRedisArgs,
RV: FromRedisValue,
§fn xgroup_create<'a, K, G, ID, RV>(
&mut self,
key: K,
group: G,
id: ID,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
G: ToRedisArgs,
ID: ToRedisArgs,
RV: FromRedisValue,
fn xgroup_create<'a, K, G, ID, RV>(
&mut self,
key: K,
group: G,
id: ID,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
G: ToRedisArgs,
ID: ToRedisArgs,
RV: FromRedisValue,
group
. It expects the stream key
to already exist. Otherwise, use xgroup_create_mkstream
if it doesn’t.
The id
is the starting message id all consumers should read from. Use $
If you want
all consumers to read from the last message added to stream. Read more§fn xgroup_createconsumer<'a, K, G, C, RV>(
&mut self,
key: K,
group: G,
consumer: C,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
G: ToRedisArgs,
C: ToRedisArgs,
RV: FromRedisValue,
fn xgroup_createconsumer<'a, K, G, C, RV>(
&mut self,
key: K,
group: G,
consumer: C,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
G: ToRedisArgs,
C: ToRedisArgs,
RV: FromRedisValue,
consumer
explicitly (vs implicit via XREADGROUP)
for given stream `key. Read more§fn xgroup_create_mkstream<'a, K, G, ID, RV>(
&mut self,
key: K,
group: G,
id: ID,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
G: ToRedisArgs,
ID: ToRedisArgs,
RV: FromRedisValue,
fn xgroup_create_mkstream<'a, K, G, ID, RV>(
&mut self,
key: K,
group: G,
id: ID,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
G: ToRedisArgs,
ID: ToRedisArgs,
RV: FromRedisValue,
group
which makes the stream if it doesn’t exist. Read more§fn xgroup_setid<'a, K, G, ID, RV>(
&mut self,
key: K,
group: G,
id: ID,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
G: ToRedisArgs,
ID: ToRedisArgs,
RV: FromRedisValue,
fn xgroup_setid<'a, K, G, ID, RV>(
&mut self,
key: K,
group: G,
id: ID,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
G: ToRedisArgs,
ID: ToRedisArgs,
RV: FromRedisValue,
§fn xgroup_destroy<'a, K, G, RV>(
&mut self,
key: K,
group: G,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
G: ToRedisArgs,
RV: FromRedisValue,
fn xgroup_destroy<'a, K, G, RV>(
&mut self,
key: K,
group: G,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
G: ToRedisArgs,
RV: FromRedisValue,
§fn xgroup_delconsumer<'a, K, G, C, RV>(
&mut self,
key: K,
group: G,
consumer: C,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
G: ToRedisArgs,
C: ToRedisArgs,
RV: FromRedisValue,
fn xgroup_delconsumer<'a, K, G, C, RV>(
&mut self,
key: K,
group: G,
consumer: C,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
G: ToRedisArgs,
C: ToRedisArgs,
RV: FromRedisValue,
§fn xinfo_consumers<'a, K, G, RV>(
&mut self,
key: K,
group: G,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
G: ToRedisArgs,
RV: FromRedisValue,
fn xinfo_consumers<'a, K, G, RV>(
&mut self,
key: K,
group: G,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
G: ToRedisArgs,
RV: FromRedisValue,
group
.
Take note of the StreamInfoConsumersReply return type. Read more§fn xinfo_groups<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn xinfo_groups<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
group
s created for a given stream key
.
Take note of the StreamInfoGroupsReply return type. Read more§fn xinfo_stream<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn xinfo_stream<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
id
, length, number of groups, etc.)
Take note of the StreamInfoStreamReply return type. Read more§fn xlen<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn xlen<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
key
. Read more§fn xpending<'a, K, G, RV>(&mut self, key: K, group: G) -> Result<RV, RedisError>where
K: ToRedisArgs,
G: ToRedisArgs,
RV: FromRedisValue,
fn xpending<'a, K, G, RV>(&mut self, key: K, group: G) -> Result<RV, RedisError>where
K: ToRedisArgs,
G: ToRedisArgs,
RV: FromRedisValue,
key
and consumer group
and it
returns details about which consumers have pending messages
that haven’t been acked. Read more§fn xpending_count<'a, K, G, S, E, C, RV>(
&mut self,
key: K,
group: G,
start: S,
end: E,
count: C,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
G: ToRedisArgs,
S: ToRedisArgs,
E: ToRedisArgs,
C: ToRedisArgs,
RV: FromRedisValue,
fn xpending_count<'a, K, G, S, E, C, RV>(
&mut self,
key: K,
group: G,
start: S,
end: E,
count: C,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
G: ToRedisArgs,
S: ToRedisArgs,
E: ToRedisArgs,
C: ToRedisArgs,
RV: FromRedisValue,
§fn xpending_consumer_count<'a, K, G, S, E, C, CN, RV>(
&mut self,
key: K,
group: G,
start: S,
end: E,
count: C,
consumer: CN,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
G: ToRedisArgs,
S: ToRedisArgs,
E: ToRedisArgs,
C: ToRedisArgs,
CN: ToRedisArgs,
RV: FromRedisValue,
fn xpending_consumer_count<'a, K, G, S, E, C, CN, RV>(
&mut self,
key: K,
group: G,
start: S,
end: E,
count: C,
consumer: CN,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
G: ToRedisArgs,
S: ToRedisArgs,
E: ToRedisArgs,
C: ToRedisArgs,
CN: ToRedisArgs,
RV: FromRedisValue,
§fn xrange<'a, K, S, E, RV>(
&mut self,
key: K,
start: S,
end: E,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
S: ToRedisArgs,
E: ToRedisArgs,
RV: FromRedisValue,
fn xrange<'a, K, S, E, RV>(
&mut self,
key: K,
start: S,
end: E,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
S: ToRedisArgs,
E: ToRedisArgs,
RV: FromRedisValue,
key
. Read more§fn xrange_all<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn xrange_all<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
key
.
Use with caution! Read more§fn xrange_count<'a, K, S, E, C, RV>(
&mut self,
key: K,
start: S,
end: E,
count: C,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
S: ToRedisArgs,
E: ToRedisArgs,
C: ToRedisArgs,
RV: FromRedisValue,
fn xrange_count<'a, K, S, E, C, RV>(
&mut self,
key: K,
start: S,
end: E,
count: C,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
S: ToRedisArgs,
E: ToRedisArgs,
C: ToRedisArgs,
RV: FromRedisValue,
key
. Read more§fn xread<'a, K, ID, RV>(
&mut self,
keys: &'a [K],
ids: &'a [ID],
) -> Result<RV, RedisError>where
K: ToRedisArgs,
ID: ToRedisArgs,
RV: FromRedisValue,
fn xread<'a, K, ID, RV>(
&mut self,
keys: &'a [K],
ids: &'a [ID],
) -> Result<RV, RedisError>where
K: ToRedisArgs,
ID: ToRedisArgs,
RV: FromRedisValue,
id
s for each stream key
.
This is the basic form of reading streams.
For more advanced control, like blocking, limiting, or reading by consumer group
,
see xread_options
. Read more§fn xread_options<'a, K, ID, RV>(
&mut self,
keys: &'a [K],
ids: &'a [ID],
options: &'a StreamReadOptions,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
ID: ToRedisArgs,
RV: FromRedisValue,
fn xread_options<'a, K, ID, RV>(
&mut self,
keys: &'a [K],
ids: &'a [ID],
options: &'a StreamReadOptions,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
ID: ToRedisArgs,
RV: FromRedisValue,
§fn xrevrange<'a, K, E, S, RV>(
&mut self,
key: K,
end: E,
start: S,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
E: ToRedisArgs,
S: ToRedisArgs,
RV: FromRedisValue,
fn xrevrange<'a, K, E, S, RV>(
&mut self,
key: K,
end: E,
start: S,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
E: ToRedisArgs,
S: ToRedisArgs,
RV: FromRedisValue,
§fn xrevrange_all<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn xrevrange_all<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn xrevrange_count<'a, K, E, S, C, RV>(
&mut self,
key: K,
end: E,
start: S,
count: C,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
E: ToRedisArgs,
S: ToRedisArgs,
C: ToRedisArgs,
RV: FromRedisValue,
fn xrevrange_count<'a, K, E, S, C, RV>(
&mut self,
key: K,
end: E,
start: S,
count: C,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
E: ToRedisArgs,
S: ToRedisArgs,
C: ToRedisArgs,
RV: FromRedisValue,
§fn xtrim<'a, K, RV>(
&mut self,
key: K,
maxlen: StreamMaxlen,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn xtrim<'a, K, RV>(
&mut self,
key: K,
maxlen: StreamMaxlen,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
key
to a MAXLEN count. Read more§fn xtrim_options<'a, K, RV>(
&mut self,
key: K,
options: &'a StreamTrimOptions,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn xtrim_options<'a, K, RV>(
&mut self,
key: K,
options: &'a StreamTrimOptions,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
key
with full options Read more§fn invoke_script<'a, RV>(
&mut self,
invocation: &'a ScriptInvocation<'a>,
) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn invoke_script<'a, RV>(
&mut self,
invocation: &'a ScriptInvocation<'a>,
) -> Result<RV, RedisError>where
RV: FromRedisValue,
§fn scan<RV>(&mut self) -> Result<Iter<'_, RV>, RedisError>where
RV: FromRedisValue,
fn scan<RV>(&mut self) -> Result<Iter<'_, RV>, RedisError>where
RV: FromRedisValue,
§fn scan_options<RV>(
&mut self,
opts: ScanOptions,
) -> Result<Iter<'_, RV>, RedisError>where
RV: FromRedisValue,
fn scan_options<RV>(
&mut self,
opts: ScanOptions,
) -> Result<Iter<'_, RV>, RedisError>where
RV: FromRedisValue,
§fn scan_match<P, RV>(&mut self, pattern: P) -> Result<Iter<'_, RV>, RedisError>where
P: ToRedisArgs,
RV: FromRedisValue,
fn scan_match<P, RV>(&mut self, pattern: P) -> Result<Iter<'_, RV>, RedisError>where
P: ToRedisArgs,
RV: FromRedisValue,
§fn hscan<K, RV>(&mut self, key: K) -> Result<Iter<'_, RV>, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn hscan<K, RV>(&mut self, key: K) -> Result<Iter<'_, RV>, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn hscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P,
) -> Result<Iter<'_, RV>, RedisError>where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
fn hscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P,
) -> Result<Iter<'_, RV>, RedisError>where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
§fn sscan<K, RV>(&mut self, key: K) -> Result<Iter<'_, RV>, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn sscan<K, RV>(&mut self, key: K) -> Result<Iter<'_, RV>, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn sscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P,
) -> Result<Iter<'_, RV>, RedisError>where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
fn sscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P,
) -> Result<Iter<'_, RV>, RedisError>where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
§fn zscan<K, RV>(&mut self, key: K) -> Result<Iter<'_, RV>, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zscan<K, RV>(&mut self, key: K) -> Result<Iter<'_, RV>, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
§fn zscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P,
) -> Result<Iter<'_, RV>, RedisError>where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
fn zscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P,
) -> Result<Iter<'_, RV>, RedisError>where
K: ToRedisArgs,
P: ToRedisArgs,
RV: FromRedisValue,
§impl<C, T> ConnectionLike for Twhere
C: ConnectionLike,
T: DerefMut<Target = C>,
impl<C, T> ConnectionLike for Twhere
C: ConnectionLike,
T: DerefMut<Target = C>,
§fn req_packed_command(&mut self, cmd: &[u8]) -> Result<Value, RedisError>
fn req_packed_command(&mut self, cmd: &[u8]) -> Result<Value, RedisError>
fn req_packed_commands( &mut self, cmd: &[u8], offset: usize, count: usize, ) -> Result<Vec<Value>, RedisError>
§fn req_command(&mut self, cmd: &Cmd) -> Result<Value, RedisError>
fn req_command(&mut self, cmd: &Cmd) -> Result<Value, RedisError>
§fn get_db(&self) -> i64
fn get_db(&self) -> i64
fn supports_pipelining(&self) -> bool
§fn check_connection(&mut self) -> bool
fn check_connection(&mut self) -> bool
PING
internally).§impl<T> Conv for T
impl<T> Conv for T
§impl<Choices> CoproductSubsetter<CNil, HNil> for Choices
impl<Choices> CoproductSubsetter<CNil, HNil> for Choices
§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
§fn into_any(self: Box<T>) -> Box<dyn Any>
fn into_any(self: Box<T>) -> Box<dyn Any>
Box<dyn Trait>
(where Trait: Downcast
) to Box<dyn Any>
, which can then be
downcast
into Box<dyn ConcreteType>
where ConcreteType
implements Trait
.§fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
, which can then be further
downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
.§fn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
&Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s.§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
&mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s.§impl<T> DowncastSend for T
impl<T> DowncastSend for T
§impl<T> DowncastSync for T
impl<T> DowncastSync for T
§impl<T, A> DynAccess<T> for Awhere
A: Access<T>,
<A as Access<T>>::Guard: 'static,
impl<T, A> DynAccess<T> for Awhere
A: Access<T>,
<A as Access<T>>::Guard: 'static,
§impl<T> FmtForward for T
impl<T> FmtForward for T
§fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
self
to use its Binary
implementation when Debug
-formatted.§fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
self
to use its Display
implementation when
Debug
-formatted.§fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
self
to use its LowerExp
implementation when
Debug
-formatted.§fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
self
to use its LowerHex
implementation when
Debug
-formatted.§fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
self
to use its Octal
implementation when Debug
-formatted.§fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
self
to use its Pointer
implementation when
Debug
-formatted.§fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
self
to use its UpperExp
implementation when
Debug
-formatted.§fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
self
to use its UpperHex
implementation when
Debug
-formatted.§fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,
fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,
§impl<T> FutureExt for T
impl<T> FutureExt for T
§fn with_context(self, otel_cx: Context) -> WithContext<Self>
fn with_context(self, otel_cx: Context) -> WithContext<Self>
§fn with_current_context(self) -> WithContext<Self>
fn with_current_context(self) -> WithContext<Self>
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
Source§impl<T> Instrument for T
impl<T> Instrument for T
Source§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
Source§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
Source§impl<T> IntoEither for T
impl<T> IntoEither for T
Source§fn into_either(self, into_left: bool) -> Either<Self, Self>
fn into_either(self, into_left: bool) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left
is true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moreSource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left(&self)
returns true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moreSource§impl<T> IntoRequest<T> for T
impl<T> IntoRequest<T> for T
Source§fn into_request(self) -> Request<T>
fn into_request(self) -> Request<T>
T
in a tonic::Request
§impl<T> IntoResult<T> for T
impl<T> IntoResult<T> for T
type Err = Infallible
fn into_result(self) -> Result<T, <T as IntoResult<T>>::Err>
§impl<T, U, I> LiftInto<U, I> for Twhere
U: LiftFrom<T, I>,
impl<T, U, I> LiftInto<U, I> for Twhere
U: LiftFrom<T, I>,
§impl<M> MetricVecRelabelExt for M
impl<M> MetricVecRelabelExt for M
§fn relabel(
self,
metric_level: MetricLevel,
relabel_threshold: MetricLevel,
) -> RelabeledMetricVec<M>
fn relabel( self, metric_level: MetricLevel, relabel_threshold: MetricLevel, ) -> RelabeledMetricVec<M>
RelabeledMetricVec::with_metric_level
].§fn relabel_n(
self,
metric_level: MetricLevel,
relabel_threshold: MetricLevel,
relabel_num: usize,
) -> RelabeledMetricVec<M>
fn relabel_n( self, metric_level: MetricLevel, relabel_threshold: MetricLevel, relabel_num: usize, ) -> RelabeledMetricVec<M>
RelabeledMetricVec::with_metric_level_relabel_n
].§fn relabel_debug_1(
self,
relabel_threshold: MetricLevel,
) -> RelabeledMetricVec<M>
fn relabel_debug_1( self, relabel_threshold: MetricLevel, ) -> RelabeledMetricVec<M>
RelabeledMetricVec::with_metric_level_relabel_n
] with metric_level
set to
MetricLevel::Debug
and relabel_num
set to 1.§impl<T> Pipe for Twhere
T: ?Sized,
impl<T> Pipe for Twhere
T: ?Sized,
§fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
§fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
self
and passes that borrow into the pipe function. Read more§fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
self
and passes that borrow into the pipe function. Read more§fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
§fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R,
) -> R
fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
§fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
self
, then passes self.as_ref()
into the pipe function.§fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
self
, then passes self.as_mut()
into the pipe
function.§fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
self
, then passes self.deref()
into the pipe function.§impl<T> Pointable for T
impl<T> Pointable for T
Source§impl<R> Rng for R
impl<R> Rng for R
Source§fn random<T>(&mut self) -> Twhere
StandardUniform: Distribution<T>,
fn random<T>(&mut self) -> Twhere
StandardUniform: Distribution<T>,
StandardUniform
distribution. Read moreSource§fn random_iter<T>(self) -> Iter<StandardUniform, Self, T>
fn random_iter<T>(self) -> Iter<StandardUniform, Self, T>
Source§fn random_range<T, R>(&mut self, range: R) -> Twhere
T: SampleUniform,
R: SampleRange<T>,
fn random_range<T, R>(&mut self, range: R) -> Twhere
T: SampleUniform,
R: SampleRange<T>,
Source§fn random_bool(&mut self, p: f64) -> bool
fn random_bool(&mut self, p: f64) -> bool
p
of being true. Read moreSource§fn random_ratio(&mut self, numerator: u32, denominator: u32) -> bool
fn random_ratio(&mut self, numerator: u32, denominator: u32) -> bool
numerator/denominator
of being
true. Read moreSource§fn sample<T, D>(&mut self, distr: D) -> Twhere
D: Distribution<T>,
fn sample<T, D>(&mut self, distr: D) -> Twhere
D: Distribution<T>,
Source§fn sample_iter<T, D>(self, distr: D) -> Iter<D, Self, T>where
D: Distribution<T>,
Self: Sized,
fn sample_iter<T, D>(self, distr: D) -> Iter<D, Self, T>where
D: Distribution<T>,
Self: Sized,
Source§fn gen<T>(&mut self) -> Twhere
StandardUniform: Distribution<T>,
fn gen<T>(&mut self) -> Twhere
StandardUniform: Distribution<T>,
random
to avoid conflict with the new gen
keyword in Rust 2024.Rng::random
.Source§fn gen_range<T, R>(&mut self, range: R) -> Twhere
T: SampleUniform,
R: SampleRange<T>,
fn gen_range<T, R>(&mut self, range: R) -> Twhere
T: SampleUniform,
R: SampleRange<T>,
random_range
Rng::random_range
.§impl<T> Scope for T
impl<T> Scope for T
§impl<Source> Sculptor<HNil, HNil> for Source
impl<Source> Sculptor<HNil, HNil> for Source
§impl<T> Source for T
impl<T> Source for T
§type Slice<'a> = <<T as Deref>::Target as Source>::Slice<'a>
where
T: 'a
type Slice<'a> = <<T as Deref>::Target as Source>::Slice<'a> where T: 'a
Source
can be sliced into.§fn read<'a, Chunk>(&'a self, offset: usize) -> Option<Chunk>where
Chunk: Chunk<'a>,
fn read<'a, Chunk>(&'a self, offset: usize) -> Option<Chunk>where
Chunk: Chunk<'a>,
None
when reading
out of bounds would occur. Read more§unsafe fn read_byte_unchecked(&self, offset: usize) -> u8
unsafe fn read_byte_unchecked(&self, offset: usize) -> u8
§fn slice(&self, range: Range<usize>) -> Option<<T as Source>::Slice<'_>>
fn slice(&self, range: Range<usize>) -> Option<<T as Source>::Slice<'_>>
slice::get(range)
. Read more§unsafe fn slice_unchecked(
&self,
range: Range<usize>,
) -> <T as Source>::Slice<'_>
unsafe fn slice_unchecked( &self, range: Range<usize>, ) -> <T as Source>::Slice<'_>
slice::get_unchecked(range)
. Read more§fn is_boundary(&self, index: usize) -> bool
fn is_boundary(&self, index: usize) -> bool
§fn find_boundary(&self, index: usize) -> usize
fn find_boundary(&self, index: usize) -> usize
&str
sources attempts to find the closest char
boundary at which source
can be sliced, starting from index
. Read more§impl<T> Tap for T
impl<T> Tap for T
§fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
Borrow<B>
of a value. Read more§fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
BorrowMut<B>
of a value. Read more§fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
AsRef<R>
view of a value. Read more§fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
AsMut<R>
view of a value. Read more§fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
Deref::Target
of a value. Read more§fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
Deref::Target
of a value. Read more§fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
.tap()
only in debug builds, and is erased in release builds.§fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
.tap_mut()
only in debug builds, and is erased in release
builds.§fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
.tap_borrow()
only in debug builds, and is erased in release
builds.§fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
.tap_borrow_mut()
only in debug builds, and is erased in release
builds.§fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
.tap_ref()
only in debug builds, and is erased in release
builds.§fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
.tap_ref_mut()
only in debug builds, and is erased in release
builds.§fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
.tap_deref()
only in debug builds, and is erased in release
builds.§impl<T> TryConv for T
impl<T> TryConv for T
Source§impl<R> TryRngCore for Rwhere
R: RngCore,
impl<R> TryRngCore for Rwhere
R: RngCore,
Source§type Error = Infallible
type Error = Infallible
Source§fn try_next_u32(&mut self) -> Result<u32, <R as TryRngCore>::Error>
fn try_next_u32(&mut self) -> Result<u32, <R as TryRngCore>::Error>
u32
.Source§fn try_next_u64(&mut self) -> Result<u64, <R as TryRngCore>::Error>
fn try_next_u64(&mut self) -> Result<u64, <R as TryRngCore>::Error>
u64
.Source§fn try_fill_bytes(
&mut self,
dst: &mut [u8],
) -> Result<(), <R as TryRngCore>::Error>
fn try_fill_bytes( &mut self, dst: &mut [u8], ) -> Result<(), <R as TryRngCore>::Error>
dest
entirely with random data.Source§fn read_adapter(&mut self) -> RngReadAdapter<'_, Self>where
Self: Sized,
fn read_adapter(&mut self) -> RngReadAdapter<'_, Self>where
Self: Sized,
RngCore
to a RngReadAdapter
.