Struct headless_lms_server::prelude::web::Form
source · pub struct Form<T>(pub T);
Expand description
URL encoded payload extractor and responder.
Form
has two uses: URL encoded responses, and extracting typed data from URL request payloads.
Extractor
To extract typed data from a request body, the inner type T
must implement the
DeserializeOwned
trait.
Use FormConfig
to configure extraction options.
Examples
use actix_web::{post, web};
use serde::Deserialize;
#[derive(Deserialize)]
struct Info {
name: String,
}
// This handler is only called if:
// - request headers declare the content type as `application/x-www-form-urlencoded`
// - request payload deserializes into an `Info` struct from the URL encoded format
#[post("/")]
async fn index(web::Form(form): web::Form<Info>) -> String {
format!("Welcome {}!", form.name)
}
Responder
The Form
type also allows you to create URL encoded responses by returning a value of type
Form<T>
where T
is the type to be URL encoded, as long as T
implements Serialize
.
Examples
use actix_web::{get, web};
use serde::Serialize;
#[derive(Serialize)]
struct SomeForm {
name: String,
age: u8
}
// Response will have:
// - status: 200 OK
// - header: `Content-Type: application/x-www-form-urlencoded`
// - body: `name=actix&age=123`
#[get("/")]
async fn index() -> web::Form<SomeForm> {
web::Form(SomeForm {
name: "actix".to_owned(),
age: 123
})
}
Panics
URL encoded forms consist of unordered key=value
pairs, therefore they cannot be decoded into
any type which depends upon data ordering (eg. tuples). Trying to do so will result in a panic.
Tuple Fields§
§0: T
Implementations§
source§impl<T> Form<T>
impl<T> Form<T>
sourcepub fn into_inner(self) -> T
pub fn into_inner(self) -> T
Unwrap into inner T
value.
Trait Implementations§
source§impl<T> FromRequest for Form<T>where
T: DeserializeOwned + 'static,
impl<T> FromRequest for Form<T>where
T: DeserializeOwned + 'static,
See here for example of usage as an extractor.
§type Future = FormExtractFut<T>
type Future = FormExtractFut<T>
Self
. Read moresource§fn from_request(
req: &HttpRequest,
payload: &mut Payload
) -> <Form<T> as FromRequest>::Future
fn from_request( req: &HttpRequest, payload: &mut Payload ) -> <Form<T> as FromRequest>::Future
Self
from request parts asynchronously.source§impl<T> Ord for Form<T>where
T: Ord,
impl<T> Ord for Form<T>where
T: Ord,
source§impl<T> PartialEq for Form<T>where
T: PartialEq,
impl<T> PartialEq for Form<T>where
T: PartialEq,
source§impl<T> PartialOrd for Form<T>where
T: PartialOrd,
impl<T> PartialOrd for Form<T>where
T: PartialOrd,
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl<T> Responder for Form<T>where
T: Serialize,
impl<T> Responder for Form<T>where
T: Serialize,
See here for example of usage as a handler return type.
type Body = EitherBody<String>
source§fn respond_to(
self,
_: &HttpRequest
) -> HttpResponse<<Form<T> as Responder>::Body>
fn respond_to( self, _: &HttpRequest ) -> HttpResponse<<Form<T> as Responder>::Body>
HttpResponse
.source§impl<T> Serialize for Form<T>where
T: Serialize,
impl<T> Serialize for Form<T>where
T: Serialize,
source§fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,
fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,
impl<T> Eq for Form<T>where
T: Eq,
impl<T> StructuralEq for Form<T>
impl<T> StructuralPartialEq for Form<T>
Auto Trait Implementations§
impl<T> RefUnwindSafe for Form<T>where
T: RefUnwindSafe,
impl<T> Send for Form<T>where
T: Send,
impl<T> Sync for Form<T>where
T: Sync,
impl<T> Unpin for Form<T>where
T: Unpin,
impl<T> UnwindSafe for Form<T>where
T: UnwindSafe,
Blanket Implementations§
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
source§impl<T> Commands for Twhere
T: ConnectionLike,
impl<T> Commands for Twhere
T: ConnectionLike,
source§fn get<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn get<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
MGET
.source§fn mget<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn mget<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn keys<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn keys<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn set<K, V, RV, 'a>(&mut self, key: K, value: V) -> Result<RV, RedisError>
fn set<K, V, RV, 'a>(&mut self, key: K, value: V) -> Result<RV, RedisError>
source§fn set_options<K, V, RV, 'a>(
&mut self,
key: K,
value: V,
options: SetOptions
) -> Result<RV, RedisError>
fn set_options<K, V, RV, 'a>( &mut self, key: K, value: V, options: SetOptions ) -> Result<RV, RedisError>
source§fn set_multiple<K, V, RV, 'a>(
&mut self,
items: &'a [(K, V)]
) -> Result<RV, RedisError>
fn set_multiple<K, V, RV, 'a>( &mut self, items: &'a [(K, V)] ) -> Result<RV, RedisError>
source§fn mset<K, V, RV, 'a>(&mut self, items: &'a [(K, V)]) -> Result<RV, RedisError>
fn mset<K, V, RV, 'a>(&mut self, items: &'a [(K, V)]) -> Result<RV, RedisError>
source§fn set_ex<K, V, RV, 'a>(
&mut self,
key: K,
value: V,
seconds: u64
) -> Result<RV, RedisError>
fn set_ex<K, V, RV, 'a>( &mut self, key: K, value: V, seconds: u64 ) -> Result<RV, RedisError>
source§fn pset_ex<K, V, RV, 'a>(
&mut self,
key: K,
value: V,
milliseconds: u64
) -> Result<RV, RedisError>
fn pset_ex<K, V, RV, 'a>( &mut self, key: K, value: V, milliseconds: u64 ) -> Result<RV, RedisError>
source§fn set_nx<K, V, RV, 'a>(&mut self, key: K, value: V) -> Result<RV, RedisError>
fn set_nx<K, V, RV, 'a>(&mut self, key: K, value: V) -> Result<RV, RedisError>
source§fn mset_nx<K, V, RV, 'a>(
&mut self,
items: &'a [(K, V)]
) -> Result<RV, RedisError>
fn mset_nx<K, V, RV, 'a>( &mut self, items: &'a [(K, V)] ) -> Result<RV, RedisError>
source§fn getset<K, V, RV, 'a>(&mut self, key: K, value: V) -> Result<RV, RedisError>
fn getset<K, V, RV, 'a>(&mut self, key: K, value: V) -> Result<RV, RedisError>
source§fn getrange<K, RV, 'a>(
&mut self,
key: K,
from: isize,
to: isize
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn getrange<K, RV, 'a>(
&mut self,
key: K,
from: isize,
to: isize
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn setrange<K, V, RV, 'a>(
&mut self,
key: K,
offset: isize,
value: V
) -> Result<RV, RedisError>
fn setrange<K, V, RV, 'a>( &mut self, key: K, offset: isize, value: V ) -> Result<RV, RedisError>
source§fn del<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn del<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn exists<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn exists<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn key_type<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn key_type<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn expire<K, RV, 'a>(&mut self, key: K, seconds: i64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn expire<K, RV, 'a>(&mut self, key: K, seconds: i64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn expire_at<K, RV, 'a>(&mut self, key: K, ts: i64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn expire_at<K, RV, 'a>(&mut self, key: K, ts: i64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn pexpire<K, RV, 'a>(&mut self, key: K, ms: i64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn pexpire<K, RV, 'a>(&mut self, key: K, ms: i64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn pexpire_at<K, RV, 'a>(&mut self, key: K, ts: i64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn pexpire_at<K, RV, 'a>(&mut self, key: K, ts: i64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn persist<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn persist<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn ttl<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn ttl<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn pttl<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn pttl<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn get_ex<K, RV, 'a>(
&mut self,
key: K,
expire_at: Expiry
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn get_ex<K, RV, 'a>(
&mut self,
key: K,
expire_at: Expiry
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn get_del<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn get_del<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn rename<K, N, RV, 'a>(&mut self, key: K, new_key: N) -> Result<RV, RedisError>
fn rename<K, N, RV, 'a>(&mut self, key: K, new_key: N) -> Result<RV, RedisError>
source§fn rename_nx<K, N, RV, 'a>(
&mut self,
key: K,
new_key: N
) -> Result<RV, RedisError>
fn rename_nx<K, N, RV, 'a>( &mut self, key: K, new_key: N ) -> Result<RV, RedisError>
source§fn unlink<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn unlink<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn append<K, V, RV, 'a>(&mut self, key: K, value: V) -> Result<RV, RedisError>
fn append<K, V, RV, 'a>(&mut self, key: K, value: V) -> Result<RV, RedisError>
source§fn incr<K, V, RV, 'a>(&mut self, key: K, delta: V) -> Result<RV, RedisError>
fn incr<K, V, RV, 'a>(&mut self, key: K, delta: V) -> Result<RV, RedisError>
INCRBY
or INCRBYFLOAT
depending on the type.source§fn decr<K, V, RV, 'a>(&mut self, key: K, delta: V) -> Result<RV, RedisError>
fn decr<K, V, RV, 'a>(&mut self, key: K, delta: V) -> Result<RV, RedisError>
source§fn setbit<K, RV, 'a>(
&mut self,
key: K,
offset: usize,
value: bool
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn setbit<K, RV, 'a>(
&mut self,
key: K,
offset: usize,
value: bool
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn getbit<K, RV, 'a>(&mut self, key: K, offset: usize) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn getbit<K, RV, 'a>(&mut self, key: K, offset: usize) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn bitcount<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn bitcount<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn bitcount_range<K, RV, 'a>(
&mut self,
key: K,
start: usize,
end: usize
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn bitcount_range<K, RV, 'a>(
&mut self,
key: K,
start: usize,
end: usize
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn bit_and<D, S, RV, 'a>(
&mut self,
dstkey: D,
srckeys: S
) -> Result<RV, RedisError>
fn bit_and<D, S, RV, 'a>( &mut self, dstkey: D, srckeys: S ) -> Result<RV, RedisError>
source§fn bit_or<D, S, RV, 'a>(
&mut self,
dstkey: D,
srckeys: S
) -> Result<RV, RedisError>
fn bit_or<D, S, RV, 'a>( &mut self, dstkey: D, srckeys: S ) -> Result<RV, RedisError>
source§fn bit_xor<D, S, RV, 'a>(
&mut self,
dstkey: D,
srckeys: S
) -> Result<RV, RedisError>
fn bit_xor<D, S, RV, 'a>( &mut self, dstkey: D, srckeys: S ) -> Result<RV, RedisError>
source§fn bit_not<D, S, RV, 'a>(
&mut self,
dstkey: D,
srckey: S
) -> Result<RV, RedisError>
fn bit_not<D, S, RV, 'a>( &mut self, dstkey: D, srckey: S ) -> Result<RV, RedisError>
source§fn strlen<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn strlen<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn hget<K, F, RV, 'a>(&mut self, key: K, field: F) -> Result<RV, RedisError>
fn hget<K, F, RV, 'a>(&mut self, key: K, field: F) -> Result<RV, RedisError>
source§fn hdel<K, F, RV, 'a>(&mut self, key: K, field: F) -> Result<RV, RedisError>
fn hdel<K, F, RV, 'a>(&mut self, key: K, field: F) -> Result<RV, RedisError>
source§fn hset<K, F, V, RV, 'a>(
&mut self,
key: K,
field: F,
value: V
) -> Result<RV, RedisError>
fn hset<K, F, V, RV, 'a>( &mut self, key: K, field: F, value: V ) -> Result<RV, RedisError>
source§fn hset_nx<K, F, V, RV, 'a>(
&mut self,
key: K,
field: F,
value: V
) -> Result<RV, RedisError>
fn hset_nx<K, F, V, RV, 'a>( &mut self, key: K, field: F, value: V ) -> Result<RV, RedisError>
source§fn hset_multiple<K, F, V, RV, 'a>(
&mut self,
key: K,
items: &'a [(F, V)]
) -> Result<RV, RedisError>
fn hset_multiple<K, F, V, RV, 'a>( &mut self, key: K, items: &'a [(F, V)] ) -> Result<RV, RedisError>
source§fn hincr<K, F, D, RV, 'a>(
&mut self,
key: K,
field: F,
delta: D
) -> Result<RV, RedisError>
fn hincr<K, F, D, RV, 'a>( &mut self, key: K, field: F, delta: D ) -> Result<RV, RedisError>
source§fn hexists<K, F, RV, 'a>(&mut self, key: K, field: F) -> Result<RV, RedisError>
fn hexists<K, F, RV, 'a>(&mut self, key: K, field: F) -> Result<RV, RedisError>
source§fn hkeys<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn hkeys<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn hvals<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn hvals<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn hgetall<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn hgetall<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn hlen<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn hlen<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn blmove<S, D, RV, 'a>(
&mut self,
srckey: S,
dstkey: D,
src_dir: Direction,
dst_dir: Direction,
timeout: f64
) -> Result<RV, RedisError>
fn blmove<S, D, RV, 'a>( &mut self, srckey: S, dstkey: D, src_dir: Direction, dst_dir: Direction, timeout: f64 ) -> Result<RV, RedisError>
source§fn blmpop<K, RV, 'a>(
&mut self,
timeout: f64,
numkeys: usize,
key: K,
dir: Direction,
count: usize
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn blmpop<K, RV, 'a>(
&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.source§fn blpop<K, RV, 'a>(&mut self, key: K, timeout: f64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn blpop<K, RV, 'a>(&mut self, key: K, timeout: f64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn brpop<K, RV, 'a>(&mut self, key: K, timeout: f64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn brpop<K, RV, 'a>(&mut self, key: K, timeout: f64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn brpoplpush<S, D, RV, 'a>(
&mut self,
srckey: S,
dstkey: D,
timeout: f64
) -> Result<RV, RedisError>
fn brpoplpush<S, D, RV, 'a>( &mut self, srckey: S, dstkey: D, timeout: f64 ) -> Result<RV, RedisError>
source§fn lindex<K, RV, 'a>(&mut self, key: K, index: isize) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn lindex<K, RV, 'a>(&mut self, key: K, index: isize) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn linsert_before<K, P, V, RV, 'a>(
&mut self,
key: K,
pivot: P,
value: V
) -> Result<RV, RedisError>
fn linsert_before<K, P, V, RV, 'a>( &mut self, key: K, pivot: P, value: V ) -> Result<RV, RedisError>
source§fn linsert_after<K, P, V, RV, 'a>(
&mut self,
key: K,
pivot: P,
value: V
) -> Result<RV, RedisError>
fn linsert_after<K, P, V, RV, 'a>( &mut self, key: K, pivot: P, value: V ) -> Result<RV, RedisError>
source§fn llen<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn llen<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn lmove<S, D, RV, 'a>(
&mut self,
srckey: S,
dstkey: D,
src_dir: Direction,
dst_dir: Direction
) -> Result<RV, RedisError>
fn lmove<S, D, RV, 'a>( &mut self, srckey: S, dstkey: D, src_dir: Direction, dst_dir: Direction ) -> Result<RV, RedisError>
source§fn lmpop<K, RV, 'a>(
&mut self,
numkeys: usize,
key: K,
dir: Direction,
count: usize
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn lmpop<K, RV, 'a>(
&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.source§fn lpop<K, RV, 'a>(
&mut self,
key: K,
count: Option<NonZeroUsize>
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn lpop<K, RV, 'a>(
&mut self,
key: K,
count: Option<NonZeroUsize>
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
count
first elements of the list stored at key. Read moresource§fn lpos<K, V, RV, 'a>(
&mut self,
key: K,
value: V,
options: LposOptions
) -> Result<RV, RedisError>
fn lpos<K, V, RV, 'a>( &mut self, key: K, value: V, options: LposOptions ) -> Result<RV, RedisError>
source§fn lpush<K, V, RV, 'a>(&mut self, key: K, value: V) -> Result<RV, RedisError>
fn lpush<K, V, RV, 'a>(&mut self, key: K, value: V) -> Result<RV, RedisError>
source§fn lpush_exists<K, V, RV, 'a>(
&mut self,
key: K,
value: V
) -> Result<RV, RedisError>
fn lpush_exists<K, V, RV, 'a>( &mut self, key: K, value: V ) -> Result<RV, RedisError>
source§fn lrange<K, RV, 'a>(
&mut self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn lrange<K, RV, 'a>(
&mut self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn lrem<K, V, RV, 'a>(
&mut self,
key: K,
count: isize,
value: V
) -> Result<RV, RedisError>
fn lrem<K, V, RV, 'a>( &mut self, key: K, count: isize, value: V ) -> Result<RV, RedisError>
source§fn ltrim<K, RV, 'a>(
&mut self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn ltrim<K, RV, 'a>(
&mut self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn lset<K, V, RV, 'a>(
&mut self,
key: K,
index: isize,
value: V
) -> Result<RV, RedisError>
fn lset<K, V, RV, 'a>( &mut self, key: K, index: isize, value: V ) -> Result<RV, RedisError>
source§fn rpop<K, RV, 'a>(
&mut self,
key: K,
count: Option<NonZeroUsize>
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn rpop<K, RV, 'a>(
&mut self,
key: K,
count: Option<NonZeroUsize>
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
count
last elements of the list stored at key Read moresource§fn rpoplpush<K, D, RV, 'a>(
&mut self,
key: K,
dstkey: D
) -> Result<RV, RedisError>
fn rpoplpush<K, D, RV, 'a>( &mut self, key: K, dstkey: D ) -> Result<RV, RedisError>
source§fn rpush<K, V, RV, 'a>(&mut self, key: K, value: V) -> Result<RV, RedisError>
fn rpush<K, V, RV, 'a>(&mut self, key: K, value: V) -> Result<RV, RedisError>
source§fn rpush_exists<K, V, RV, 'a>(
&mut self,
key: K,
value: V
) -> Result<RV, RedisError>
fn rpush_exists<K, V, RV, 'a>( &mut self, key: K, value: V ) -> Result<RV, RedisError>
source§fn sadd<K, M, RV, 'a>(&mut self, key: K, member: M) -> Result<RV, RedisError>
fn sadd<K, M, RV, 'a>(&mut self, key: K, member: M) -> Result<RV, RedisError>
source§fn scard<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn scard<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn sdiff<K, RV, 'a>(&mut self, keys: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn sdiff<K, RV, 'a>(&mut self, keys: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn sdiffstore<D, K, RV, 'a>(
&mut self,
dstkey: D,
keys: K
) -> Result<RV, RedisError>
fn sdiffstore<D, K, RV, 'a>( &mut self, dstkey: D, keys: K ) -> Result<RV, RedisError>
source§fn sinter<K, RV, 'a>(&mut self, keys: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn sinter<K, RV, 'a>(&mut self, keys: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn sinterstore<D, K, RV, 'a>(
&mut self,
dstkey: D,
keys: K
) -> Result<RV, RedisError>
fn sinterstore<D, K, RV, 'a>( &mut self, dstkey: D, keys: K ) -> Result<RV, RedisError>
source§fn sismember<K, M, RV, 'a>(
&mut self,
key: K,
member: M
) -> Result<RV, RedisError>
fn sismember<K, M, RV, 'a>( &mut self, key: K, member: M ) -> Result<RV, RedisError>
source§fn smembers<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn smembers<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn smove<S, D, M, RV, 'a>(
&mut self,
srckey: S,
dstkey: D,
member: M
) -> Result<RV, RedisError>
fn smove<S, D, M, RV, 'a>( &mut self, srckey: S, dstkey: D, member: M ) -> Result<RV, RedisError>
source§fn spop<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn spop<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn srandmember<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn srandmember<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn srandmember_multiple<K, RV, 'a>(
&mut self,
key: K,
count: usize
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn srandmember_multiple<K, RV, 'a>(
&mut self,
key: K,
count: usize
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn srem<K, M, RV, 'a>(&mut self, key: K, member: M) -> Result<RV, RedisError>
fn srem<K, M, RV, 'a>(&mut self, key: K, member: M) -> Result<RV, RedisError>
source§fn sunion<K, RV, 'a>(&mut self, keys: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn sunion<K, RV, 'a>(&mut self, keys: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn sunionstore<D, K, RV, 'a>(
&mut self,
dstkey: D,
keys: K
) -> Result<RV, RedisError>
fn sunionstore<D, K, RV, 'a>( &mut self, dstkey: D, keys: K ) -> Result<RV, RedisError>
source§fn zadd<K, S, M, RV, 'a>(
&mut self,
key: K,
member: M,
score: S
) -> Result<RV, RedisError>
fn zadd<K, S, M, RV, 'a>( &mut self, key: K, member: M, score: S ) -> Result<RV, RedisError>
source§fn zadd_multiple<K, S, M, RV, 'a>(
&mut self,
key: K,
items: &'a [(S, M)]
) -> Result<RV, RedisError>
fn zadd_multiple<K, S, M, RV, 'a>( &mut self, key: K, items: &'a [(S, M)] ) -> Result<RV, RedisError>
source§fn zcard<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zcard<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn zcount<K, M, MM, RV, 'a>(
&mut self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError>
fn zcount<K, M, MM, RV, 'a>( &mut self, key: K, min: M, max: MM ) -> Result<RV, RedisError>
source§fn zincr<K, M, D, RV, 'a>(
&mut self,
key: K,
member: M,
delta: D
) -> Result<RV, RedisError>
fn zincr<K, M, D, RV, 'a>( &mut self, key: K, member: M, delta: D ) -> Result<RV, RedisError>
source§fn zinterstore<D, K, RV, 'a>(
&mut self,
dstkey: D,
keys: &'a [K]
) -> Result<RV, RedisError>
fn zinterstore<D, K, RV, 'a>( &mut self, dstkey: D, keys: &'a [K] ) -> Result<RV, RedisError>
source§fn zinterstore_min<D, K, RV, 'a>(
&mut self,
dstkey: D,
keys: &'a [K]
) -> Result<RV, RedisError>
fn zinterstore_min<D, K, RV, 'a>( &mut self, dstkey: D, keys: &'a [K] ) -> Result<RV, RedisError>
source§fn zinterstore_max<D, K, RV, 'a>(
&mut self,
dstkey: D,
keys: &'a [K]
) -> Result<RV, RedisError>
fn zinterstore_max<D, K, RV, 'a>( &mut self, dstkey: D, keys: &'a [K] ) -> Result<RV, RedisError>
source§fn zinterstore_weights<D, K, W, RV, 'a>(
&mut self,
dstkey: D,
keys: &'a [(K, W)]
) -> Result<RV, RedisError>
fn zinterstore_weights<D, K, W, RV, 'a>( &mut self, dstkey: D, keys: &'a [(K, W)] ) -> Result<RV, RedisError>
Commands::zinterstore
, but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.source§fn zinterstore_min_weights<D, K, W, RV, 'a>(
&mut self,
dstkey: D,
keys: &'a [(K, W)]
) -> Result<RV, RedisError>
fn zinterstore_min_weights<D, K, W, RV, 'a>( &mut self, dstkey: D, keys: &'a [(K, W)] ) -> Result<RV, RedisError>
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.source§fn zinterstore_max_weights<D, K, W, RV, 'a>(
&mut self,
dstkey: D,
keys: &'a [(K, W)]
) -> Result<RV, RedisError>
fn zinterstore_max_weights<D, K, W, RV, 'a>( &mut self, dstkey: D, keys: &'a [(K, W)] ) -> Result<RV, RedisError>
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.source§fn zlexcount<K, M, MM, RV, 'a>(
&mut self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError>
fn zlexcount<K, M, MM, RV, 'a>( &mut self, key: K, min: M, max: MM ) -> Result<RV, RedisError>
source§fn bzpopmax<K, RV, 'a>(
&mut self,
key: K,
timeout: f64
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn bzpopmax<K, RV, 'a>(
&mut self,
key: K,
timeout: f64
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn zpopmax<K, RV, 'a>(&mut self, key: K, count: isize) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zpopmax<K, RV, 'a>(&mut self, key: K, count: isize) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn bzpopmin<K, RV, 'a>(
&mut self,
key: K,
timeout: f64
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn bzpopmin<K, RV, 'a>(
&mut self,
key: K,
timeout: f64
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn zpopmin<K, RV, 'a>(&mut self, key: K, count: isize) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zpopmin<K, RV, 'a>(&mut self, key: K, count: isize) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn bzmpop_max<K, RV, 'a>(
&mut self,
timeout: f64,
keys: &'a [K],
count: isize
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn bzmpop_max<K, RV, 'a>(
&mut self,
timeout: f64,
keys: &'a [K],
count: isize
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn zmpop_max<K, RV, 'a>(
&mut self,
keys: &'a [K],
count: isize
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zmpop_max<K, RV, 'a>(
&mut self,
keys: &'a [K],
count: isize
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn bzmpop_min<K, RV, 'a>(
&mut self,
timeout: f64,
keys: &'a [K],
count: isize
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn bzmpop_min<K, RV, 'a>(
&mut self,
timeout: f64,
keys: &'a [K],
count: isize
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn zmpop_min<K, RV, 'a>(
&mut self,
keys: &'a [K],
count: isize
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zmpop_min<K, RV, 'a>(
&mut self,
keys: &'a [K],
count: isize
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn zrandmember<K, RV, 'a>(
&mut self,
key: K,
count: Option<isize>
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zrandmember<K, RV, 'a>(
&mut self,
key: K,
count: Option<isize>
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
count == None
)source§fn zrandmember_withscores<K, RV, 'a>(
&mut self,
key: K,
count: isize
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zrandmember_withscores<K, RV, 'a>(
&mut self,
key: K,
count: isize
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn zrange<K, RV, 'a>(
&mut self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zrange<K, RV, 'a>(
&mut self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn zrange_withscores<K, RV, 'a>(
&mut self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zrange_withscores<K, RV, 'a>(
&mut self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn zrangebylex<K, M, MM, RV, 'a>(
&mut self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError>
fn zrangebylex<K, M, MM, RV, 'a>( &mut self, key: K, min: M, max: MM ) -> Result<RV, RedisError>
source§fn zrangebylex_limit<K, M, MM, RV, 'a>(
&mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Result<RV, RedisError>
fn zrangebylex_limit<K, M, MM, RV, 'a>( &mut self, key: K, min: M, max: MM, offset: isize, count: isize ) -> Result<RV, RedisError>
source§fn zrevrangebylex<K, MM, M, RV, 'a>(
&mut self,
key: K,
max: MM,
min: M
) -> Result<RV, RedisError>
fn zrevrangebylex<K, MM, M, RV, 'a>( &mut self, key: K, max: MM, min: M ) -> Result<RV, RedisError>
source§fn zrevrangebylex_limit<K, MM, M, RV, 'a>(
&mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Result<RV, RedisError>
fn zrevrangebylex_limit<K, MM, M, RV, 'a>( &mut self, key: K, max: MM, min: M, offset: isize, count: isize ) -> Result<RV, RedisError>
source§fn zrangebyscore<K, M, MM, RV, 'a>(
&mut self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError>
fn zrangebyscore<K, M, MM, RV, 'a>( &mut self, key: K, min: M, max: MM ) -> Result<RV, RedisError>
source§fn zrangebyscore_withscores<K, M, MM, RV, 'a>(
&mut self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError>
fn zrangebyscore_withscores<K, M, MM, RV, 'a>( &mut self, key: K, min: M, max: MM ) -> Result<RV, RedisError>
source§fn zrangebyscore_limit<K, M, MM, RV, 'a>(
&mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Result<RV, RedisError>
fn zrangebyscore_limit<K, M, MM, RV, 'a>( &mut self, key: K, min: M, max: MM, offset: isize, count: isize ) -> Result<RV, RedisError>
source§fn zrangebyscore_limit_withscores<K, M, MM, RV, 'a>(
&mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize
) -> Result<RV, RedisError>
fn zrangebyscore_limit_withscores<K, M, MM, RV, 'a>( &mut self, key: K, min: M, max: MM, offset: isize, count: isize ) -> Result<RV, RedisError>
source§fn zrank<K, M, RV, 'a>(&mut self, key: K, member: M) -> Result<RV, RedisError>
fn zrank<K, M, RV, 'a>(&mut self, key: K, member: M) -> Result<RV, RedisError>
source§fn zrem<K, M, RV, 'a>(&mut self, key: K, members: M) -> Result<RV, RedisError>
fn zrem<K, M, RV, 'a>(&mut self, key: K, members: M) -> Result<RV, RedisError>
source§fn zrembylex<K, M, MM, RV, 'a>(
&mut self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError>
fn zrembylex<K, M, MM, RV, 'a>( &mut self, key: K, min: M, max: MM ) -> Result<RV, RedisError>
source§fn zremrangebyrank<K, RV, 'a>(
&mut self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zremrangebyrank<K, RV, 'a>(
&mut self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn zrembyscore<K, M, MM, RV, 'a>(
&mut self,
key: K,
min: M,
max: MM
) -> Result<RV, RedisError>
fn zrembyscore<K, M, MM, RV, 'a>( &mut self, key: K, min: M, max: MM ) -> Result<RV, RedisError>
source§fn zrevrange<K, RV, 'a>(
&mut self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zrevrange<K, RV, 'a>(
&mut self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn zrevrange_withscores<K, RV, 'a>(
&mut self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zrevrange_withscores<K, RV, 'a>(
&mut self,
key: K,
start: isize,
stop: isize
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn zrevrangebyscore<K, MM, M, RV, 'a>(
&mut self,
key: K,
max: MM,
min: M
) -> Result<RV, RedisError>
fn zrevrangebyscore<K, MM, M, RV, 'a>( &mut self, key: K, max: MM, min: M ) -> Result<RV, RedisError>
source§fn zrevrangebyscore_withscores<K, MM, M, RV, 'a>(
&mut self,
key: K,
max: MM,
min: M
) -> Result<RV, RedisError>
fn zrevrangebyscore_withscores<K, MM, M, RV, 'a>( &mut self, key: K, max: MM, min: M ) -> Result<RV, RedisError>
source§fn zrevrangebyscore_limit<K, MM, M, RV, 'a>(
&mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Result<RV, RedisError>
fn zrevrangebyscore_limit<K, MM, M, RV, 'a>( &mut self, key: K, max: MM, min: M, offset: isize, count: isize ) -> Result<RV, RedisError>
source§fn zrevrangebyscore_limit_withscores<K, MM, M, RV, 'a>(
&mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize
) -> Result<RV, RedisError>
fn zrevrangebyscore_limit_withscores<K, MM, M, RV, 'a>( &mut self, key: K, max: MM, min: M, offset: isize, count: isize ) -> Result<RV, RedisError>
source§fn zrevrank<K, M, RV, 'a>(
&mut self,
key: K,
member: M
) -> Result<RV, RedisError>
fn zrevrank<K, M, RV, 'a>( &mut self, key: K, member: M ) -> Result<RV, RedisError>
source§fn zscore<K, M, RV, 'a>(&mut self, key: K, member: M) -> Result<RV, RedisError>
fn zscore<K, M, RV, 'a>(&mut self, key: K, member: M) -> Result<RV, RedisError>
source§fn zscore_multiple<K, M, RV, 'a>(
&mut self,
key: K,
members: &'a [M]
) -> Result<RV, RedisError>
fn zscore_multiple<K, M, RV, 'a>( &mut self, key: K, members: &'a [M] ) -> Result<RV, RedisError>
source§fn zunionstore<D, K, RV, 'a>(
&mut self,
dstkey: D,
keys: &'a [K]
) -> Result<RV, RedisError>
fn zunionstore<D, K, RV, 'a>( &mut self, dstkey: D, keys: &'a [K] ) -> Result<RV, RedisError>
source§fn zunionstore_min<D, K, RV, 'a>(
&mut self,
dstkey: D,
keys: &'a [K]
) -> Result<RV, RedisError>
fn zunionstore_min<D, K, RV, 'a>( &mut self, dstkey: D, keys: &'a [K] ) -> Result<RV, RedisError>
source§fn zunionstore_max<D, K, RV, 'a>(
&mut self,
dstkey: D,
keys: &'a [K]
) -> Result<RV, RedisError>
fn zunionstore_max<D, K, RV, 'a>( &mut self, dstkey: D, keys: &'a [K] ) -> Result<RV, RedisError>
source§fn zunionstore_weights<D, K, W, RV, 'a>(
&mut self,
dstkey: D,
keys: &'a [(K, W)]
) -> Result<RV, RedisError>
fn zunionstore_weights<D, K, W, RV, 'a>( &mut self, dstkey: D, keys: &'a [(K, W)] ) -> Result<RV, RedisError>
Commands::zunionstore
, but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.source§fn zunionstore_min_weights<D, K, W, RV, 'a>(
&mut self,
dstkey: D,
keys: &'a [(K, W)]
) -> Result<RV, RedisError>
fn zunionstore_min_weights<D, K, W, RV, 'a>( &mut self, dstkey: D, keys: &'a [(K, W)] ) -> Result<RV, RedisError>
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.source§fn zunionstore_max_weights<D, K, W, RV, 'a>(
&mut self,
dstkey: D,
keys: &'a [(K, W)]
) -> Result<RV, RedisError>
fn zunionstore_max_weights<D, K, W, RV, 'a>( &mut self, dstkey: D, keys: &'a [(K, W)] ) -> Result<RV, RedisError>
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.source§fn pfadd<K, E, RV, 'a>(&mut self, key: K, element: E) -> Result<RV, RedisError>
fn pfadd<K, E, RV, 'a>(&mut self, key: K, element: E) -> Result<RV, RedisError>
source§fn pfcount<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn pfcount<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn pfmerge<D, S, RV, 'a>(
&mut self,
dstkey: D,
srckeys: S
) -> Result<RV, RedisError>
fn pfmerge<D, S, RV, 'a>( &mut self, dstkey: D, srckeys: S ) -> Result<RV, RedisError>
source§fn publish<K, E, RV, 'a>(
&mut self,
channel: K,
message: E
) -> Result<RV, RedisError>
fn publish<K, E, RV, 'a>( &mut self, channel: K, message: E ) -> Result<RV, RedisError>
source§fn object_encoding<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn object_encoding<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn object_idletime<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn object_idletime<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn object_freq<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn object_freq<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn object_refcount<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn object_refcount<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn acl_load<RV, 'a>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn acl_load<RV, 'a>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
source§fn acl_save<RV, 'a>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn acl_save<RV, 'a>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
source§fn acl_list<RV, 'a>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn acl_list<RV, 'a>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
source§fn acl_users<RV, 'a>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn acl_users<RV, 'a>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
source§fn acl_getuser<K, RV, 'a>(&mut self, username: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn acl_getuser<K, RV, 'a>(&mut self, username: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn acl_setuser<K, RV, 'a>(&mut self, username: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn acl_setuser<K, RV, 'a>(&mut self, username: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn acl_setuser_rules<K, RV, 'a>(
&mut self,
username: K,
rules: &'a [Rule]
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn acl_setuser_rules<K, RV, 'a>(
&mut self,
username: K,
rules: &'a [Rule]
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn acl_deluser<K, RV, 'a>(
&mut self,
usernames: &'a [K]
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn acl_deluser<K, RV, 'a>(
&mut self,
usernames: &'a [K]
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn acl_cat<RV, 'a>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn acl_cat<RV, 'a>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
source§fn acl_cat_categoryname<K, RV, 'a>(
&mut self,
categoryname: K
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn acl_cat_categoryname<K, RV, 'a>(
&mut self,
categoryname: K
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn acl_genpass<RV, 'a>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn acl_genpass<RV, 'a>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
source§fn acl_genpass_bits<RV, 'a>(&mut self, bits: isize) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn acl_genpass_bits<RV, 'a>(&mut self, bits: isize) -> Result<RV, RedisError>where
RV: FromRedisValue,
source§fn acl_whoami<RV, 'a>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn acl_whoami<RV, 'a>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
source§fn acl_log<RV, 'a>(&mut self, count: isize) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn acl_log<RV, 'a>(&mut self, count: isize) -> Result<RV, RedisError>where
RV: FromRedisValue,
source§fn acl_log_reset<RV, 'a>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn acl_log_reset<RV, 'a>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
source§fn acl_help<RV, 'a>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn acl_help<RV, 'a>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
source§fn geo_add<K, M, RV, 'a>(
&mut self,
key: K,
members: M
) -> Result<RV, RedisError>
fn geo_add<K, M, RV, 'a>( &mut self, key: K, members: M ) -> Result<RV, RedisError>
source§fn geo_dist<K, M1, M2, RV, 'a>(
&mut self,
key: K,
member1: M1,
member2: M2,
unit: Unit
) -> Result<RV, RedisError>
fn geo_dist<K, M1, M2, RV, 'a>( &mut self, key: K, member1: M1, member2: M2, unit: Unit ) -> Result<RV, RedisError>
source§fn geo_hash<K, M, RV, 'a>(
&mut self,
key: K,
members: M
) -> Result<RV, RedisError>
fn geo_hash<K, M, RV, 'a>( &mut self, key: K, members: M ) -> Result<RV, RedisError>
source§fn geo_pos<K, M, RV, 'a>(
&mut self,
key: K,
members: M
) -> Result<RV, RedisError>
fn geo_pos<K, M, RV, 'a>( &mut self, key: K, members: M ) -> Result<RV, RedisError>
source§fn geo_radius<K, RV, 'a>(
&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<K, RV, 'a>(
&mut self,
key: K,
longitude: f64,
latitude: f64,
radius: f64,
unit: Unit,
options: RadiusOptions
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn geo_radius_by_member<K, M, RV, 'a>(
&mut self,
key: K,
member: M,
radius: f64,
unit: Unit,
options: RadiusOptions
) -> Result<RV, RedisError>
fn geo_radius_by_member<K, M, RV, 'a>( &mut self, key: K, member: M, radius: f64, unit: Unit, options: RadiusOptions ) -> Result<RV, RedisError>
member
. The
member itself is always contained in the results.source§fn xack<K, G, I, RV, 'a>(
&mut self,
key: K,
group: G,
ids: &'a [I]
) -> Result<RV, RedisError>
fn xack<K, G, I, RV, 'a>( &mut self, key: K, group: G, ids: &'a [I] ) -> Result<RV, RedisError>
source§fn xadd<K, ID, F, V, RV, 'a>(
&mut self,
key: K,
id: ID,
items: &'a [(F, V)]
) -> Result<RV, RedisError>
fn xadd<K, ID, F, V, RV, 'a>( &mut self, key: K, id: ID, items: &'a [(F, V)] ) -> Result<RV, RedisError>
source§fn xadd_map<K, ID, BTM, RV, 'a>(
&mut self,
key: K,
id: ID,
map: BTM
) -> Result<RV, RedisError>
fn xadd_map<K, ID, BTM, RV, 'a>( &mut self, key: K, id: ID, map: BTM ) -> Result<RV, RedisError>
key
.
Use *
as the id
for the current timestamp. Read moresource§fn xadd_maxlen<K, ID, F, V, RV, 'a>(
&mut self,
key: K,
maxlen: StreamMaxlen,
id: ID,
items: &'a [(F, V)]
) -> Result<RV, RedisError>
fn xadd_maxlen<K, ID, F, V, RV, 'a>( &mut self, key: K, maxlen: StreamMaxlen, id: ID, items: &'a [(F, V)] ) -> Result<RV, RedisError>
source§fn xadd_maxlen_map<K, ID, BTM, RV, 'a>(
&mut self,
key: K,
maxlen: StreamMaxlen,
id: ID,
map: BTM
) -> Result<RV, RedisError>
fn xadd_maxlen_map<K, ID, BTM, RV, 'a>( &mut self, key: K, maxlen: StreamMaxlen, id: ID, map: BTM ) -> Result<RV, RedisError>
source§fn xclaim<K, G, C, MIT, ID, RV, 'a>(
&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<K, G, C, MIT, ID, RV, 'a>(
&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,
source§fn xclaim_options<K, G, C, MIT, ID, RV, 'a>(
&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<K, G, C, MIT, ID, RV, 'a>(
&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,
source§fn xgroup_create<K, G, ID, RV, 'a>(
&mut self,
key: K,
group: G,
id: ID
) -> Result<RV, RedisError>
fn xgroup_create<K, G, ID, RV, 'a>( &mut self, key: K, group: G, id: ID ) -> Result<RV, RedisError>
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 moresource§fn xgroup_create_mkstream<K, G, ID, RV, 'a>(
&mut self,
key: K,
group: G,
id: ID
) -> Result<RV, RedisError>
fn xgroup_create_mkstream<K, G, ID, RV, 'a>( &mut self, key: K, group: G, id: ID ) -> Result<RV, RedisError>
group
which makes the stream if it doesn’t exist. Read moresource§fn xgroup_setid<K, G, ID, RV, 'a>(
&mut self,
key: K,
group: G,
id: ID
) -> Result<RV, RedisError>
fn xgroup_setid<K, G, ID, RV, 'a>( &mut self, key: K, group: G, id: ID ) -> Result<RV, RedisError>
source§fn xgroup_destroy<K, G, RV, 'a>(
&mut self,
key: K,
group: G
) -> Result<RV, RedisError>
fn xgroup_destroy<K, G, RV, 'a>( &mut self, key: K, group: G ) -> Result<RV, RedisError>
source§fn xgroup_delconsumer<K, G, C, RV, 'a>(
&mut self,
key: K,
group: G,
consumer: C
) -> Result<RV, RedisError>
fn xgroup_delconsumer<K, G, C, RV, 'a>( &mut self, key: K, group: G, consumer: C ) -> Result<RV, RedisError>
source§fn xinfo_consumers<K, G, RV, 'a>(
&mut self,
key: K,
group: G
) -> Result<RV, RedisError>
fn xinfo_consumers<K, G, RV, 'a>( &mut self, key: K, group: G ) -> Result<RV, RedisError>
group
.
Take note of the StreamInfoConsumersReply return type. Read moresource§fn xinfo_groups<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn xinfo_groups<K, RV, 'a>(&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 moresource§fn xinfo_stream<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn xinfo_stream<K, RV, 'a>(&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 moresource§fn xlen<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn xlen<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
key
. Read moresource§fn xpending<K, G, RV, 'a>(&mut self, key: K, group: G) -> Result<RV, RedisError>
fn xpending<K, G, RV, 'a>(&mut self, key: K, group: G) -> Result<RV, RedisError>
key
and consumer group
and it
returns details about which consumers have pending messages
that haven’t been acked. Read moresource§fn xpending_count<K, G, S, E, C, RV, 'a>(
&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<K, G, S, E, C, RV, 'a>(
&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,
source§fn xpending_consumer_count<K, G, S, E, C, CN, RV, 'a>(
&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<K, G, S, E, C, CN, RV, 'a>(
&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,
source§fn xrange<K, S, E, RV, 'a>(
&mut self,
key: K,
start: S,
end: E
) -> Result<RV, RedisError>
fn xrange<K, S, E, RV, 'a>( &mut self, key: K, start: S, end: E ) -> Result<RV, RedisError>
key
. Read moresource§fn xrange_all<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn xrange_all<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
key
.
Use with caution! Read moresource§fn xrange_count<K, S, E, C, RV, 'a>(
&mut self,
key: K,
start: S,
end: E,
count: C
) -> Result<RV, RedisError>
fn xrange_count<K, S, E, C, RV, 'a>( &mut self, key: K, start: S, end: E, count: C ) -> Result<RV, RedisError>
key
. Read moresource§fn xread<K, ID, RV, 'a>(
&mut self,
keys: &'a [K],
ids: &'a [ID]
) -> Result<RV, RedisError>
fn xread<K, ID, RV, 'a>( &mut self, keys: &'a [K], ids: &'a [ID] ) -> Result<RV, RedisError>
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 moresource§fn xread_options<K, ID, RV, 'a>(
&mut self,
keys: &'a [K],
ids: &'a [ID],
options: &'a StreamReadOptions
) -> Result<RV, RedisError>
fn xread_options<K, ID, RV, 'a>( &mut self, keys: &'a [K], ids: &'a [ID], options: &'a StreamReadOptions ) -> Result<RV, RedisError>
source§fn xrevrange<K, E, S, RV, 'a>(
&mut self,
key: K,
end: E,
start: S
) -> Result<RV, RedisError>
fn xrevrange<K, E, S, RV, 'a>( &mut self, key: K, end: E, start: S ) -> Result<RV, RedisError>
source§fn xrevrange_all<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn xrevrange_all<K, RV, 'a>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
source§fn xrevrange_count<K, E, S, C, RV, 'a>(
&mut self,
key: K,
end: E,
start: S,
count: C
) -> Result<RV, RedisError>
fn xrevrange_count<K, E, S, C, RV, 'a>( &mut self, key: K, end: E, start: S, count: C ) -> Result<RV, RedisError>
source§fn xtrim<K, RV, 'a>(
&mut self,
key: K,
maxlen: StreamMaxlen
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn xtrim<K, RV, 'a>(
&mut self,
key: K,
maxlen: StreamMaxlen
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
key
to a MAXLEN count. Read moresource§fn scan<RV>(&mut self) -> Result<Iter<'_, RV>, RedisError>where
RV: FromRedisValue,
fn scan<RV>(&mut self) -> Result<Iter<'_, RV>, RedisError>where
RV: FromRedisValue,
source§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,
source§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,
source§fn hscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P
) -> Result<Iter<'_, RV>, RedisError>
fn hscan_match<K, P, RV>( &mut self, key: K, pattern: P ) -> Result<Iter<'_, RV>, RedisError>
source§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,
source§fn sscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P
) -> Result<Iter<'_, RV>, RedisError>
fn sscan_match<K, P, RV>( &mut self, key: K, pattern: P ) -> Result<Iter<'_, RV>, RedisError>
source§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,
source§fn zscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P
) -> Result<Iter<'_, RV>, RedisError>
fn zscan_match<K, P, RV>( &mut self, key: K, pattern: P ) -> Result<Iter<'_, RV>, RedisError>
source§impl<Q, K> Comparable<K> for Q
impl<Q, K> Comparable<K> for Q
source§impl<C, T> ConnectionLike for Twhere
C: ConnectionLike,
T: DerefMut<Target = C>,
impl<C, T> ConnectionLike for Twhere
C: ConnectionLike,
T: DerefMut<Target = C>,
source§fn req_packed_command(&mut self, cmd: &[u8]) -> Result<Value, RedisError>
fn req_packed_command(&mut self, cmd: &[u8]) -> Result<Value, RedisError>
source§fn req_packed_commands(
&mut self,
cmd: &[u8],
offset: usize,
count: usize
) -> Result<Vec<Value>, RedisError>
fn req_packed_commands( &mut self, cmd: &[u8], offset: usize, count: usize ) -> Result<Vec<Value>, RedisError>
count
responses from it. This is used to implement
pipelining.source§fn req_command(&mut self, cmd: &Cmd) -> Result<Value, RedisError>
fn req_command(&mut self, cmd: &Cmd) -> Result<Value, RedisError>
source§fn get_db(&self) -> i64
fn get_db(&self) -> i64
fn supports_pipelining(&self) -> bool
source§fn check_connection(&mut self) -> bool
fn check_connection(&mut self) -> bool
PING
internally).source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
source§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key
and return true
if they are equal.