Enum reool::ConnectionFlavour[−][src]

pub enum ConnectionFlavour {
    RedisRs(Connection, Arc<String>),
}

Variants

RedisRs(Connection, Arc<String>)

Trait Implementations

`impl ConnectionLike for ConnectionFlavour`[src]

`fn req_packed_command<'a>(&'a mut self, cmd: &'a Cmd) -> RedisFuture<'a, Value>`[src]

`fn req_packed_commands<'a>( &'a mut self, pipeline: &'a Pipeline, offset: usize, count: usize ) -> RedisFuture<'a, Vec<Value>>`[src]

`fn get_db(&self) -> i64`[src]

`impl Poolable for ConnectionFlavour`[src]

`fn connected_to(&self) -> &str`[src]

Auto Trait Implementations

`impl !RefUnwindSafe for ConnectionFlavour`

`impl Send for ConnectionFlavour`

`impl Sync for ConnectionFlavour`

`impl Unpin for ConnectionFlavour`

`impl !UnwindSafe for ConnectionFlavour`

Blanket Implementations

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`pub fn type_id(&self) -> TypeId`[src]

`impl<T> AsyncCommands for T where T: ConnectionLike + Send,` [src]

`pub fn get<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn keys<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn set<'a, K, V, RV>( &'a mut self, key: K, value: V ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn set_multiple<'a, K, V, RV>( &'a mut self, items: &'a [(K, V)] ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn set_ex<'a, K, V, RV>( &'a mut self, key: K, value: V, seconds: usize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn pset_ex<'a, K, V, RV>( &'a mut self, key: K, value: V, milliseconds: usize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn set_nx<'a, K, V, RV>( &'a mut self, key: K, value: V ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn mset_nx<'a, K, V, RV>( &'a mut self, items: &'a [(K, V)] ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn getset<'a, K, V, RV>( &'a mut self, key: K, value: V ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn getrange<'a, K, RV>( &'a mut self, key: K, from: isize, to: isize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn setrange<'a, K, V, RV>( &'a mut self, key: K, offset: isize, value: V ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn del<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn exists<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn expire<'a, K, RV>( &'a mut self, key: K, seconds: usize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn expire_at<'a, K, RV>( &'a mut self, key: K, ts: usize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn pexpire<'a, K, RV>( &'a mut self, key: K, ms: usize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn pexpire_at<'a, K, RV>( &'a mut self, key: K, ts: usize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn persist<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn ttl<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn pttl<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn rename<'a, K, RV>( &'a mut self, key: K, new_key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn rename_nx<'a, K, RV>( &'a mut self, key: K, new_key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn unlink<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn append<'a, K, V, RV>( &'a mut self, key: K, value: V ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn incr<'a, K, V, RV>( &'a mut self, key: K, delta: V ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn decr<'a, K, V, RV>( &'a mut self, key: K, delta: V ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn setbit<'a, K, RV>( &'a mut self, key: K, offset: usize, value: bool ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn getbit<'a, K, RV>( &'a mut self, key: K, offset: usize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn bitcount<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn bitcount_range<'a, K, RV>( &'a mut self, key: K, start: usize, end: usize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn bit_and<'a, K, RV>( &'a mut self, dstkey: K, srckeys: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn bit_or<'a, K, RV>( &'a mut self, dstkey: K, srckeys: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn bit_xor<'a, K, RV>( &'a mut self, dstkey: K, srckeys: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn bit_not<'a, K, RV>( &'a mut self, dstkey: K, srckey: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn strlen<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn hget<'a, K, F, RV>( &'a mut self, key: K, field: F ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where F: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn hdel<'a, K, F, RV>( &'a mut self, key: K, field: F ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where F: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn hset<'a, K, F, V, RV>( &'a mut self, key: K, field: F, value: V ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where F: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn hset_nx<'a, K, F, V, RV>( &'a mut self, key: K, field: F, value: V ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where F: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn hset_multiple<'a, K, F, V, RV>( &'a mut self, key: K, items: &'a [(F, V)] ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where F: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn hincr<'a, K, F, D, RV>( &'a mut self, key: K, field: F, delta: D ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where F: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, D: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn hexists<'a, K, F, RV>( &'a mut self, key: K, field: F ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where F: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn hkeys<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn hvals<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn hgetall<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn hlen<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn blpop<'a, K, RV>( &'a mut self, key: K, timeout: usize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn brpop<'a, K, RV>( &'a mut self, key: K, timeout: usize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn brpoplpush<'a, K, RV>( &'a mut self, srckey: K, dstkey: K, timeout: usize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn lindex<'a, K, RV>( &'a mut self, key: K, index: isize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn linsert_before<'a, K, P, V, RV>( &'a mut self, key: K, pivot: P, value: V ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where P: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn linsert_after<'a, K, P, V, RV>( &'a mut self, key: K, pivot: P, value: V ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where P: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn llen<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn lpop<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn lpos<'a, K, V, RV>( &'a mut self, key: K, value: V, options: LposOptions ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn lpush<'a, K, V, RV>( &'a mut self, key: K, value: V ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn lpush_exists<'a, K, V, RV>( &'a mut self, key: K, value: V ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn lrange<'a, K, RV>( &'a mut self, key: K, start: isize, stop: isize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn lrem<'a, K, V, RV>( &'a mut self, key: K, count: isize, value: V ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn ltrim<'a, K, RV>( &'a mut self, key: K, start: isize, stop: isize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn lset<'a, K, V, RV>( &'a mut self, key: K, index: isize, value: V ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn rpop<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn rpoplpush<'a, K, RV>( &'a mut self, key: K, dstkey: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn rpush<'a, K, V, RV>( &'a mut self, key: K, value: V ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn rpush_exists<'a, K, V, RV>( &'a mut self, key: K, value: V ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn sadd<'a, K, M, RV>( &'a mut self, key: K, member: M ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where M: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn scard<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn sdiff<'a, K, RV>( &'a mut self, keys: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn sdiffstore<'a, K, RV>( &'a mut self, dstkey: K, keys: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn sinter<'a, K, RV>( &'a mut self, keys: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn sinterstore<'a, K, RV>( &'a mut self, dstkey: K, keys: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn sismember<'a, K, M, RV>( &'a mut self, key: K, member: M ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where M: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn smembers<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn smove<'a, K, M, RV>( &'a mut self, srckey: K, dstkey: K, member: M ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where M: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn spop<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn srandmember<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn srandmember_multiple<'a, K, RV>( &'a mut self, key: K, count: usize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn srem<'a, K, M, RV>( &'a mut self, key: K, member: M ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where M: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn sunion<'a, K, RV>( &'a mut self, keys: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn sunionstore<'a, K, RV>( &'a mut self, dstkey: K, keys: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn zadd<'a, K, S, M, RV>( &'a mut self, key: K, member: M, score: S ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where M: 'a + ToRedisArgs + Send + Sync, S: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn zadd_multiple<'a, K, S, M, RV>( &'a mut self, key: K, items: &'a [(S, M)] ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where M: 'a + ToRedisArgs + Send + Sync, S: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn zcard<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn zcount<'a, K, M, MM, RV>( &'a mut self, key: K, min: M, max: MM ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where M: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, MM: 'a + ToRedisArgs + Send + Sync,` [src]

