[−][src]Struct reool::PoolConnection

pub struct PoolConnection<T: Poolable = ConnectionFlavour> { /* fields omitted */ }

A connection that has been taken from the pool.

The connection returns when dropped unless there was an error.

Pooled connection implements redis::async::ConnectionLike to easily integrate with code that already uses redis-rs.

Implementations

`impl<T: Poolable> PoolConnection<T>`[src]

`pub fn default_command_timeout<TO: Into<DefaultCommandTimeout>>( &mut self, timeout: TO )`[src]

Trait Implementations

`impl<T: Poolable> ConnectionLike for PoolConnection<T> where T: ConnectionLike,` [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<T: Poolable> Drop for PoolConnection<T>`[src]

`fn drop(&mut self)`[src]

Auto Trait Implementations

`impl<T = ConnectionFlavour> !RefUnwindSafe for PoolConnection<T>`

`impl<T> Send for PoolConnection<T>`

`impl<T> Sync for PoolConnection<T> where T: Sync,`

`impl<T> Unpin for PoolConnection<T> where T: Unpin,`

`impl<T = ConnectionFlavour> !UnwindSafe for PoolConnection<T>`

Blanket Implementations

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`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.

`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.

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

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

`fn vzip(self) -> V`

[−][src]Struct reool::PoolConnection

Implementations

impl<T: Poolable> PoolConnection<T>[src]

pub fn default_command_timeout<TO: Into<DefaultCommandTimeout>>( &mut self, timeout: TO)[src]

Trait Implementations

impl<T: Poolable> ConnectionLike for PoolConnection<T> where T: ConnectionLike, [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<T: Poolable> Drop for PoolConnection<T>[src]

fn drop(&mut self)[src]

Auto Trait Implementations

impl<T = ConnectionFlavour> !RefUnwindSafe for PoolConnection<T>

impl<T> Send for PoolConnection<T>

impl<T> Sync for PoolConnection<T> where T: Sync,

impl<T> Unpin for PoolConnection<T> where T: Unpin,

impl<T = ConnectionFlavour> !UnwindSafe for PoolConnection<T>

Blanket Implementations

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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