pub struct GenericDatabase<Storage, Metadata> { /* private fields */ }Implementations§
Source§impl GenericDatabase<IterableKeyValueViewWrapper<<OffChain as DatabaseDescription>::Column>, <OffChain as DatabaseDescription>::Height>
impl GenericDatabase<IterableKeyValueViewWrapper<<OffChain as DatabaseDescription>::Column>, <OffChain as DatabaseDescription>::Height>
pub fn get_block_height( &self, id: &BlockId, ) -> StorageResult<Option<BlockHeight>>
Source§impl GenericDatabase<IterableKeyValueViewWrapper<<OnChain as DatabaseDescription>::Column>, <OnChain as DatabaseDescription>::Height>
impl GenericDatabase<IterableKeyValueViewWrapper<<OnChain as DatabaseDescription>::Column>, <OnChain as DatabaseDescription>::Height>
pub fn latest_compressed_block(&self) -> StorageResult<Option<CompressedBlock>>
Sourcepub fn get_current_block(&self) -> StorageResult<Option<CompressedBlock>>
pub fn get_current_block(&self) -> StorageResult<Option<CompressedBlock>>
Get the current block at the head of the chain.
Sourcepub fn get_full_block(
&self,
height: &BlockHeight,
) -> StorageResult<Option<Block>>
pub fn get_full_block( &self, height: &BlockHeight, ) -> StorageResult<Option<Block>>
Retrieve the full block and all associated transactions
Source§impl GenericDatabase<IterableKeyValueViewWrapper<<OnChain as DatabaseDescription>::Column>, <OnChain as DatabaseDescription>::Height>
impl GenericDatabase<IterableKeyValueViewWrapper<<OnChain as DatabaseDescription>::Column>, <OnChain as DatabaseDescription>::Height>
pub fn block_history_proof( &self, message_block_height: &BlockHeight, commit_block_height: &BlockHeight, ) -> StorageResult<MerkleProof>
Source§impl GenericDatabase<IterableKeyValueViewWrapper<<OffChain as DatabaseDescription>::Column>, <OffChain as DatabaseDescription>::Height>
impl GenericDatabase<IterableKeyValueViewWrapper<<OffChain as DatabaseDescription>::Column>, <OffChain as DatabaseDescription>::Height>
pub fn owned_coins_ids( &self, owner: &Address, start_coin: Option<UtxoId>, direction: Option<IterDirection>, ) -> impl Iterator<Item = StorageResult<UtxoId>> + '_ + use<'_>
Source§impl GenericDatabase<IterableKeyValueViewWrapper<<OnChain as DatabaseDescription>::Column>, <OnChain as DatabaseDescription>::Height>
impl GenericDatabase<IterableKeyValueViewWrapper<<OnChain as DatabaseDescription>::Column>, <OnChain as DatabaseDescription>::Height>
pub fn coin(&self, utxo_id: &UtxoId) -> StorageResult<CompressedCoin>
Source§impl GenericDatabase<IterableKeyValueViewWrapper<<OnChain as DatabaseDescription>::Column>, <OnChain as DatabaseDescription>::Height>
impl GenericDatabase<IterableKeyValueViewWrapper<<OnChain as DatabaseDescription>::Column>, <OnChain as DatabaseDescription>::Height>
pub fn iter_contract_state( &self, ) -> impl Iterator<Item = StorageResult<TableEntry<ContractsState>>> + '_
pub fn iter_contract_balance( &self, ) -> impl Iterator<Item = StorageResult<TableEntry<ContractsAssets>>> + '_
pub fn iter_contracts_code( &self, ) -> impl Iterator<Item = StorageResult<TableEntry<ContractsRawCode>>> + '_
pub fn iter_contracts_latest_utxo( &self, ) -> impl Iterator<Item = StorageResult<TableEntry<ContractsLatestUtxo>>> + '_
pub fn contract_code( &self, contract_id: ContractId, ) -> StorageResult<TableEntry<ContractsRawCode>>
pub fn contract_latest_utxo( &self, contract_id: ContractId, ) -> StorageResult<TableEntry<ContractsLatestUtxo>>
pub fn filter_contract_balances( &self, contract: ContractId, start_asset: Option<AssetId>, direction: Option<IterDirection>, ) -> impl Iterator<Item = StorageResult<TableEntry<ContractsAssets>>> + '_
Source§impl GenericDatabase<DataSource<OnChain, GenesisStage>, Empty>
impl GenericDatabase<DataSource<OnChain, GenesisStage>, Empty>
pub fn genesis_coins_root(&self) -> Result<MerkleRoot>
pub fn genesis_messages_root(&self) -> Result<MerkleRoot>
pub fn genesis_contracts_root(&self) -> Result<MerkleRoot>
pub fn processed_transactions_root(&self) -> Result<MerkleRoot>
Source§impl GenericDatabase<IterableKeyValueViewWrapper<<OffChain as DatabaseDescription>::Column>, <OffChain as DatabaseDescription>::Height>
impl GenericDatabase<IterableKeyValueViewWrapper<<OffChain as DatabaseDescription>::Column>, <OffChain as DatabaseDescription>::Height>
pub fn owned_message_ids( &self, owner: &Address, start_message_id: Option<Nonce>, direction: Option<IterDirection>, ) -> impl Iterator<Item = StorageResult<Nonce>> + '_ + use<'_>
pub fn message_is_spent(&self, id: &Nonce) -> StorageResult<bool>
Source§impl GenericDatabase<IterableKeyValueViewWrapper<<OnChain as DatabaseDescription>::Column>, <OnChain as DatabaseDescription>::Height>
impl GenericDatabase<IterableKeyValueViewWrapper<<OnChain as DatabaseDescription>::Column>, <OnChain as DatabaseDescription>::Height>
pub fn all_messages( &self, start: Option<Nonce>, direction: Option<IterDirection>, ) -> impl Iterator<Item = StorageResult<Message>> + '_
pub fn iter_messages( &self, ) -> impl Iterator<Item = StorageResult<TableEntry<Messages>>> + '_
pub fn message_exists(&self, id: &Nonce) -> StorageResult<bool>
Source§impl<Description, Stage> GenericDatabase<DataSource<Description, Stage>, Empty>where
Description: DatabaseDescription,
Self: StorageInspect<MetadataTable<Description>, Error = Error>,
impl<Description, Stage> GenericDatabase<DataSource<Description, Stage>, Empty>where
Description: DatabaseDescription,
Self: StorageInspect<MetadataTable<Description>, Error = Error>,
Sourcepub fn check_version(&self) -> StorageResult<()>
pub fn check_version(&self) -> StorageResult<()>
Ensures the version is correct.
pub fn latest_height_from_metadata( &self, ) -> StorageResult<Option<Description::Height>>
pub fn indexation_available(&self, kind: IndexationKind) -> StorageResult<bool>
Source§impl GenericDatabase<IterableKeyValueViewWrapper<<OnChain as DatabaseDescription>::Column>, <OnChain as DatabaseDescription>::Height>
impl GenericDatabase<IterableKeyValueViewWrapper<<OnChain as DatabaseDescription>::Column>, <OnChain as DatabaseDescription>::Height>
Sourcepub fn get_sealed_block_by_height(
&self,
height: &BlockHeight,
) -> StorageResult<Option<SealedBlock>>
pub fn get_sealed_block_by_height( &self, height: &BlockHeight, ) -> StorageResult<Option<SealedBlock>>
Returns SealedBlock by height.
Reusable across different trait implementations
pub fn genesis_height(&self) -> StorageResult<Option<BlockHeight>>
pub fn genesis_block(&self) -> StorageResult<Option<CompressedBlock>>
pub fn get_genesis(&self) -> StorageResult<Genesis>
pub fn get_sealed_block_headers( &self, block_height_range: Range<u32>, ) -> StorageResult<Option<Vec<SealedBlockHeader>>>
pub fn get_sealed_block_header( &self, height: &BlockHeight, ) -> StorageResult<Option<SealedBlockHeader>>
pub fn get_transactions_on_blocks( &self, block_height_range: Range<u32>, ) -> StorageResult<Option<Vec<Transactions>>>
Source§impl GenericDatabase<IterableKeyValueViewWrapper<<OffChain as DatabaseDescription>::Column>, <OffChain as DatabaseDescription>::Height>
impl GenericDatabase<IterableKeyValueViewWrapper<<OffChain as DatabaseDescription>::Column>, <OffChain as DatabaseDescription>::Height>
Sourcepub fn owned_transactions(
&self,
owner: Address,
start: Option<OwnedTransactionIndexCursor>,
direction: Option<IterDirection>,
) -> impl Iterator<Item = StorageResult<(TxPointer, Bytes32)>> + '_
pub fn owned_transactions( &self, owner: Address, start: Option<OwnedTransactionIndexCursor>, direction: Option<IterDirection>, ) -> impl Iterator<Item = StorageResult<(TxPointer, Bytes32)>> + '_
Iterates over a KV mapping of [address + block height + tx idx] => transaction id. This
allows for efficient lookup of transaction ids associated with an address, sorted by
block age and ordering within a block. The cursor tracks the [block height + tx idx] for
pagination purposes.
pub fn get_tx_status( &self, id: &Bytes32, ) -> StorageResult<Option<TransactionExecutionStatus>>
Source§impl GenericDatabase<IterableKeyValueViewWrapper<<OnChain as DatabaseDescription>::Column>, <OnChain as DatabaseDescription>::Height>
impl GenericDatabase<IterableKeyValueViewWrapper<<OnChain as DatabaseDescription>::Column>, <OnChain as DatabaseDescription>::Height>
pub fn maybe_latest_height(&self) -> StorageResult<Option<BlockHeight>>
pub fn latest_height(&self) -> StorageResult<BlockHeight>
pub fn latest_block(&self) -> StorageResult<CompressedBlock>
Source§impl<DbDesc> GenericDatabase<DataSource<DbDesc, RegularStage<DbDesc>>, Empty>where
DbDesc: DatabaseDescription,
impl<DbDesc> GenericDatabase<DataSource<DbDesc, RegularStage<DbDesc>>, Empty>where
DbDesc: DatabaseDescription,
pub fn entries<'a, T>(
&'a self,
prefix: Option<Vec<u8>>,
direction: IterDirection,
) -> impl Iterator<Item = StorageResult<TableEntry<T>>> + 'awhere
T: Mappable + 'a,
Self: IterableTable<T>,
pub fn shutdown(self)
Source§impl<Description> GenericDatabase<DataSource<Description, GenesisStage>, Empty>where
Description: DatabaseDescription,
impl<Description> GenericDatabase<DataSource<Description, GenesisStage>, Empty>where
Description: DatabaseDescription,
pub fn new(data_source: DataSourceType<Description>) -> Self
Source§impl<Description> GenericDatabase<DataSource<Description, RegularStage<Description>>, Empty>where
Description: DatabaseDescription,
Database<Description>: StorageInspect<MetadataTable<Description>, Error = Error>,
impl<Description> GenericDatabase<DataSource<Description, RegularStage<Description>>, Empty>where
Description: DatabaseDescription,
Database<Description>: StorageInspect<MetadataTable<Description>, Error = Error>,
pub fn new(data_source: DataSourceType<Description>) -> Self
pub fn open_rocksdb( path: &Path, state_rewind_policy: StateRewindPolicy, database_config: DatabaseConfig, ) -> Result<Self>
Sourcepub fn into_genesis(
self,
) -> Result<GenesisDatabase<Description>, GenesisDatabase<Description>>
pub fn into_genesis( self, ) -> Result<GenesisDatabase<Description>, GenesisDatabase<Description>>
Converts the regular database to an unchecked database.
Returns an error in the case regular database is initialized with the GenesisDatabase,
to highlight that it is a bad idea and it is unsafe.
Source§impl<Description, Stage> GenericDatabase<DataSource<Description, Stage>, Empty>where
Description: DatabaseDescription,
Stage: Default,
impl<Description, Stage> GenericDatabase<DataSource<Description, Stage>, Empty>where
Description: DatabaseDescription,
Stage: Default,
pub fn in_memory() -> Self
pub fn rocksdb_temp( state_rewind_policy: StateRewindPolicy, database_config: DatabaseConfig, ) -> Result<Self>
Source§impl<Description> GenericDatabase<DataSource<Description, RegularStage<Description>>, Empty>where
Description: DatabaseDescription,
impl<Description> GenericDatabase<DataSource<Description, RegularStage<Description>>, Empty>where
Description: DatabaseDescription,
pub fn rollback_last_block(&self) -> StorageResult<()>
Source§impl<Storage, Metadata> GenericDatabase<Storage, Metadata>
impl<Storage, Metadata> GenericDatabase<Storage, Metadata>
pub fn inner_storage(&self) -> &Storage
pub fn metadata(&self) -> Option<&Metadata>
pub fn from_storage_and_metadata( storage: Storage, metadata: Option<Metadata>, ) -> Self
pub fn into_inner(self) -> (Storage, Option<Metadata>)
Source§impl<Column, Height> GenericDatabase<IterableKeyValueViewWrapper<Column>, Height>where
Column: StorageColumn + 'static,
impl<Column, Height> GenericDatabase<IterableKeyValueViewWrapper<Column>, Height>where
Column: StorageColumn + 'static,
Sourcepub fn into_key_value_view(self) -> KeyValueView<Column, Height>
pub fn into_key_value_view(self) -> KeyValueView<Column, Height>
Downgrades the IterableKeyValueView into the KeyValueView.
Trait Implementations§
Source§impl<Storage, Metadata> AsMut<Storage> for GenericDatabase<Storage, Metadata>
impl<Storage, Metadata> AsMut<Storage> for GenericDatabase<Storage, Metadata>
Source§fn as_mut(&mut self) -> &mut Storage
fn as_mut(&mut self) -> &mut Storage
Source§impl<Storage, Metadata> AsRef<Storage> for GenericDatabase<Storage, Metadata>
impl<Storage, Metadata> AsRef<Storage> for GenericDatabase<Storage, Metadata>
Source§impl<Storage: Clone, Metadata: Clone> Clone for GenericDatabase<Storage, Metadata>
impl<Storage: Clone, Metadata: Clone> Clone for GenericDatabase<Storage, Metadata>
Source§fn clone(&self) -> GenericDatabase<Storage, Metadata>
fn clone(&self) -> GenericDatabase<Storage, Metadata>
1.0.0 · Source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source. Read moreSource§impl<Storage, Metadata> Deref for GenericDatabase<Storage, Metadata>
impl<Storage, Metadata> Deref for GenericDatabase<Storage, Metadata>
Source§impl<Storage, Metadata> DerefMut for GenericDatabase<Storage, Metadata>
impl<Storage, Metadata> DerefMut for GenericDatabase<Storage, Metadata>
Source§impl<Storage, Metadata> IterableStore for GenericDatabase<Storage, Metadata>where
Storage: IterableStore,
impl<Storage, Metadata> IterableStore for GenericDatabase<Storage, Metadata>where
Storage: IterableStore,
Source§impl<Storage, Metadata> KeyValueInspect for GenericDatabase<Storage, Metadata>where
Storage: KeyValueInspect,
impl<Storage, Metadata> KeyValueInspect for GenericDatabase<Storage, Metadata>where
Storage: KeyValueInspect,
Source§type Column = <Storage as KeyValueInspect>::Column
type Column = <Storage as KeyValueInspect>::Column
Source§fn exists(&self, key: &[u8], column: Self::Column) -> StorageResult<bool>
fn exists(&self, key: &[u8], column: Self::Column) -> StorageResult<bool>
Source§fn size_of_value(
&self,
key: &[u8],
column: Self::Column,
) -> StorageResult<Option<usize>>
fn size_of_value( &self, key: &[u8], column: Self::Column, ) -> StorageResult<Option<usize>>
Source§impl<Key, M, Storage, Metadata> MerkleRootStorage<Key, M> for GenericDatabase<Storage, Metadata>
impl<Key, M, Storage, Metadata> MerkleRootStorage<Key, M> for GenericDatabase<Storage, Metadata>
Source§impl<Storage, Error, Metadata> PredicateStorageRequirements for GenericDatabase<Storage, Metadata>
impl<Storage, Error, Metadata> PredicateStorageRequirements for GenericDatabase<Storage, Metadata>
Source§fn storage_error_to_string(error: Error) -> String
fn storage_error_to_string(error: Error) -> String
Source§impl<M, Storage, Metadata> StorageInspect<M> for GenericDatabase<Storage, Metadata>
impl<M, Storage, Metadata> StorageInspect<M> for GenericDatabase<Storage, Metadata>
Source§impl<M, Storage, Metadata> StorageRead<M> for GenericDatabase<Storage, Metadata>
impl<M, Storage, Metadata> StorageRead<M> for GenericDatabase<Storage, Metadata>
Source§impl<M, Storage, Metadata> StorageSize<M> for GenericDatabase<Storage, Metadata>
impl<M, Storage, Metadata> StorageSize<M> for GenericDatabase<Storage, Metadata>
Auto Trait Implementations§
impl<Storage, Metadata> Freeze for GenericDatabase<Storage, Metadata>
impl<Storage, Metadata> RefUnwindSafe for GenericDatabase<Storage, Metadata>where
Storage: RefUnwindSafe,
Metadata: RefUnwindSafe,
impl<Storage, Metadata> Send for GenericDatabase<Storage, Metadata>
impl<Storage, Metadata> Sync for GenericDatabase<Storage, Metadata>
impl<Storage, Metadata> Unpin for GenericDatabase<Storage, Metadata>
impl<Storage, Metadata> UnsafeUnpin for GenericDatabase<Storage, Metadata>where
Storage: UnsafeUnpin,
Metadata: UnsafeUnpin,
impl<Storage, Metadata> UnwindSafe for GenericDatabase<Storage, Metadata>where
Storage: UnwindSafe,
Metadata: UnwindSafe,
Blanket Implementations§
Source§impl<T> AnyDebug for T
impl<T> AnyDebug for T
Source§fn as_any_ref(&self) -> &(dyn Any + 'static)
fn as_any_ref(&self) -> &(dyn Any + 'static)
Any.Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
Source§impl<T> Commands for Twhere
T: ConnectionLike,
impl<T> Commands for Twhere
T: ConnectionLike,
Source§fn get<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn get<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
MGET.Source§fn mget<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn mget<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn keys<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn keys<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn set<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>
fn set<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>
Source§fn set_options<'a, K, V, RV>(
&mut self,
key: K,
value: V,
options: SetOptions,
) -> Result<RV, RedisError>
fn set_options<'a, K, V, RV>( &mut self, key: K, value: V, options: SetOptions, ) -> Result<RV, RedisError>
Source§fn set_multiple<'a, K, V, RV>(
&mut self,
items: &'a [(K, V)],
) -> Result<RV, RedisError>
fn set_multiple<'a, K, V, RV>( &mut self, items: &'a [(K, V)], ) -> Result<RV, RedisError>
Renamed to mset() to reflect Redis name
Source§fn mset<'a, K, V, RV>(&mut self, items: &'a [(K, V)]) -> Result<RV, RedisError>
fn mset<'a, K, V, RV>(&mut self, items: &'a [(K, V)]) -> Result<RV, RedisError>
Source§fn set_ex<'a, K, V, RV>(
&mut self,
key: K,
value: V,
seconds: u64,
) -> Result<RV, RedisError>
fn set_ex<'a, K, V, RV>( &mut self, key: K, value: V, seconds: u64, ) -> Result<RV, RedisError>
Source§fn pset_ex<'a, K, V, RV>(
&mut self,
key: K,
value: V,
milliseconds: u64,
) -> Result<RV, RedisError>
fn pset_ex<'a, K, V, RV>( &mut self, key: K, value: V, milliseconds: u64, ) -> Result<RV, RedisError>
Source§fn set_nx<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>
fn set_nx<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>
Source§fn mset_nx<'a, K, V, RV>(
&mut self,
items: &'a [(K, V)],
) -> Result<RV, RedisError>
fn mset_nx<'a, K, V, RV>( &mut self, items: &'a [(K, V)], ) -> Result<RV, RedisError>
Source§fn getset<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>
fn getset<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>
Source§fn getrange<'a, K, RV>(
&mut self,
key: K,
from: isize,
to: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn getrange<'a, K, RV>(
&mut self,
key: K,
from: isize,
to: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn setrange<'a, K, V, RV>(
&mut self,
key: K,
offset: isize,
value: V,
) -> Result<RV, RedisError>
fn setrange<'a, K, V, RV>( &mut self, key: K, offset: isize, value: V, ) -> Result<RV, RedisError>
Source§fn del<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn del<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn exists<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn exists<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn key_type<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn key_type<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn expire<'a, K, RV>(&mut self, key: K, seconds: i64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn expire<'a, K, RV>(&mut self, key: K, seconds: i64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn expire_at<'a, K, RV>(&mut self, key: K, ts: i64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn expire_at<'a, K, RV>(&mut self, key: K, ts: i64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn pexpire<'a, K, RV>(&mut self, key: K, ms: i64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn pexpire<'a, K, RV>(&mut self, key: K, ms: i64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn pexpire_at<'a, K, RV>(&mut self, key: K, ts: i64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn pexpire_at<'a, K, RV>(&mut self, key: K, ts: i64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn expire_time<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn expire_time<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn pexpire_time<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn pexpire_time<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn persist<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn persist<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn ttl<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn ttl<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn pttl<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn pttl<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn get_ex<'a, K, RV>(
&mut self,
key: K,
expire_at: Expiry,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn get_ex<'a, K, RV>(
&mut self,
key: K,
expire_at: Expiry,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn get_del<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn get_del<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn rename<'a, K, N, RV>(&mut self, key: K, new_key: N) -> Result<RV, RedisError>
fn rename<'a, K, N, RV>(&mut self, key: K, new_key: N) -> Result<RV, RedisError>
Source§fn rename_nx<'a, K, N, RV>(
&mut self,
key: K,
new_key: N,
) -> Result<RV, RedisError>
fn rename_nx<'a, K, N, RV>( &mut self, key: K, new_key: N, ) -> Result<RV, RedisError>
Source§fn unlink<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn unlink<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn append<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>
fn append<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>
Source§fn incr<'a, K, V, RV>(&mut self, key: K, delta: V) -> Result<RV, RedisError>
fn incr<'a, K, V, RV>(&mut self, key: K, delta: V) -> Result<RV, RedisError>
INCRBY or INCRBYFLOAT depending on the type.Source§fn decr<'a, K, V, RV>(&mut self, key: K, delta: V) -> Result<RV, RedisError>
fn decr<'a, K, V, RV>(&mut self, key: K, delta: V) -> Result<RV, RedisError>
Source§fn setbit<'a, K, RV>(
&mut self,
key: K,
offset: usize,
value: bool,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn setbit<'a, K, RV>(
&mut self,
key: K,
offset: usize,
value: bool,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn getbit<'a, K, RV>(&mut self, key: K, offset: usize) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn getbit<'a, K, RV>(&mut self, key: K, offset: usize) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn bitcount<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn bitcount<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn bitcount_range<'a, K, RV>(
&mut self,
key: K,
start: usize,
end: usize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn bitcount_range<'a, K, RV>(
&mut self,
key: K,
start: usize,
end: usize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn bit_and<'a, D, S, RV>(
&mut self,
dstkey: D,
srckeys: S,
) -> Result<RV, RedisError>
fn bit_and<'a, D, S, RV>( &mut self, dstkey: D, srckeys: S, ) -> Result<RV, RedisError>
Source§fn bit_or<'a, D, S, RV>(
&mut self,
dstkey: D,
srckeys: S,
) -> Result<RV, RedisError>
fn bit_or<'a, D, S, RV>( &mut self, dstkey: D, srckeys: S, ) -> Result<RV, RedisError>
Source§fn bit_xor<'a, D, S, RV>(
&mut self,
dstkey: D,
srckeys: S,
) -> Result<RV, RedisError>
fn bit_xor<'a, D, S, RV>( &mut self, dstkey: D, srckeys: S, ) -> Result<RV, RedisError>
Source§fn bit_not<'a, D, S, RV>(
&mut self,
dstkey: D,
srckey: S,
) -> Result<RV, RedisError>
fn bit_not<'a, D, S, RV>( &mut self, dstkey: D, srckey: S, ) -> Result<RV, RedisError>
Source§fn strlen<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn strlen<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn hget<'a, K, F, RV>(&mut self, key: K, field: F) -> Result<RV, RedisError>
fn hget<'a, K, F, RV>(&mut self, key: K, field: F) -> Result<RV, RedisError>
Source§fn hdel<'a, K, F, RV>(&mut self, key: K, field: F) -> Result<RV, RedisError>
fn hdel<'a, K, F, RV>(&mut self, key: K, field: F) -> Result<RV, RedisError>
Source§fn hset<'a, K, F, V, RV>(
&mut self,
key: K,
field: F,
value: V,
) -> Result<RV, RedisError>
fn hset<'a, K, F, V, RV>( &mut self, key: K, field: F, value: V, ) -> Result<RV, RedisError>
Source§fn hset_nx<'a, K, F, V, RV>(
&mut self,
key: K,
field: F,
value: V,
) -> Result<RV, RedisError>
fn hset_nx<'a, K, F, V, RV>( &mut self, key: K, field: F, value: V, ) -> Result<RV, RedisError>
Source§fn hset_multiple<'a, K, F, V, RV>(
&mut self,
key: K,
items: &'a [(F, V)],
) -> Result<RV, RedisError>
fn hset_multiple<'a, K, F, V, RV>( &mut self, key: K, items: &'a [(F, V)], ) -> Result<RV, RedisError>
Source§fn hincr<'a, K, F, D, RV>(
&mut self,
key: K,
field: F,
delta: D,
) -> Result<RV, RedisError>
fn hincr<'a, K, F, D, RV>( &mut self, key: K, field: F, delta: D, ) -> Result<RV, RedisError>
Source§fn hexists<'a, K, F, RV>(&mut self, key: K, field: F) -> Result<RV, RedisError>
fn hexists<'a, K, F, RV>(&mut self, key: K, field: F) -> Result<RV, RedisError>
Source§fn httl<'a, K, F, RV>(&mut self, key: K, fields: F) -> Result<RV, RedisError>
fn httl<'a, K, F, RV>(&mut self, key: K, fields: F) -> Result<RV, RedisError>
Source§fn hpttl<'a, K, F, RV>(&mut self, key: K, fields: F) -> Result<RV, RedisError>
fn hpttl<'a, K, F, RV>(&mut self, key: K, fields: F) -> Result<RV, RedisError>
Source§fn hexpire<'a, K, F, RV>(
&mut self,
key: K,
seconds: i64,
opt: ExpireOption,
fields: F,
) -> Result<RV, RedisError>
fn hexpire<'a, K, F, RV>( &mut self, key: K, seconds: i64, opt: ExpireOption, fields: F, ) -> Result<RV, RedisError>
Source§fn hexpire_at<'a, K, F, RV>(
&mut self,
key: K,
ts: i64,
opt: ExpireOption,
fields: F,
) -> Result<RV, RedisError>
fn hexpire_at<'a, K, F, RV>( &mut self, key: K, ts: i64, opt: ExpireOption, fields: F, ) -> Result<RV, RedisError>
Source§fn hexpire_time<'a, K, F, RV>(
&mut self,
key: K,
fields: F,
) -> Result<RV, RedisError>
fn hexpire_time<'a, K, F, RV>( &mut self, key: K, fields: F, ) -> Result<RV, RedisError>
Source§fn hpersist<'a, K, F, RV>(
&mut self,
key: K,
fields: F,
) -> Result<RV, RedisError>
fn hpersist<'a, K, F, RV>( &mut self, key: K, fields: F, ) -> Result<RV, RedisError>
Source§fn hpexpire<'a, K, F, RV>(
&mut self,
key: K,
milliseconds: i64,
opt: ExpireOption,
fields: F,
) -> Result<RV, RedisError>
fn hpexpire<'a, K, F, RV>( &mut self, key: K, milliseconds: i64, opt: ExpireOption, fields: F, ) -> Result<RV, RedisError>
Source§fn hpexpire_at<'a, K, F, RV>(
&mut self,
key: K,
ts: i64,
opt: ExpireOption,
fields: F,
) -> Result<RV, RedisError>
fn hpexpire_at<'a, K, F, RV>( &mut self, key: K, ts: i64, opt: ExpireOption, fields: F, ) -> Result<RV, RedisError>
Source§fn hpexpire_time<'a, K, F, RV>(
&mut self,
key: K,
fields: F,
) -> Result<RV, RedisError>
fn hpexpire_time<'a, K, F, RV>( &mut self, key: K, fields: F, ) -> Result<RV, RedisError>
Source§fn hkeys<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn hkeys<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn hvals<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn hvals<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn hgetall<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn hgetall<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn hlen<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn hlen<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn blmove<'a, S, D, RV>(
&mut self,
srckey: S,
dstkey: D,
src_dir: Direction,
dst_dir: Direction,
timeout: f64,
) -> Result<RV, RedisError>
fn blmove<'a, S, D, RV>( &mut self, srckey: S, dstkey: D, src_dir: Direction, dst_dir: Direction, timeout: f64, ) -> Result<RV, RedisError>
Source§fn blmpop<'a, K, RV>(
&mut self,
timeout: f64,
numkeys: usize,
key: K,
dir: Direction,
count: usize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn blmpop<'a, K, RV>(
&mut self,
timeout: f64,
numkeys: usize,
key: K,
dir: Direction,
count: usize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
count elements from the first non-empty list key from the list of
provided key names; or blocks until one is available.Source§fn blpop<'a, K, RV>(&mut self, key: K, timeout: f64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn blpop<'a, K, RV>(&mut self, key: K, timeout: f64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn brpop<'a, K, RV>(&mut self, key: K, timeout: f64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn brpop<'a, K, RV>(&mut self, key: K, timeout: f64) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn brpoplpush<'a, S, D, RV>(
&mut self,
srckey: S,
dstkey: D,
timeout: f64,
) -> Result<RV, RedisError>
fn brpoplpush<'a, S, D, RV>( &mut self, srckey: S, dstkey: D, timeout: f64, ) -> Result<RV, RedisError>
Source§fn lindex<'a, K, RV>(&mut self, key: K, index: isize) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn lindex<'a, K, RV>(&mut self, key: K, index: isize) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn linsert_before<'a, K, P, V, RV>(
&mut self,
key: K,
pivot: P,
value: V,
) -> Result<RV, RedisError>
fn linsert_before<'a, K, P, V, RV>( &mut self, key: K, pivot: P, value: V, ) -> Result<RV, RedisError>
Source§fn linsert_after<'a, K, P, V, RV>(
&mut self,
key: K,
pivot: P,
value: V,
) -> Result<RV, RedisError>
fn linsert_after<'a, K, P, V, RV>( &mut self, key: K, pivot: P, value: V, ) -> Result<RV, RedisError>
Source§fn llen<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn llen<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn lmove<'a, S, D, RV>(
&mut self,
srckey: S,
dstkey: D,
src_dir: Direction,
dst_dir: Direction,
) -> Result<RV, RedisError>
fn lmove<'a, S, D, RV>( &mut self, srckey: S, dstkey: D, src_dir: Direction, dst_dir: Direction, ) -> Result<RV, RedisError>
Source§fn lmpop<'a, K, RV>(
&mut self,
numkeys: usize,
key: K,
dir: Direction,
count: usize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn lmpop<'a, K, RV>(
&mut self,
numkeys: usize,
key: K,
dir: Direction,
count: usize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
count elements from the first non-empty list key from the list of
provided key names.Source§fn lpop<'a, K, RV>(
&mut self,
key: K,
count: Option<NonZero<usize>>,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn lpop<'a, K, RV>(
&mut self,
key: K,
count: Option<NonZero<usize>>,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
count first elements of the list stored at key. Read moreSource§fn lpos<'a, K, V, RV>(
&mut self,
key: K,
value: V,
options: LposOptions,
) -> Result<RV, RedisError>
fn lpos<'a, K, V, RV>( &mut self, key: K, value: V, options: LposOptions, ) -> Result<RV, RedisError>
Source§fn lpush<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>
fn lpush<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>
Source§fn lpush_exists<'a, K, V, RV>(
&mut self,
key: K,
value: V,
) -> Result<RV, RedisError>
fn lpush_exists<'a, K, V, RV>( &mut self, key: K, value: V, ) -> Result<RV, RedisError>
Source§fn lrange<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn lrange<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn lrem<'a, K, V, RV>(
&mut self,
key: K,
count: isize,
value: V,
) -> Result<RV, RedisError>
fn lrem<'a, K, V, RV>( &mut self, key: K, count: isize, value: V, ) -> Result<RV, RedisError>
Source§fn ltrim<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn ltrim<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn lset<'a, K, V, RV>(
&mut self,
key: K,
index: isize,
value: V,
) -> Result<RV, RedisError>
fn lset<'a, K, V, RV>( &mut self, key: K, index: isize, value: V, ) -> Result<RV, RedisError>
Source§fn rpop<'a, K, RV>(
&mut self,
key: K,
count: Option<NonZero<usize>>,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn rpop<'a, K, RV>(
&mut self,
key: K,
count: Option<NonZero<usize>>,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
count last elements of the list stored at key Read moreSource§fn rpoplpush<'a, K, D, RV>(
&mut self,
key: K,
dstkey: D,
) -> Result<RV, RedisError>
fn rpoplpush<'a, K, D, RV>( &mut self, key: K, dstkey: D, ) -> Result<RV, RedisError>
Source§fn rpush<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>
fn rpush<'a, K, V, RV>(&mut self, key: K, value: V) -> Result<RV, RedisError>
Source§fn rpush_exists<'a, K, V, RV>(
&mut self,
key: K,
value: V,
) -> Result<RV, RedisError>
fn rpush_exists<'a, K, V, RV>( &mut self, key: K, value: V, ) -> Result<RV, RedisError>
Source§fn sadd<'a, K, M, RV>(&mut self, key: K, member: M) -> Result<RV, RedisError>
fn sadd<'a, K, M, RV>(&mut self, key: K, member: M) -> Result<RV, RedisError>
Source§fn scard<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn scard<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn sdiff<'a, K, RV>(&mut self, keys: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn sdiff<'a, K, RV>(&mut self, keys: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn sdiffstore<'a, D, K, RV>(
&mut self,
dstkey: D,
keys: K,
) -> Result<RV, RedisError>
fn sdiffstore<'a, D, K, RV>( &mut self, dstkey: D, keys: K, ) -> Result<RV, RedisError>
Source§fn sinter<'a, K, RV>(&mut self, keys: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn sinter<'a, K, RV>(&mut self, keys: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn sinterstore<'a, D, K, RV>(
&mut self,
dstkey: D,
keys: K,
) -> Result<RV, RedisError>
fn sinterstore<'a, D, K, RV>( &mut self, dstkey: D, keys: K, ) -> Result<RV, RedisError>
Source§fn sismember<'a, K, M, RV>(
&mut self,
key: K,
member: M,
) -> Result<RV, RedisError>
fn sismember<'a, K, M, RV>( &mut self, key: K, member: M, ) -> Result<RV, RedisError>
Source§fn smismember<'a, K, M, RV>(
&mut self,
key: K,
members: M,
) -> Result<RV, RedisError>
fn smismember<'a, K, M, RV>( &mut self, key: K, members: M, ) -> Result<RV, RedisError>
Source§fn smembers<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn smembers<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn smove<'a, S, D, M, RV>(
&mut self,
srckey: S,
dstkey: D,
member: M,
) -> Result<RV, RedisError>
fn smove<'a, S, D, M, RV>( &mut self, srckey: S, dstkey: D, member: M, ) -> Result<RV, RedisError>
Source§fn spop<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn spop<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn srandmember<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn srandmember<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn srandmember_multiple<'a, K, RV>(
&mut self,
key: K,
count: usize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn srandmember_multiple<'a, K, RV>(
&mut self,
key: K,
count: usize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn srem<'a, K, M, RV>(&mut self, key: K, member: M) -> Result<RV, RedisError>
fn srem<'a, K, M, RV>(&mut self, key: K, member: M) -> Result<RV, RedisError>
Source§fn sunion<'a, K, RV>(&mut self, keys: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn sunion<'a, K, RV>(&mut self, keys: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn sunionstore<'a, D, K, RV>(
&mut self,
dstkey: D,
keys: K,
) -> Result<RV, RedisError>
fn sunionstore<'a, D, K, RV>( &mut self, dstkey: D, keys: K, ) -> Result<RV, RedisError>
Source§fn zadd<'a, K, S, M, RV>(
&mut self,
key: K,
member: M,
score: S,
) -> Result<RV, RedisError>
fn zadd<'a, K, S, M, RV>( &mut self, key: K, member: M, score: S, ) -> Result<RV, RedisError>
Source§fn zadd_multiple<'a, K, S, M, RV>(
&mut self,
key: K,
items: &'a [(S, M)],
) -> Result<RV, RedisError>
fn zadd_multiple<'a, K, S, M, RV>( &mut self, key: K, items: &'a [(S, M)], ) -> Result<RV, RedisError>
Source§fn zcard<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zcard<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn zcount<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
) -> Result<RV, RedisError>
fn zcount<'a, K, M, MM, RV>( &mut self, key: K, min: M, max: MM, ) -> Result<RV, RedisError>
Source§fn zincr<'a, K, M, D, RV>(
&mut self,
key: K,
member: M,
delta: D,
) -> Result<RV, RedisError>
fn zincr<'a, K, M, D, RV>( &mut self, key: K, member: M, delta: D, ) -> Result<RV, RedisError>
Source§fn zinterstore<'a, D, K, RV>(
&mut self,
dstkey: D,
keys: K,
) -> Result<RV, RedisError>
fn zinterstore<'a, D, K, RV>( &mut self, dstkey: D, keys: K, ) -> Result<RV, RedisError>
Source§fn zinterstore_min<'a, D, K, RV>(
&mut self,
dstkey: D,
keys: K,
) -> Result<RV, RedisError>
fn zinterstore_min<'a, D, K, RV>( &mut self, dstkey: D, keys: K, ) -> Result<RV, RedisError>
Source§fn zinterstore_max<'a, D, K, RV>(
&mut self,
dstkey: D,
keys: K,
) -> Result<RV, RedisError>
fn zinterstore_max<'a, D, K, RV>( &mut self, dstkey: D, keys: K, ) -> Result<RV, RedisError>
Source§fn zinterstore_weights<'a, D, K, W, RV>(
&mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Result<RV, RedisError>
fn zinterstore_weights<'a, D, K, W, RV>( &mut self, dstkey: D, keys: &'a [(K, W)], ) -> Result<RV, RedisError>
Commands::zinterstore, but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.Source§fn zinterstore_min_weights<'a, D, K, W, RV>(
&mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Result<RV, RedisError>
fn zinterstore_min_weights<'a, D, K, W, RV>( &mut self, dstkey: D, keys: &'a [(K, W)], ) -> Result<RV, RedisError>
Commands::zinterstore_min, but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.Source§fn zinterstore_max_weights<'a, D, K, W, RV>(
&mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Result<RV, RedisError>
fn zinterstore_max_weights<'a, D, K, W, RV>( &mut self, dstkey: D, keys: &'a [(K, W)], ) -> Result<RV, RedisError>
Commands::zinterstore_max, but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.Source§fn zlexcount<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
) -> Result<RV, RedisError>
fn zlexcount<'a, K, M, MM, RV>( &mut self, key: K, min: M, max: MM, ) -> Result<RV, RedisError>
Source§fn bzpopmax<'a, K, RV>(
&mut self,
key: K,
timeout: f64,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn bzpopmax<'a, K, RV>(
&mut self,
key: K,
timeout: f64,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn zpopmax<'a, K, RV>(&mut self, key: K, count: isize) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zpopmax<'a, K, RV>(&mut self, key: K, count: isize) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn bzpopmin<'a, K, RV>(
&mut self,
key: K,
timeout: f64,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn bzpopmin<'a, K, RV>(
&mut self,
key: K,
timeout: f64,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn zpopmin<'a, K, RV>(&mut self, key: K, count: isize) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zpopmin<'a, K, RV>(&mut self, key: K, count: isize) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn bzmpop_max<'a, K, RV>(
&mut self,
timeout: f64,
keys: K,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn bzmpop_max<'a, K, RV>(
&mut self,
timeout: f64,
keys: K,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn zmpop_max<'a, K, RV>(
&mut self,
keys: K,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zmpop_max<'a, K, RV>(
&mut self,
keys: K,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn bzmpop_min<'a, K, RV>(
&mut self,
timeout: f64,
keys: K,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn bzmpop_min<'a, K, RV>(
&mut self,
timeout: f64,
keys: K,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn zmpop_min<'a, K, RV>(
&mut self,
keys: K,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zmpop_min<'a, K, RV>(
&mut self,
keys: K,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn zrandmember<'a, K, RV>(
&mut self,
key: K,
count: Option<isize>,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zrandmember<'a, K, RV>(
&mut self,
key: K,
count: Option<isize>,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
count == None)Source§fn zrandmember_withscores<'a, K, RV>(
&mut self,
key: K,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zrandmember_withscores<'a, K, RV>(
&mut self,
key: K,
count: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn zrange<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zrange<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn zrange_withscores<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zrange_withscores<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn zrangebylex<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
) -> Result<RV, RedisError>
fn zrangebylex<'a, K, M, MM, RV>( &mut self, key: K, min: M, max: MM, ) -> Result<RV, RedisError>
Source§fn zrangebylex_limit<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize,
) -> Result<RV, RedisError>
fn zrangebylex_limit<'a, K, M, MM, RV>( &mut self, key: K, min: M, max: MM, offset: isize, count: isize, ) -> Result<RV, RedisError>
Source§fn zrevrangebylex<'a, K, MM, M, RV>(
&mut self,
key: K,
max: MM,
min: M,
) -> Result<RV, RedisError>
fn zrevrangebylex<'a, K, MM, M, RV>( &mut self, key: K, max: MM, min: M, ) -> Result<RV, RedisError>
Source§fn zrevrangebylex_limit<'a, K, MM, M, RV>(
&mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize,
) -> Result<RV, RedisError>
fn zrevrangebylex_limit<'a, K, MM, M, RV>( &mut self, key: K, max: MM, min: M, offset: isize, count: isize, ) -> Result<RV, RedisError>
Source§fn zrangebyscore<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
) -> Result<RV, RedisError>
fn zrangebyscore<'a, K, M, MM, RV>( &mut self, key: K, min: M, max: MM, ) -> Result<RV, RedisError>
Source§fn zrangebyscore_withscores<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
) -> Result<RV, RedisError>
fn zrangebyscore_withscores<'a, K, M, MM, RV>( &mut self, key: K, min: M, max: MM, ) -> Result<RV, RedisError>
Source§fn zrangebyscore_limit<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize,
) -> Result<RV, RedisError>
fn zrangebyscore_limit<'a, K, M, MM, RV>( &mut self, key: K, min: M, max: MM, offset: isize, count: isize, ) -> Result<RV, RedisError>
Source§fn zrangebyscore_limit_withscores<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
offset: isize,
count: isize,
) -> Result<RV, RedisError>
fn zrangebyscore_limit_withscores<'a, K, M, MM, RV>( &mut self, key: K, min: M, max: MM, offset: isize, count: isize, ) -> Result<RV, RedisError>
Source§fn zrank<'a, K, M, RV>(&mut self, key: K, member: M) -> Result<RV, RedisError>
fn zrank<'a, K, M, RV>(&mut self, key: K, member: M) -> Result<RV, RedisError>
Source§fn zrem<'a, K, M, RV>(&mut self, key: K, members: M) -> Result<RV, RedisError>
fn zrem<'a, K, M, RV>(&mut self, key: K, members: M) -> Result<RV, RedisError>
Source§fn zrembylex<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
) -> Result<RV, RedisError>
fn zrembylex<'a, K, M, MM, RV>( &mut self, key: K, min: M, max: MM, ) -> Result<RV, RedisError>
Source§fn zremrangebyrank<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zremrangebyrank<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn zrembyscore<'a, K, M, MM, RV>(
&mut self,
key: K,
min: M,
max: MM,
) -> Result<RV, RedisError>
fn zrembyscore<'a, K, M, MM, RV>( &mut self, key: K, min: M, max: MM, ) -> Result<RV, RedisError>
Source§fn zrevrange<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zrevrange<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn zrevrange_withscores<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zrevrange_withscores<'a, K, RV>(
&mut self,
key: K,
start: isize,
stop: isize,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn zrevrangebyscore<'a, K, MM, M, RV>(
&mut self,
key: K,
max: MM,
min: M,
) -> Result<RV, RedisError>
fn zrevrangebyscore<'a, K, MM, M, RV>( &mut self, key: K, max: MM, min: M, ) -> Result<RV, RedisError>
Source§fn zrevrangebyscore_withscores<'a, K, MM, M, RV>(
&mut self,
key: K,
max: MM,
min: M,
) -> Result<RV, RedisError>
fn zrevrangebyscore_withscores<'a, K, MM, M, RV>( &mut self, key: K, max: MM, min: M, ) -> Result<RV, RedisError>
Source§fn zrevrangebyscore_limit<'a, K, MM, M, RV>(
&mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize,
) -> Result<RV, RedisError>
fn zrevrangebyscore_limit<'a, K, MM, M, RV>( &mut self, key: K, max: MM, min: M, offset: isize, count: isize, ) -> Result<RV, RedisError>
Source§fn zrevrangebyscore_limit_withscores<'a, K, MM, M, RV>(
&mut self,
key: K,
max: MM,
min: M,
offset: isize,
count: isize,
) -> Result<RV, RedisError>
fn zrevrangebyscore_limit_withscores<'a, K, MM, M, RV>( &mut self, key: K, max: MM, min: M, offset: isize, count: isize, ) -> Result<RV, RedisError>
Source§fn zrevrank<'a, K, M, RV>(
&mut self,
key: K,
member: M,
) -> Result<RV, RedisError>
fn zrevrank<'a, K, M, RV>( &mut self, key: K, member: M, ) -> Result<RV, RedisError>
Source§fn zscore<'a, K, M, RV>(&mut self, key: K, member: M) -> Result<RV, RedisError>
fn zscore<'a, K, M, RV>(&mut self, key: K, member: M) -> Result<RV, RedisError>
Source§fn zscore_multiple<'a, K, M, RV>(
&mut self,
key: K,
members: &'a [M],
) -> Result<RV, RedisError>
fn zscore_multiple<'a, K, M, RV>( &mut self, key: K, members: &'a [M], ) -> Result<RV, RedisError>
Source§fn zunionstore<'a, D, K, RV>(
&mut self,
dstkey: D,
keys: K,
) -> Result<RV, RedisError>
fn zunionstore<'a, D, K, RV>( &mut self, dstkey: D, keys: K, ) -> Result<RV, RedisError>
Source§fn zunionstore_min<'a, D, K, RV>(
&mut self,
dstkey: D,
keys: K,
) -> Result<RV, RedisError>
fn zunionstore_min<'a, D, K, RV>( &mut self, dstkey: D, keys: K, ) -> Result<RV, RedisError>
Source§fn zunionstore_max<'a, D, K, RV>(
&mut self,
dstkey: D,
keys: K,
) -> Result<RV, RedisError>
fn zunionstore_max<'a, D, K, RV>( &mut self, dstkey: D, keys: K, ) -> Result<RV, RedisError>
Source§fn zunionstore_weights<'a, D, K, W, RV>(
&mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Result<RV, RedisError>
fn zunionstore_weights<'a, D, K, W, RV>( &mut self, dstkey: D, keys: &'a [(K, W)], ) -> Result<RV, RedisError>
Commands::zunionstore, but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.Source§fn zunionstore_min_weights<'a, D, K, W, RV>(
&mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Result<RV, RedisError>
fn zunionstore_min_weights<'a, D, K, W, RV>( &mut self, dstkey: D, keys: &'a [(K, W)], ) -> Result<RV, RedisError>
Commands::zunionstore_min, but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.Source§fn zunionstore_max_weights<'a, D, K, W, RV>(
&mut self,
dstkey: D,
keys: &'a [(K, W)],
) -> Result<RV, RedisError>
fn zunionstore_max_weights<'a, D, K, W, RV>( &mut self, dstkey: D, keys: &'a [(K, W)], ) -> Result<RV, RedisError>
Commands::zunionstore_max, but with the ability to specify a
multiplication factor for each sorted set by pairing one with each key
in a tuple.Source§fn pfadd<'a, K, E, RV>(&mut self, key: K, element: E) -> Result<RV, RedisError>
fn pfadd<'a, K, E, RV>(&mut self, key: K, element: E) -> Result<RV, RedisError>
Source§fn pfcount<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn pfcount<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn pfmerge<'a, D, S, RV>(
&mut self,
dstkey: D,
srckeys: S,
) -> Result<RV, RedisError>
fn pfmerge<'a, D, S, RV>( &mut self, dstkey: D, srckeys: S, ) -> Result<RV, RedisError>
Source§fn publish<'a, K, E, RV>(
&mut self,
channel: K,
message: E,
) -> Result<RV, RedisError>
fn publish<'a, K, E, RV>( &mut self, channel: K, message: E, ) -> Result<RV, RedisError>
Source§fn object_encoding<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn object_encoding<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn object_idletime<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn object_idletime<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn object_freq<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn object_freq<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn object_refcount<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn object_refcount<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn client_getname<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn client_getname<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
Source§fn client_id<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn client_id<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
Source§fn client_setname<'a, K, RV>(
&mut self,
connection_name: K,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn client_setname<'a, K, RV>(
&mut self,
connection_name: K,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn acl_load<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn acl_load<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
Source§fn acl_save<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn acl_save<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
Source§fn acl_list<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn acl_list<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
Source§fn acl_users<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn acl_users<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
Source§fn acl_getuser<'a, K, RV>(&mut self, username: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn acl_getuser<'a, K, RV>(&mut self, username: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn acl_setuser<'a, K, RV>(&mut self, username: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn acl_setuser<'a, K, RV>(&mut self, username: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn acl_setuser_rules<'a, K, RV>(
&mut self,
username: K,
rules: &'a [Rule],
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn acl_setuser_rules<'a, K, RV>(
&mut self,
username: K,
rules: &'a [Rule],
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn acl_deluser<'a, K, RV>(
&mut self,
usernames: &'a [K],
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn acl_deluser<'a, K, RV>(
&mut self,
usernames: &'a [K],
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn acl_dryrun<'a, K, C, A, RV>(
&mut self,
username: K,
command: C,
args: A,
) -> Result<RV, RedisError>
fn acl_dryrun<'a, K, C, A, RV>( &mut self, username: K, command: C, args: A, ) -> Result<RV, RedisError>
Source§fn acl_cat<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn acl_cat<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
Source§fn acl_cat_categoryname<'a, K, RV>(
&mut self,
categoryname: K,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn acl_cat_categoryname<'a, K, RV>(
&mut self,
categoryname: K,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn acl_genpass<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn acl_genpass<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
Source§fn acl_genpass_bits<'a, RV>(&mut self, bits: isize) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn acl_genpass_bits<'a, RV>(&mut self, bits: isize) -> Result<RV, RedisError>where
RV: FromRedisValue,
Source§fn acl_whoami<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn acl_whoami<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
Source§fn acl_log<'a, RV>(&mut self, count: isize) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn acl_log<'a, RV>(&mut self, count: isize) -> Result<RV, RedisError>where
RV: FromRedisValue,
Source§fn acl_log_reset<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn acl_log_reset<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
Source§fn acl_help<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn acl_help<'a, RV>(&mut self) -> Result<RV, RedisError>where
RV: FromRedisValue,
Source§fn geo_add<'a, K, M, RV>(
&mut self,
key: K,
members: M,
) -> Result<RV, RedisError>
fn geo_add<'a, K, M, RV>( &mut self, key: K, members: M, ) -> Result<RV, RedisError>
Source§fn geo_dist<'a, K, M1, M2, RV>(
&mut self,
key: K,
member1: M1,
member2: M2,
unit: Unit,
) -> Result<RV, RedisError>
fn geo_dist<'a, K, M1, M2, RV>( &mut self, key: K, member1: M1, member2: M2, unit: Unit, ) -> Result<RV, RedisError>
Source§fn geo_hash<'a, K, M, RV>(
&mut self,
key: K,
members: M,
) -> Result<RV, RedisError>
fn geo_hash<'a, K, M, RV>( &mut self, key: K, members: M, ) -> Result<RV, RedisError>
Source§fn geo_pos<'a, K, M, RV>(
&mut self,
key: K,
members: M,
) -> Result<RV, RedisError>
fn geo_pos<'a, K, M, RV>( &mut self, key: K, members: M, ) -> Result<RV, RedisError>
Source§fn geo_radius<'a, K, RV>(
&mut self,
key: K,
longitude: f64,
latitude: f64,
radius: f64,
unit: Unit,
options: RadiusOptions,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn geo_radius<'a, K, RV>(
&mut self,
key: K,
longitude: f64,
latitude: f64,
radius: f64,
unit: Unit,
options: RadiusOptions,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn geo_radius_by_member<'a, K, M, RV>(
&mut self,
key: K,
member: M,
radius: f64,
unit: Unit,
options: RadiusOptions,
) -> Result<RV, RedisError>
fn geo_radius_by_member<'a, K, M, RV>( &mut self, key: K, member: M, radius: f64, unit: Unit, options: RadiusOptions, ) -> Result<RV, RedisError>
member. The
member itself is always contained in the results.Source§fn xack<'a, K, G, I, RV>(
&mut self,
key: K,
group: G,
ids: &'a [I],
) -> Result<RV, RedisError>
fn xack<'a, K, G, I, RV>( &mut self, key: K, group: G, ids: &'a [I], ) -> Result<RV, RedisError>
Source§fn xadd<'a, K, ID, F, V, RV>(
&mut self,
key: K,
id: ID,
items: &'a [(F, V)],
) -> Result<RV, RedisError>
fn xadd<'a, K, ID, F, V, RV>( &mut self, key: K, id: ID, items: &'a [(F, V)], ) -> Result<RV, RedisError>
Source§fn xadd_map<'a, K, ID, BTM, RV>(
&mut self,
key: K,
id: ID,
map: BTM,
) -> Result<RV, RedisError>
fn xadd_map<'a, K, ID, BTM, RV>( &mut self, key: K, id: ID, map: BTM, ) -> Result<RV, RedisError>
key.
Use * as the id for the current timestamp. Read moreSource§fn xadd_options<'a, K, ID, I, RV>(
&mut self,
key: K,
id: ID,
items: I,
options: &'a StreamAddOptions,
) -> Result<RV, RedisError>
fn xadd_options<'a, K, ID, I, RV>( &mut self, key: K, id: ID, items: I, options: &'a StreamAddOptions, ) -> Result<RV, RedisError>
Source§fn xadd_maxlen<'a, K, ID, F, V, RV>(
&mut self,
key: K,
maxlen: StreamMaxlen,
id: ID,
items: &'a [(F, V)],
) -> Result<RV, RedisError>
fn xadd_maxlen<'a, K, ID, F, V, RV>( &mut self, key: K, maxlen: StreamMaxlen, id: ID, items: &'a [(F, V)], ) -> Result<RV, RedisError>
Source§fn xadd_maxlen_map<'a, K, ID, BTM, RV>(
&mut self,
key: K,
maxlen: StreamMaxlen,
id: ID,
map: BTM,
) -> Result<RV, RedisError>
fn xadd_maxlen_map<'a, K, ID, BTM, RV>( &mut self, key: K, maxlen: StreamMaxlen, id: ID, map: BTM, ) -> Result<RV, RedisError>
Source§fn xautoclaim_options<'a, K, G, C, MIT, S, RV>(
&mut self,
key: K,
group: G,
consumer: C,
min_idle_time: MIT,
start: S,
options: StreamAutoClaimOptions,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
G: ToRedisArgs,
C: ToRedisArgs,
MIT: ToRedisArgs,
S: ToRedisArgs,
RV: FromRedisValue,
fn xautoclaim_options<'a, K, G, C, MIT, S, RV>(
&mut self,
key: K,
group: G,
consumer: C,
min_idle_time: MIT,
start: S,
options: StreamAutoClaimOptions,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
G: ToRedisArgs,
C: ToRedisArgs,
MIT: ToRedisArgs,
S: ToRedisArgs,
RV: FromRedisValue,
Source§fn xclaim<'a, K, G, C, MIT, ID, RV>(
&mut self,
key: K,
group: G,
consumer: C,
min_idle_time: MIT,
ids: &'a [ID],
) -> Result<RV, RedisError>where
K: ToRedisArgs,
G: ToRedisArgs,
C: ToRedisArgs,
MIT: ToRedisArgs,
ID: ToRedisArgs,
RV: FromRedisValue,
fn xclaim<'a, K, G, C, MIT, ID, RV>(
&mut self,
key: K,
group: G,
consumer: C,
min_idle_time: MIT,
ids: &'a [ID],
) -> Result<RV, RedisError>where
K: ToRedisArgs,
G: ToRedisArgs,
C: ToRedisArgs,
MIT: ToRedisArgs,
ID: ToRedisArgs,
RV: FromRedisValue,
Source§fn xclaim_options<'a, K, G, C, MIT, ID, RV>(
&mut self,
key: K,
group: G,
consumer: C,
min_idle_time: MIT,
ids: &'a [ID],
options: StreamClaimOptions,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
G: ToRedisArgs,
C: ToRedisArgs,
MIT: ToRedisArgs,
ID: ToRedisArgs,
RV: FromRedisValue,
fn xclaim_options<'a, K, G, C, MIT, ID, RV>(
&mut self,
key: K,
group: G,
consumer: C,
min_idle_time: MIT,
ids: &'a [ID],
options: StreamClaimOptions,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
G: ToRedisArgs,
C: ToRedisArgs,
MIT: ToRedisArgs,
ID: ToRedisArgs,
RV: FromRedisValue,
Source§fn xgroup_create<'a, K, G, ID, RV>(
&mut self,
key: K,
group: G,
id: ID,
) -> Result<RV, RedisError>
fn xgroup_create<'a, K, G, ID, RV>( &mut self, key: K, group: G, id: ID, ) -> Result<RV, RedisError>
group. It expects the stream key
to already exist. Otherwise, use xgroup_create_mkstream if it doesn’t.
The id is the starting message id all consumers should read from. Use $ If you want
all consumers to read from the last message added to stream. Read moreSource§fn xgroup_createconsumer<'a, K, G, C, RV>(
&mut self,
key: K,
group: G,
consumer: C,
) -> Result<RV, RedisError>
fn xgroup_createconsumer<'a, K, G, C, RV>( &mut self, key: K, group: G, consumer: C, ) -> Result<RV, RedisError>
consumer explicitly (vs implicit via XREADGROUP)
for given stream `key. Read moreSource§fn xgroup_create_mkstream<'a, K, G, ID, RV>(
&mut self,
key: K,
group: G,
id: ID,
) -> Result<RV, RedisError>
fn xgroup_create_mkstream<'a, K, G, ID, RV>( &mut self, key: K, group: G, id: ID, ) -> Result<RV, RedisError>
group
which makes the stream if it doesn’t exist. Read moreSource§fn xgroup_setid<'a, K, G, ID, RV>(
&mut self,
key: K,
group: G,
id: ID,
) -> Result<RV, RedisError>
fn xgroup_setid<'a, K, G, ID, RV>( &mut self, key: K, group: G, id: ID, ) -> Result<RV, RedisError>
Source§fn xgroup_destroy<'a, K, G, RV>(
&mut self,
key: K,
group: G,
) -> Result<RV, RedisError>
fn xgroup_destroy<'a, K, G, RV>( &mut self, key: K, group: G, ) -> Result<RV, RedisError>
Source§fn xgroup_delconsumer<'a, K, G, C, RV>(
&mut self,
key: K,
group: G,
consumer: C,
) -> Result<RV, RedisError>
fn xgroup_delconsumer<'a, K, G, C, RV>( &mut self, key: K, group: G, consumer: C, ) -> Result<RV, RedisError>
Source§fn xinfo_consumers<'a, K, G, RV>(
&mut self,
key: K,
group: G,
) -> Result<RV, RedisError>
fn xinfo_consumers<'a, K, G, RV>( &mut self, key: K, group: G, ) -> Result<RV, RedisError>
group.
Take note of the StreamInfoConsumersReply return type. Read moreSource§fn xinfo_groups<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn xinfo_groups<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
groups created for a given stream key.
Take note of the StreamInfoGroupsReply return type. Read moreSource§fn xinfo_stream<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn xinfo_stream<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
id, length, number of groups, etc.)
Take note of the StreamInfoStreamReply return type. Read moreSource§fn xlen<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn xlen<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
key. Read moreSource§fn xpending<'a, K, G, RV>(&mut self, key: K, group: G) -> Result<RV, RedisError>
fn xpending<'a, K, G, RV>(&mut self, key: K, group: G) -> Result<RV, RedisError>
key and consumer group and it
returns details about which consumers have pending messages
that haven’t been acked. Read moreSource§fn xpending_count<'a, K, G, S, E, C, RV>(
&mut self,
key: K,
group: G,
start: S,
end: E,
count: C,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
G: ToRedisArgs,
S: ToRedisArgs,
E: ToRedisArgs,
C: ToRedisArgs,
RV: FromRedisValue,
fn xpending_count<'a, K, G, S, E, C, RV>(
&mut self,
key: K,
group: G,
start: S,
end: E,
count: C,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
G: ToRedisArgs,
S: ToRedisArgs,
E: ToRedisArgs,
C: ToRedisArgs,
RV: FromRedisValue,
Source§fn xpending_consumer_count<'a, K, G, S, E, C, CN, RV>(
&mut self,
key: K,
group: G,
start: S,
end: E,
count: C,
consumer: CN,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
G: ToRedisArgs,
S: ToRedisArgs,
E: ToRedisArgs,
C: ToRedisArgs,
CN: ToRedisArgs,
RV: FromRedisValue,
fn xpending_consumer_count<'a, K, G, S, E, C, CN, RV>(
&mut self,
key: K,
group: G,
start: S,
end: E,
count: C,
consumer: CN,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
G: ToRedisArgs,
S: ToRedisArgs,
E: ToRedisArgs,
C: ToRedisArgs,
CN: ToRedisArgs,
RV: FromRedisValue,
Source§fn xrange<'a, K, S, E, RV>(
&mut self,
key: K,
start: S,
end: E,
) -> Result<RV, RedisError>
fn xrange<'a, K, S, E, RV>( &mut self, key: K, start: S, end: E, ) -> Result<RV, RedisError>
key. Read moreSource§fn xrange_all<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn xrange_all<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
key.
Use with caution! Read moreSource§fn xrange_count<'a, K, S, E, C, RV>(
&mut self,
key: K,
start: S,
end: E,
count: C,
) -> Result<RV, RedisError>
fn xrange_count<'a, K, S, E, C, RV>( &mut self, key: K, start: S, end: E, count: C, ) -> Result<RV, RedisError>
key. Read moreSource§fn xread<'a, K, ID, RV>(
&mut self,
keys: &'a [K],
ids: &'a [ID],
) -> Result<RV, RedisError>
fn xread<'a, K, ID, RV>( &mut self, keys: &'a [K], ids: &'a [ID], ) -> Result<RV, RedisError>
ids for each stream key.
This is the basic form of reading streams.
For more advanced control, like blocking, limiting, or reading by consumer group,
see xread_options. Read moreSource§fn xread_options<'a, K, ID, RV>(
&mut self,
keys: &'a [K],
ids: &'a [ID],
options: &'a StreamReadOptions,
) -> Result<RV, RedisError>
fn xread_options<'a, K, ID, RV>( &mut self, keys: &'a [K], ids: &'a [ID], options: &'a StreamReadOptions, ) -> Result<RV, RedisError>
Source§fn xrevrange<'a, K, E, S, RV>(
&mut self,
key: K,
end: E,
start: S,
) -> Result<RV, RedisError>
fn xrevrange<'a, K, E, S, RV>( &mut self, key: K, end: E, start: S, ) -> Result<RV, RedisError>
Source§fn xrevrange_all<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn xrevrange_all<'a, K, RV>(&mut self, key: K) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn xrevrange_count<'a, K, E, S, C, RV>(
&mut self,
key: K,
end: E,
start: S,
count: C,
) -> Result<RV, RedisError>
fn xrevrange_count<'a, K, E, S, C, RV>( &mut self, key: K, end: E, start: S, count: C, ) -> Result<RV, RedisError>
Source§fn xtrim<'a, K, RV>(
&mut self,
key: K,
maxlen: StreamMaxlen,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn xtrim<'a, K, RV>(
&mut self,
key: K,
maxlen: StreamMaxlen,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
key to a MAXLEN count. Read moreSource§fn xtrim_options<'a, K, RV>(
&mut self,
key: K,
options: &'a StreamTrimOptions,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn xtrim_options<'a, K, RV>(
&mut self,
key: K,
options: &'a StreamTrimOptions,
) -> Result<RV, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
key with full options Read moreSource§fn invoke_script<'a, RV>(
&mut self,
invocation: &'a ScriptInvocation<'a>,
) -> Result<RV, RedisError>where
RV: FromRedisValue,
fn invoke_script<'a, RV>(
&mut self,
invocation: &'a ScriptInvocation<'a>,
) -> Result<RV, RedisError>where
RV: FromRedisValue,
Source§fn scan<RV>(&mut self) -> Result<Iter<'_, RV>, RedisError>where
RV: FromRedisValue,
fn scan<RV>(&mut self) -> Result<Iter<'_, RV>, RedisError>where
RV: FromRedisValue,
Source§fn scan_options<RV>(
&mut self,
opts: ScanOptions,
) -> Result<Iter<'_, RV>, RedisError>where
RV: FromRedisValue,
fn scan_options<RV>(
&mut self,
opts: ScanOptions,
) -> Result<Iter<'_, RV>, RedisError>where
RV: FromRedisValue,
Source§fn scan_match<P, RV>(&mut self, pattern: P) -> Result<Iter<'_, RV>, RedisError>where
P: ToRedisArgs,
RV: FromRedisValue,
fn scan_match<P, RV>(&mut self, pattern: P) -> Result<Iter<'_, RV>, RedisError>where
P: ToRedisArgs,
RV: FromRedisValue,
Source§fn hscan<K, RV>(&mut self, key: K) -> Result<Iter<'_, RV>, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn hscan<K, RV>(&mut self, key: K) -> Result<Iter<'_, RV>, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn hscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P,
) -> Result<Iter<'_, RV>, RedisError>
fn hscan_match<K, P, RV>( &mut self, key: K, pattern: P, ) -> Result<Iter<'_, RV>, RedisError>
Source§fn sscan<K, RV>(&mut self, key: K) -> Result<Iter<'_, RV>, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn sscan<K, RV>(&mut self, key: K) -> Result<Iter<'_, RV>, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn sscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P,
) -> Result<Iter<'_, RV>, RedisError>
fn sscan_match<K, P, RV>( &mut self, key: K, pattern: P, ) -> Result<Iter<'_, RV>, RedisError>
Source§fn zscan<K, RV>(&mut self, key: K) -> Result<Iter<'_, RV>, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
fn zscan<K, RV>(&mut self, key: K) -> Result<Iter<'_, RV>, RedisError>where
K: ToRedisArgs,
RV: FromRedisValue,
Source§fn zscan_match<K, P, RV>(
&mut self,
key: K,
pattern: P,
) -> Result<Iter<'_, RV>, RedisError>
fn zscan_match<K, P, RV>( &mut self, key: K, pattern: P, ) -> Result<Iter<'_, RV>, RedisError>
Source§impl<C, T> ConnectionLike for Twhere
C: ConnectionLike,
T: DerefMut<Target = C>,
impl<C, T> ConnectionLike for Twhere
C: ConnectionLike,
T: DerefMut<Target = C>,
Source§fn req_packed_command(&mut self, cmd: &[u8]) -> Result<Value, RedisError>
fn req_packed_command(&mut self, cmd: &[u8]) -> Result<Value, RedisError>
fn req_packed_commands( &mut self, cmd: &[u8], offset: usize, count: usize, ) -> Result<Vec<Value>, RedisError>
Source§fn req_command(&mut self, cmd: &Cmd) -> Result<Value, RedisError>
fn req_command(&mut self, cmd: &Cmd) -> Result<Value, RedisError>
Source§fn get_db(&self) -> i64
fn get_db(&self) -> i64
fn supports_pipelining(&self) -> bool
Source§fn check_connection(&mut self) -> bool
fn check_connection(&mut self) -> bool
PING internally).Source§impl<D, E> ContractStorageTrait for Dwhere
D: StorageInspect<ContractsLatestUtxo, Error = E>,
E: Debug + Display + Send + Sync + 'static,
impl<D, E> ContractStorageTrait for Dwhere
D: StorageInspect<ContractsLatestUtxo, Error = E>,
E: Debug + Display + Send + Sync + 'static,
type InnerError = E
Source§impl<T, Ctx, Decompressed> Decompress<Decompressed, Ctx> for Twhere
Ctx: ContextError,
Decompressed: DecompressibleBy<Ctx, Compressed = T>,
impl<T, Ctx, Decompressed> Decompress<Decompressed, Ctx> for Twhere
Ctx: ContextError,
Decompressed: DecompressibleBy<Ctx, Compressed = T>,
Source§async fn decompress(
self,
ctx: &Ctx,
) -> Result<Decompressed, <Ctx as ContextError>::Error>
async fn decompress( self, ctx: &Ctx, ) -> Result<Decompressed, <Ctx as ContextError>::Error>
Source§impl<T> FmtForward for T
impl<T> FmtForward for T
Source§fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
self to use its Binary implementation when Debug-formatted.Source§fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
self to use its Display implementation when
Debug-formatted.Source§fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
self to use its LowerExp implementation when
Debug-formatted.Source§fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
self to use its LowerHex implementation when
Debug-formatted.Source§fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
self to use its Octal implementation when Debug-formatted.Source§fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
self to use its Pointer implementation when
Debug-formatted.Source§fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
self to use its UpperExp implementation when
Debug-formatted.Source§fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
self to use its UpperHex implementation when
Debug-formatted.Source§impl<Storage> GasPriceServiceAtomicStorage for Storagewhere
Storage: GetMetadataStorage + GetLatestRecordedHeight + KeyValueInspect<Column = GasPriceColumn> + Modifiable + Send + Sync + 'static,
impl<Storage> GasPriceServiceAtomicStorage for Storagewhere
Storage: GetMetadataStorage + GetLatestRecordedHeight + KeyValueInspect<Column = GasPriceColumn> + Modifiable + Send + Sync + 'static,
type Transaction<'a> = StructuredStorage<InMemoryTransaction<&'a mut Storage>> where Storage: 'a
fn begin_transaction( &mut self, ) -> Result<<Storage as GasPriceServiceAtomicStorage>::Transaction<'_>, Error>
fn commit_transaction( transaction: <Storage as GasPriceServiceAtomicStorage>::Transaction<'_>, ) -> Result<(), Error>
Source§impl<S, DbDesc> GenesisProgressInspect<DbDesc> for S
impl<S, DbDesc> GenesisProgressInspect<DbDesc> for S
fn genesis_progress( &self, key: &<GenesisMetadata<DbDesc> as Mappable>::Key, ) -> Option<usize>
Source§impl<Storage> GetLatestRecordedHeight for Storage
impl<Storage> GetLatestRecordedHeight for Storage
Source§fn get_recorded_height(&self) -> Result<Option<BlockHeight>, Error>
fn get_recorded_height(&self) -> Result<Option<BlockHeight>, Error>
Source§impl<Storage> GetMetadataStorage for Storage
impl<Storage> GetMetadataStorage for Storage
fn get_metadata( &self, block_height: &BlockHeight, ) -> Result<Option<UpdaterMetadata>, Error>
Source§impl<T> Instrument for T
impl<T> Instrument for T
Source§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
Source§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
Source§impl<T> Instrument for T
impl<T> Instrument for T
Source§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
Source§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
Source§impl<T> IntoEither for T
impl<T> IntoEither for T
Source§fn into_either(self, into_left: bool) -> Either<Self, Self>
fn into_either(self, into_left: bool) -> Either<Self, Self>
self into a Left variant of Either<Self, Self>
if into_left is true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read moreSource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
self into a Left variant of Either<Self, Self>
if into_left(&self) returns true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read moreSource§impl<S> IntoTransaction for Swhere
S: KeyValueInspect,
impl<S> IntoTransaction for Swhere
S: KeyValueInspect,
Source§fn into_transaction(self) -> StructuredStorage<InMemoryTransaction<S>>
fn into_transaction(self) -> StructuredStorage<InMemoryTransaction<S>>
Source§impl<Column, M, S> IterableTable<M> for Swhere
M: TableWithBlueprint<Column = Column>,
<M as TableWithBlueprint>::Blueprint: BlueprintInspect<M, S>,
S: IterableStore<Column = Column>,
impl<Column, M, S> IterableTable<M> for Swhere
M: TableWithBlueprint<Column = Column>,
<M as TableWithBlueprint>::Blueprint: BlueprintInspect<M, S>,
S: IterableStore<Column = Column>,
Source§fn iter_table_keys<P>(
&self,
prefix: Option<P>,
start: Option<&<M as Mappable>::Key>,
direction: Option<IterDirection>,
) -> BoxedIter<'_, Result<<M as Mappable>::OwnedKey, Error>>
fn iter_table_keys<P>( &self, prefix: Option<P>, start: Option<&<M as Mappable>::Key>, direction: Option<IterDirection>, ) -> BoxedIter<'_, Result<<M as Mappable>::OwnedKey, Error>>
Source§fn iter_table<P>(
&self,
prefix: Option<P>,
start: Option<&<M as Mappable>::Key>,
direction: Option<IterDirection>,
) -> BoxedIter<'_, Result<(<M as Mappable>::OwnedKey, <M as Mappable>::OwnedValue), Error>>
fn iter_table<P>( &self, prefix: Option<P>, start: Option<&<M as Mappable>::Key>, direction: Option<IterDirection>, ) -> BoxedIter<'_, Result<(<M as Mappable>::OwnedKey, <M as Mappable>::OwnedValue), Error>>
Source§impl<S> IteratorOverTable for S
impl<S> IteratorOverTable for S
Source§fn iter_all_keys<M>(
&self,
direction: Option<IterDirection>,
) -> BoxedIter<'_, Result<<M as Mappable>::OwnedKey, Error>>where
M: Mappable,
Self: IterableTable<M>,
fn iter_all_keys<M>(
&self,
direction: Option<IterDirection>,
) -> BoxedIter<'_, Result<<M as Mappable>::OwnedKey, Error>>where
M: Mappable,
Self: IterableTable<M>,
Source§fn iter_all_by_prefix_keys<M, P>(
&self,
prefix: Option<P>,
) -> BoxedIter<'_, Result<<M as Mappable>::OwnedKey, Error>>
fn iter_all_by_prefix_keys<M, P>( &self, prefix: Option<P>, ) -> BoxedIter<'_, Result<<M as Mappable>::OwnedKey, Error>>
Source§fn iter_all_by_start_keys<M>(
&self,
start: Option<&<M as Mappable>::Key>,
direction: Option<IterDirection>,
) -> BoxedIter<'_, Result<<M as Mappable>::OwnedKey, Error>>where
M: Mappable,
Self: IterableTable<M>,
fn iter_all_by_start_keys<M>(
&self,
start: Option<&<M as Mappable>::Key>,
direction: Option<IterDirection>,
) -> BoxedIter<'_, Result<<M as Mappable>::OwnedKey, Error>>where
M: Mappable,
Self: IterableTable<M>,
Source§fn iter_all_filtered_keys<M, P>(
&self,
prefix: Option<P>,
start: Option<&<M as Mappable>::Key>,
direction: Option<IterDirection>,
) -> BoxedIter<'_, Result<<M as Mappable>::OwnedKey, Error>>
fn iter_all_filtered_keys<M, P>( &self, prefix: Option<P>, start: Option<&<M as Mappable>::Key>, direction: Option<IterDirection>, ) -> BoxedIter<'_, Result<<M as Mappable>::OwnedKey, Error>>
Source§fn iter_all<M>(
&self,
direction: Option<IterDirection>,
) -> BoxedIter<'_, Result<(<M as Mappable>::OwnedKey, <M as Mappable>::OwnedValue), Error>>where
M: Mappable,
Self: IterableTable<M>,
fn iter_all<M>(
&self,
direction: Option<IterDirection>,
) -> BoxedIter<'_, Result<(<M as Mappable>::OwnedKey, <M as Mappable>::OwnedValue), Error>>where
M: Mappable,
Self: IterableTable<M>,
Source§fn iter_all_by_prefix<M, P>(
&self,
prefix: Option<P>,
) -> BoxedIter<'_, Result<(<M as Mappable>::OwnedKey, <M as Mappable>::OwnedValue), Error>>
fn iter_all_by_prefix<M, P>( &self, prefix: Option<P>, ) -> BoxedIter<'_, Result<(<M as Mappable>::OwnedKey, <M as Mappable>::OwnedValue), Error>>
Source§fn iter_all_by_start<M>(
&self,
start: Option<&<M as Mappable>::Key>,
direction: Option<IterDirection>,
) -> BoxedIter<'_, Result<(<M as Mappable>::OwnedKey, <M as Mappable>::OwnedValue), Error>>where
M: Mappable,
Self: IterableTable<M>,
fn iter_all_by_start<M>(
&self,
start: Option<&<M as Mappable>::Key>,
direction: Option<IterDirection>,
) -> BoxedIter<'_, Result<(<M as Mappable>::OwnedKey, <M as Mappable>::OwnedValue), Error>>where
M: Mappable,
Self: IterableTable<M>,
Source§fn iter_all_filtered<M, P>(
&self,
prefix: Option<P>,
start: Option<&<M as Mappable>::Key>,
direction: Option<IterDirection>,
) -> BoxedIter<'_, Result<(<M as Mappable>::OwnedKey, <M as Mappable>::OwnedValue), Error>>
fn iter_all_filtered<M, P>( &self, prefix: Option<P>, start: Option<&<M as Mappable>::Key>, direction: Option<IterDirection>, ) -> BoxedIter<'_, Result<(<M as Mappable>::OwnedKey, <M as Mappable>::OwnedValue), Error>>
Source§impl<T> Pipe for Twhere
T: ?Sized,
impl<T> Pipe for Twhere
T: ?Sized,
Source§fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
Source§fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
self and passes that borrow into the pipe function. Read moreSource§fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
self and passes that borrow into the pipe function. Read moreSource§fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
Source§fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R,
) -> R
fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
Source§fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
self, then passes self.as_ref() into the pipe function.Source§fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
self, then passes self.as_mut() into the pipe
function.Source§fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
self, then passes self.deref() into the pipe function.Source§impl<T> Pointable for T
impl<T> Pointable for T
Source§impl<T> PolicyExt for Twhere
T: ?Sized,
impl<T> PolicyExt for Twhere
T: ?Sized,
Source§impl<S> ReadTransaction for Swhere
S: KeyValueInspect,
impl<S> ReadTransaction for Swhere
S: KeyValueInspect,
Source§fn read_transaction(&self) -> StructuredStorage<InMemoryTransaction<&S>>
fn read_transaction(&self) -> StructuredStorage<InMemoryTransaction<&S>>
Source§impl<Storage> SetMetadataStorage for Storagewhere
Storage: Send + Sync + Modifiable,
StructuredStorage<InMemoryTransaction<&'a mut Storage>>: for<'a> StorageMutate<GasPriceMetadata, Error = Error>,
impl<Storage> SetMetadataStorage for Storagewhere
Storage: Send + Sync + Modifiable,
StructuredStorage<InMemoryTransaction<&'a mut Storage>>: for<'a> StorageMutate<GasPriceMetadata, Error = Error>,
fn set_metadata(&mut self, metadata: &UpdaterMetadata) -> Result<(), Error>
Source§impl<T> StorageAsMut for T
impl<T> StorageAsMut for T
fn storage<Type>(&mut self) -> StorageMut<'_, Self, Type>where
Type: Mappable,
fn storage_as_mut<Type>(&mut self) -> StorageMut<'_, Self, Type>where
Type: Mappable,
Source§impl<T> StorageAsRef for T
impl<T> StorageAsRef for T
fn storage<Type>(&self) -> StorageRef<'_, Self, Type>where
Type: Mappable,
fn storage_as_ref<Type>(&self) -> StorageRef<'_, Self, Type>where
Type: Mappable,
Source§impl<T> Tap for T
impl<T> Tap for T
Source§fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
Borrow<B> of a value. Read moreSource§fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
BorrowMut<B> of a value. Read moreSource§fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
AsRef<R> view of a value. Read moreSource§fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
AsMut<R> view of a value. Read moreSource§fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
Deref::Target of a value. Read moreSource§fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
Deref::Target of a value. Read moreSource§fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
.tap() only in debug builds, and is erased in release builds.Source§fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
.tap_mut() only in debug builds, and is erased in release
builds.Source§fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
.tap_borrow() only in debug builds, and is erased in release
builds.Source§fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
.tap_borrow_mut() only in debug builds, and is erased in release
builds.Source§fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
.tap_ref() only in debug builds, and is erased in release
builds.Source§fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
.tap_ref_mut() only in debug builds, and is erased in release
builds.Source§fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
.tap_deref() only in debug builds, and is erased in release
builds.Source§impl<S> Transactional for Swhere
S: KeyValueInspect<Column = Column>,
impl<S> Transactional for Swhere
S: KeyValueInspect<Column = Column>,
Source§type Transaction<'a> = StructuredStorage<InMemoryTransaction<&'a S>>
where
S: 'a
type Transaction<'a> = StructuredStorage<InMemoryTransaction<&'a S>> where S: 'a
Source§fn storage_transaction(
&self,
changes: HashMap<u32, BTreeMap<ReferenceBytesKey, WriteOperation>>,
) -> <S as Transactional>::Transaction<'_>
fn storage_transaction( &self, changes: HashMap<u32, BTreeMap<ReferenceBytesKey, WriteOperation>>, ) -> <S as Transactional>::Transaction<'_>
Changes.