`pub fn zincr<'a, K, M, D, RV>( &'a mut self, key: K, member: M, delta: D ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where M: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, D: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn zinterstore<'a, K, RV>( &'a mut self, dstkey: K, keys: &'a [K] ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn zinterstore_min<'a, K, RV>( &'a mut self, dstkey: K, keys: &'a [K] ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn zinterstore_max<'a, K, RV>( &'a mut self, dstkey: K, keys: &'a [K] ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn zlexcount<'a, K, L, RV>( &'a mut self, key: K, min: L, max: L ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, L: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn zpopmax<'a, K, RV>( &'a mut self, key: K, count: isize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn zpopmin<'a, K, RV>( &'a mut self, key: K, count: isize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn zrange<'a, K, RV>( &'a mut self, key: K, start: isize, stop: isize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn zrange_withscores<'a, K, RV>( &'a mut self, key: K, start: isize, stop: isize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn zrangebylex<'a, K, M, MM, RV>( &'a mut self, key: K, min: M, max: MM ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where M: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, MM: 'a + ToRedisArgs + Send + Sync,` [src]

`pub fn zrangebylex_limit<'a, K, M, MM, RV>( &'a mut self, key: K, min: M, max: MM, offset: isize, count: isize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where M: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, MM: 'a + ToRedisArgs + Send + Sync,` [src]

`pub fn zrevrangebylex<'a, K, MM, M, RV>( &'a mut self, key: K, max: MM, min: M ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where M: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, MM: 'a + ToRedisArgs + Send + Sync,` [src]

`pub fn zrevrangebylex_limit<'a, K, MM, M, RV>( &'a mut self, key: K, max: MM, min: M, offset: isize, count: isize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where M: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, MM: 'a + ToRedisArgs + Send + Sync,` [src]

`pub fn zrangebyscore<'a, K, M, MM, RV>( &'a mut self, key: K, min: M, max: MM ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where M: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, MM: 'a + ToRedisArgs + Send + Sync,` [src]

`pub fn zrangebyscore_withscores<'a, K, M, MM, RV>( &'a mut self, key: K, min: M, max: MM ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where M: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, MM: 'a + ToRedisArgs + Send + Sync,` [src]

`pub fn zrangebyscore_limit<'a, K, M, MM, RV>( &'a mut self, key: K, min: M, max: MM, offset: isize, count: isize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where M: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, MM: 'a + ToRedisArgs + Send + Sync,` [src]

`pub fn zrangebyscore_limit_withscores<'a, K, M, MM, RV>( &'a mut self, key: K, min: M, max: MM, offset: isize, count: isize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where M: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, MM: 'a + ToRedisArgs + Send + Sync,` [src]

`pub fn zrank<'a, K, M, RV>( &'a mut self, key: K, member: M ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where M: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn zrem<'a, K, M, RV>( &'a mut self, key: K, members: M ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where M: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn zrembylex<'a, K, M, MM, RV>( &'a mut self, key: K, min: M, max: MM ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where M: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, MM: 'a + ToRedisArgs + Send + Sync,` [src]

`pub fn zremrangebyrank<'a, K, RV>( &'a mut self, key: K, start: isize, stop: isize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn zrembyscore<'a, K, M, MM, RV>( &'a mut self, key: K, min: M, max: MM ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where M: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, MM: 'a + ToRedisArgs + Send + Sync,` [src]

`pub fn zrevrange<'a, K, RV>( &'a mut self, key: K, start: isize, stop: isize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn zrevrange_withscores<'a, K, RV>( &'a mut self, key: K, start: isize, stop: isize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn zrevrangebyscore<'a, K, MM, M, RV>( &'a mut self, key: K, max: MM, min: M ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where M: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, MM: 'a + ToRedisArgs + Send + Sync,` [src]

`pub fn zrevrangebyscore_withscores<'a, K, MM, M, RV>( &'a mut self, key: K, max: MM, min: M ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where M: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, MM: 'a + ToRedisArgs + Send + Sync,` [src]

`pub fn zrevrangebyscore_limit<'a, K, MM, M, RV>( &'a mut self, key: K, max: MM, min: M, offset: isize, count: isize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where M: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, MM: 'a + ToRedisArgs + Send + Sync,` [src]

`pub fn zrevrangebyscore_limit_withscores<'a, K, MM, M, RV>( &'a mut self, key: K, max: MM, min: M, offset: isize, count: isize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where M: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, MM: 'a + ToRedisArgs + Send + Sync,` [src]

`pub fn zrevrank<'a, K, M, RV>( &'a mut self, key: K, member: M ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where M: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn zscore<'a, K, M, RV>( &'a mut self, key: K, member: M ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where M: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn zunionstore<'a, K, RV>( &'a mut self, dstkey: K, keys: &'a [K] ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn zunionstore_min<'a, K, RV>( &'a mut self, dstkey: K, keys: &'a [K] ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn zunionstore_max<'a, K, RV>( &'a mut self, dstkey: K, keys: &'a [K] ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn pfadd<'a, K, E, RV>( &'a mut self, key: K, element: E ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where E: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn pfcount<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn pfmerge<'a, K, RV>( &'a mut self, dstkey: K, srckeys: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn publish<'a, K, E, RV>( &'a mut self, channel: K, message: E ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where E: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn acl_load<RV>( &'a mut self ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where RV: FromRedisValue,` [src]

`pub fn acl_save<RV>( &'a mut self ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where RV: FromRedisValue,` [src]

`pub fn acl_list<RV>( &'a mut self ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where RV: FromRedisValue,` [src]

`pub fn acl_users<RV>( &'a mut self ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where RV: FromRedisValue,` [src]

`pub fn acl_getuser<'a, K, RV>( &'a mut self, username: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn acl_setuser<'a, K, RV>( &'a mut self, username: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn acl_setuser_rules<'a, K, RV>( &'a mut self, username: K, rules: &'a [Rule] ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn acl_deluser<'a, K, RV>( &'a mut self, usernames: &'a [K] ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn acl_cat<RV>( &'a mut self ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where RV: FromRedisValue,` [src]

`pub fn acl_cat_categoryname<'a, K, RV>( &'a mut self, categoryname: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn acl_genpass<RV>( &'a mut self ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where RV: FromRedisValue,` [src]

`pub fn acl_genpass_bits<RV>( &'a mut self, bits: isize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where RV: FromRedisValue,` [src]

`pub fn acl_whoami<RV>( &'a mut self ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where RV: FromRedisValue,` [src]

`pub fn acl_log<RV>( &'a mut self, count: isize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where RV: FromRedisValue,` [src]

`pub fn acl_log_reset<RV>( &'a mut self ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where RV: FromRedisValue,` [src]

`pub fn acl_help<RV>( &'a mut self ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where RV: FromRedisValue,` [src]

`pub fn geo_add<'a, K, M, RV>( &'a mut self, key: K, members: M ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where M: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn geo_dist<'a, K, M1, M2, RV>( &'a mut self, key: K, member1: M1, member2: M2, unit: Unit ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, M1: 'a + ToRedisArgs + Send + Sync, M2: 'a + ToRedisArgs + Send + Sync,` [src]

`pub fn geo_hash<'a, K, M, RV>( &'a mut self, key: K, members: M ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where M: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn geo_pos<'a, K, M, RV>( &'a mut self, key: K, members: M ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where M: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn geo_radius<'a, K, RV>( &'a mut self, key: K, longitude: f64, latitude: f64, radius: f64, unit: Unit, options: RadiusOptions ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn geo_radius_by_member<'a, K, M, RV>( &'a mut self, key: K, member: M, radius: f64, unit: Unit, options: RadiusOptions ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where M: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn xack<'a, K, G, I, RV>( &'a mut self, key: K, group: G, ids: &'a [I] ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where I: 'a + ToRedisArgs + Send + Sync, G: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn xadd<'a, K, ID, F, V, RV>( &'a mut self, key: K, id: ID, items: &'a [(F, V)] ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where F: 'a + ToRedisArgs + Send + Sync, ID: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn xadd_map<'a, K, ID, BTM, RV>( &'a mut self, key: K, id: ID, map: BTM ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where ID: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, BTM: 'a + ToRedisArgs + Send + Sync,` [src]

`pub fn xadd_maxlen<'a, K, ID, F, V, RV>( &'a mut self, key: K, maxlen: StreamMaxlen, id: ID, items: &'a [(F, V)] ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where F: 'a + ToRedisArgs + Send + Sync, ID: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn xadd_maxlen_map<'a, K, ID, BTM, RV>( &'a mut self, key: K, maxlen: StreamMaxlen, id: ID, map: BTM ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where ID: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, BTM: 'a + ToRedisArgs + Send + Sync,` [src]

`pub fn xclaim<'a, K, G, C, MIT, ID, RV>( &'a mut self, key: K, group: G, consumer: C, min_idle_time: MIT, ids: &'a [ID] ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where C: 'a + ToRedisArgs + Send + Sync, ID: 'a + ToRedisArgs + Send + Sync, G: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, MIT: 'a + ToRedisArgs + Send + Sync,` [src]

pub fn xclaim_options<'a, K, G, C, MIT, ID, RV>( &'a mut self, key: K, group: G, consumer: C, min_idle_time: MIT, ids: &'a [ID], options: StreamClaimOptions ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where C: 'a + ToRedisArgs + Send + Sync, ID: 'a + ToRedisArgs + Send + Sync, G: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, MIT: 'a + ToRedisArgs + Send + Sync, [src]

`pub fn xdel<'a, K, ID, RV>( &'a mut self, key: K, ids: &'a [ID] ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where ID: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn xgroup_create<'a, K, G, ID, RV>( &'a mut self, key: K, group: G, id: ID ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where ID: 'a + ToRedisArgs + Send + Sync, G: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn xgroup_create_mkstream<'a, K, G, ID, RV>( &'a mut self, key: K, group: G, id: ID ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where ID: 'a + ToRedisArgs + Send + Sync, G: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn xgroup_setid<'a, K, G, ID, RV>( &'a mut self, key: K, group: G, id: ID ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where ID: 'a + ToRedisArgs + Send + Sync, G: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn xgroup_destroy<'a, K, G, RV>( &'a mut self, key: K, group: G ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where G: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn xgroup_delconsumer<'a, K, G, C, RV>( &'a mut self, key: K, group: G, consumer: C ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where C: 'a + ToRedisArgs + Send + Sync, G: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn xinfo_consumers<'a, K, G, RV>( &'a mut self, key: K, group: G ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where G: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn xinfo_groups<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn xinfo_stream<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn xlen<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn xpending<'a, K, G, RV>( &'a mut self, key: K, group: G ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where G: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn xpending_count<'a, K, G, S, E, C, RV>( &'a mut self, key: K, group: G, start: S, end: E, count: C ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where C: 'a + ToRedisArgs + Send + Sync, E: 'a + ToRedisArgs + Send + Sync, G: 'a + ToRedisArgs + Send + Sync, S: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

pub fn xpending_consumer_count<'a, K, G, S, E, C, CN, RV>( &'a mut self, key: K, group: G, start: S, end: E, count: C, consumer: CN ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where C: 'a + ToRedisArgs + Send + Sync, E: 'a + ToRedisArgs + Send + Sync, G: 'a + ToRedisArgs + Send + Sync, S: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, CN: 'a + ToRedisArgs + Send + Sync, [src]

`pub fn xrange<'a, K, S, E, RV>( &'a mut self, key: K, start: S, end: E ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where E: 'a + ToRedisArgs + Send + Sync, S: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn xrange_all<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn xrange_count<'a, K, S, E, C, RV>( &'a mut self, key: K, start: S, end: E, count: C ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where C: 'a + ToRedisArgs + Send + Sync, E: 'a + ToRedisArgs + Send + Sync, S: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn xread<'a, K, ID, RV>( &'a mut self, keys: &'a [K], ids: &'a [ID] ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where ID: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn xread_options<'a, K, ID, RV>( &'a mut self, keys: &'a [K], ids: &'a [ID], options: StreamReadOptions ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where ID: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn xrevrange<'a, K, E, S, RV>( &'a mut self, key: K, end: E, start: S ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where E: 'a + ToRedisArgs + Send + Sync, S: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn xrevrange_all<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn xrevrange_count<'a, K, E, S, C, RV>( &'a mut self, key: K, end: E, start: S, count: C ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where C: 'a + ToRedisArgs + Send + Sync, E: 'a + ToRedisArgs + Send + Sync, S: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn xtrim<'a, K, RV>( &'a mut self, key: K, maxlen: StreamMaxlen ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn scan<RV>( &mut self ) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where RV: FromRedisValue,` [src]

`pub fn scan_match<P, RV>( &mut self, pattern: P ) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where P: ToRedisArgs, RV: FromRedisValue,` [src]

`pub fn hscan<K, RV>( &mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where K: ToRedisArgs, RV: FromRedisValue,` [src]

`pub fn hscan_match<K, P, RV>( &mut self, key: K, pattern: P ) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where P: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue,` [src]

`pub fn sscan<K, RV>( &mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where K: ToRedisArgs, RV: FromRedisValue,` [src]

`pub fn sscan_match<K, P, RV>( &mut self, key: K, pattern: P ) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where P: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue,` [src]

`pub fn zscan<K, RV>( &mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where K: ToRedisArgs, RV: FromRedisValue,` [src]

`pub fn zscan_match<K, P, RV>( &mut self, key: K, pattern: P ) -> Pin<Box<dyn Future<Output = Result<AsyncIter<'_, RV>, RedisError>> + Send, Global>> where P: ToRedisArgs, K: ToRedisArgs, RV: FromRedisValue,` [src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`pub fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`pub fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T> From<T> for T`[src]

`pub fn from(t: T) -> T`[src]

`impl<T, U> Into for T where U: From<T>,` [src]

`pub fn into(self) -> U`[src]

`impl<T, U> TryFrom for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`pub fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>`[src]

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = >::Error`

The type returned in the event of a conversion error.

`pub fn try_into(self) -> Result<U, >::Error>`[src]

`impl<V, T> VZip<V> for T where V: MultiLane<T>,`

`pub fn vzip(self) -> V`

Enum reool::ConnectionFlavour[−][src]

Variants

Trait Implementations

impl ConnectionLike for ConnectionFlavour[src]

fn req_packed_command<'a>(&'a mut self, cmd: &'a Cmd) -> RedisFuture<'a, Value>[src]

fn req_packed_commands<'a>( &'a mut self, pipeline: &'a Pipeline, offset: usize, count: usize) -> RedisFuture<'a, Vec<Value>>[src]

fn get_db(&self) -> i64[src]

impl Poolable for ConnectionFlavour[src]

fn connected_to(&self) -> &str[src]

Auto Trait Implementations

impl !RefUnwindSafe for ConnectionFlavour

impl Send for ConnectionFlavour

impl Sync for ConnectionFlavour

impl Unpin for ConnectionFlavour

impl !UnwindSafe for ConnectionFlavour

Blanket Implementations

impl<T> Any for T where T: 'static + ?Sized, [src]

pub fn type_id(&self) -> TypeId[src]

impl<T> AsyncCommands for T where T: ConnectionLike + Send, [src]

pub fn get<'a, K, RV>( &'a mut self, key: K) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn keys<'a, K, RV>( &'a mut self, key: K) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn set<'a, K, V, RV>( &'a mut self, key: K, value: V) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn set_multiple<'a, K, V, RV>( &'a mut self, items: &'a [(K, V)]) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn set_ex<'a, K, V, RV>( &'a mut self, key: K, value: V, seconds: usize) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn pset_ex<'a, K, V, RV>( &'a mut self, key: K, value: V, milliseconds: usize) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn set_nx<'a, K, V, RV>( &'a mut self, key: K, value: V) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn mset_nx<'a, K, V, RV>( &'a mut self, items: &'a [(K, V)]) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn getset<'a, K, V, RV>( &'a mut self, key: K, value: V) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn getrange<'a, K, RV>( &'a mut self, key: K, from: isize, to: isize) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn setrange<'a, K, V, RV>( &'a mut self, key: K, offset: isize, value: V) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn del<'a, K, RV>( &'a mut self, key: K) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn exists<'a, K, RV>( &'a mut self, key: K) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn expire<'a, K, RV>( &'a mut self, key: K, seconds: usize) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn expire_at<'a, K, RV>( &'a mut self, key: K, ts: usize) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn pexpire<'a, K, RV>( &'a mut self, key: K, ms: usize) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn pexpire_at<'a, K, RV>( &'a mut self, key: K, ts: usize) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn persist<'a, K, RV>( &'a mut self, key: K) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn ttl<'a, K, RV>( &'a mut self, key: K) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn pttl<'a, K, RV>( &'a mut self, key: K) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn rename<'a, K, RV>( &'a mut self, key: K, new_key: K) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn rename_nx<'a, K, RV>( &'a mut self, key: K, new_key: K) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn unlink<'a, K, RV>( &'a mut self, key: K) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn append<'a, K, V, RV>( &'a mut self, key: K, value: V) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn incr<'a, K, V, RV>( &'a mut self, key: K, delta: V) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn decr<'a, K, V, RV>( &'a mut self, key: K, delta: V) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn setbit<'a, K, RV>( &'a mut self, key: K, offset: usize, value: bool) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn getbit<'a, K, RV>( &'a mut self, key: K, offset: usize) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn bitcount<'a, K, RV>( &'a mut self, key: K) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn bitcount_range<'a, K, RV>( &'a mut self, key: K, start: usize, end: usize) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn bit_and<'a, K, RV>( &'a mut self, dstkey: K, srckeys: K) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn bit_or<'a, K, RV>( &'a mut self, dstkey: K, srckeys: K) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn bit_xor<'a, K, RV>( &'a mut self, dstkey: K, srckeys: K) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn bit_not<'a, K, RV>( &'a mut self, dstkey: K, srckey: K) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn strlen<'a, K, RV>( &'a mut self, key: K) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn hget<'a, K, F, RV>( &'a mut self, key: K, field: F) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where F: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn hdel<'a, K, F, RV>( &'a mut self, key: K, field: F) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where F: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn hset<'a, K, F, V, RV>( &'a mut self, key: K, field: F, value: V) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where F: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn hset_nx<'a, K, F, V, RV>( &'a mut self, key: K, field: F, value: V) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where F: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn hset_multiple<'a, K, F, V, RV>( &'a mut self, key: K, items: &'a [(F, V)]) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where F: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn hincr<'a, K, F, D, RV>( &'a mut self, key: K, field: F, delta: D) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where F: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, D: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn hexists<'a, K, F, RV>( &'a mut self, key: K, field: F) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where F: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn hkeys<'a, K, RV>( &'a mut self, key: K) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn hvals<'a, K, RV>( &'a mut self, key: K) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn hgetall<'a, K, RV>( &'a mut self, key: K) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn hlen<'a, K, RV>( &'a mut self, key: K) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn blpop<'a, K, RV>( &'a mut self, key: K, timeout: usize) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn brpop<'a, K, RV>( &'a mut self, key: K, timeout: usize) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn brpoplpush<'a, K, RV>( &'a mut self, srckey: K, dstkey: K, timeout: usize) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn lindex<'a, K, RV>( &'a mut self, key: K, index: isize) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn linsert_before<'a, K, P, V, RV>( &'a mut self, key: K, pivot: P, value: V) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where P: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn linsert_after<'a, K, P, V, RV>( &'a mut self, key: K, pivot: P, value: V) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where P: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn llen<'a, K, RV>( &'a mut self, key: K) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn lpop<'a, K, RV>( &'a mut self, key: K) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn lpos<'a, K, V, RV>( &'a mut self, key: K, value: V, options: LposOptions) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn lpush<'a, K, V, RV>( &'a mut self, key: K, value: V) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn lpush_exists<'a, K, V, RV>( &'a mut self, key: K, value: V) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn lrange<'a, K, RV>( &'a mut self, key: K, start: isize, stop: isize) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn lrem<'a, K, V, RV>( &'a mut self, key: K, count: isize, value: V) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn ltrim<'a, K, RV>( &'a mut self, key: K, start: isize, stop: isize) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

pub fn lset<'a, K, V, RV>( &'a mut self, key: K, index: isize, value: V) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue, [src]

`impl ConnectionLike for ConnectionFlavour`[src]

`fn req_packed_command<'a>(&'a mut self, cmd: &'a Cmd) -> RedisFuture<'a, Value>`[src]

`fn req_packed_commands<'a>( &'a mut self, pipeline: &'a Pipeline, offset: usize, count: usize ) -> RedisFuture<'a, Vec<Value>>`[src]

`fn get_db(&self) -> i64`[src]

`impl Poolable for ConnectionFlavour`[src]

`fn connected_to(&self) -> &str`[src]

`impl !RefUnwindSafe for ConnectionFlavour`

`impl Send for ConnectionFlavour`

`impl Sync for ConnectionFlavour`

`impl Unpin for ConnectionFlavour`

`impl !UnwindSafe for ConnectionFlavour`

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`pub fn type_id(&self) -> TypeId`[src]

`impl<T> AsyncCommands for T where T: ConnectionLike + Send,` [src]

`pub fn get<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn keys<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn set<'a, K, V, RV>( &'a mut self, key: K, value: V ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn set_multiple<'a, K, V, RV>( &'a mut self, items: &'a [(K, V)] ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn set_ex<'a, K, V, RV>( &'a mut self, key: K, value: V, seconds: usize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn pset_ex<'a, K, V, RV>( &'a mut self, key: K, value: V, milliseconds: usize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn set_nx<'a, K, V, RV>( &'a mut self, key: K, value: V ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn mset_nx<'a, K, V, RV>( &'a mut self, items: &'a [(K, V)] ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn getset<'a, K, V, RV>( &'a mut self, key: K, value: V ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn getrange<'a, K, RV>( &'a mut self, key: K, from: isize, to: isize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn setrange<'a, K, V, RV>( &'a mut self, key: K, offset: isize, value: V ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn del<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn exists<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn expire<'a, K, RV>( &'a mut self, key: K, seconds: usize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn expire_at<'a, K, RV>( &'a mut self, key: K, ts: usize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn pexpire<'a, K, RV>( &'a mut self, key: K, ms: usize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn pexpire_at<'a, K, RV>( &'a mut self, key: K, ts: usize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn persist<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn ttl<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn pttl<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn rename<'a, K, RV>( &'a mut self, key: K, new_key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn rename_nx<'a, K, RV>( &'a mut self, key: K, new_key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn unlink<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn append<'a, K, V, RV>( &'a mut self, key: K, value: V ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn incr<'a, K, V, RV>( &'a mut self, key: K, delta: V ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn decr<'a, K, V, RV>( &'a mut self, key: K, delta: V ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn setbit<'a, K, RV>( &'a mut self, key: K, offset: usize, value: bool ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn getbit<'a, K, RV>( &'a mut self, key: K, offset: usize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn bitcount<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn bitcount_range<'a, K, RV>( &'a mut self, key: K, start: usize, end: usize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn bit_and<'a, K, RV>( &'a mut self, dstkey: K, srckeys: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn bit_or<'a, K, RV>( &'a mut self, dstkey: K, srckeys: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn bit_xor<'a, K, RV>( &'a mut self, dstkey: K, srckeys: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn bit_not<'a, K, RV>( &'a mut self, dstkey: K, srckey: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn strlen<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn hget<'a, K, F, RV>( &'a mut self, key: K, field: F ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where F: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn hdel<'a, K, F, RV>( &'a mut self, key: K, field: F ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where F: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn hset<'a, K, F, V, RV>( &'a mut self, key: K, field: F, value: V ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where F: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn hset_nx<'a, K, F, V, RV>( &'a mut self, key: K, field: F, value: V ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where F: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn hset_multiple<'a, K, F, V, RV>( &'a mut self, key: K, items: &'a [(F, V)] ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where F: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn hincr<'a, K, F, D, RV>( &'a mut self, key: K, field: F, delta: D ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where F: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, D: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn hexists<'a, K, F, RV>( &'a mut self, key: K, field: F ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where F: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn hkeys<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn hvals<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn hgetall<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn hlen<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn blpop<'a, K, RV>( &'a mut self, key: K, timeout: usize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn brpop<'a, K, RV>( &'a mut self, key: K, timeout: usize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn brpoplpush<'a, K, RV>( &'a mut self, srckey: K, dstkey: K, timeout: usize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn lindex<'a, K, RV>( &'a mut self, key: K, index: isize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn linsert_before<'a, K, P, V, RV>( &'a mut self, key: K, pivot: P, value: V ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where P: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn linsert_after<'a, K, P, V, RV>( &'a mut self, key: K, pivot: P, value: V ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where P: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn llen<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn lpop<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn lpos<'a, K, V, RV>( &'a mut self, key: K, value: V, options: LposOptions ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn lpush<'a, K, V, RV>( &'a mut self, key: K, value: V ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn lpush_exists<'a, K, V, RV>( &'a mut self, key: K, value: V ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn lrange<'a, K, RV>( &'a mut self, key: K, start: isize, stop: isize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn lrem<'a, K, V, RV>( &'a mut self, key: K, count: isize, value: V ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn ltrim<'a, K, RV>( &'a mut self, key: K, start: isize, stop: isize ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn lset<'a, K, V, RV>( &'a mut self, key: K, index: isize, value: V ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn rpop<'a, K, RV>( &'a mut self, key: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn rpoplpush<'a, K, RV>( &'a mut self, key: K, dstkey: K ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn rpush<'a, K, V, RV>( &'a mut self, key: K, value: V ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn rpush_exists<'a, K, V, RV>( &'a mut self, key: K, value: V ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where K: 'a + ToRedisArgs + Send + Sync, V: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]

`pub fn sadd<'a, K, M, RV>( &'a mut self, key: K, member: M ) -> Pin<Box<dyn Future<Output = Result<RV, RedisError>> + 'a + Send, Global>> where M: 'a + ToRedisArgs + Send + Sync, K: 'a + ToRedisArgs + Send + Sync, RV: FromRedisValue,` [src]