Trait Store 

pub trait Store:
    Clone
    + Send
    + Sync {
    type Error: Debug;
    type Key: Send + Clone;
    type Value: Value;
    type Count: Send + Clone;

    // Required methods
    fn incr_by<'life0, 'async_trait>(
        &'life0 self,
        key: Self::Key,
        val: Self::Count,
    ) -> Pin<Box<dyn Future<Output = Result<Self::Value, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn incr<'life0, 'async_trait>(
        &'life0 self,
        key: Self::Key,
    ) -> Pin<Box<dyn Future<Output = Result<Self::Value, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn del<'life0, 'async_trait>(
        &'life0 self,
        key: Self::Key,
    ) -> Pin<Box<dyn Future<Output = Result<Option<Self::Value>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn clear<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
}

Store indicates the location and method of caching, such as storing in memory ([MemStore]) in the form of a HashMap or in Redis in the form of key-value pairs.

All methods are implemented in an async manner.

Store can be Clone, use Arc to store it.

Required Associated Types

type Error: Debug

[Error] represents possible errors that may occur during the execution of a function.

type Key: Send + Clone

[Key] is used to denote the index type in key-value pairs.

type Value: Value

Value is a structure used to represent values, such as the current count and the initial time.

type Count: Send + Clone

Alias of Value::Count.

Required Methods

fn incr_by<'life0, 'async_trait>( &'life0 self, key: Self::Key, val: Self::Count, ) -> Pin<Box<dyn Future<Output = Result<Self::Value, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

The [incr_by] function takes a [Key] and an unsigned integer, indicating the amount by which the index should be incremented.

The function returns the result of the incremented count.

fn incr<'life0, 'async_trait>( &'life0 self, key: Self::Key, ) -> Pin<Box<dyn Future<Output = Result<Self::Value, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

The [incr] function is a wrapper for the [incr_by] function, with val = 1.

fn del<'life0, 'async_trait>( &'life0 self, key: Self::Key, ) -> Pin<Box<dyn Future<Output = Result<Option<Self::Value>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

The [del] function deletes the storage of the index [Key] and returns the count result before deletion.

fn clear<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

The [clear] function clears all cached data.

This function is not mandatory; if Store does not need to clear cached data (for example, when stored in Redis or a relational database, bulk clearing of data is slow and unnecessary), the function can do nothing.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<'a, T: Store> Store for &'a T

type Error = <T as Store>::Error

type Key = <T as Store>::Key

type Value = <T as Store>::Value

type Count = <T as Store>::Count

fn incr_by<'life0, 'async_trait>( &'life0 self, key: Self::Key, val: Self::Count, ) -> Pin<Box<dyn Future<Output = Result<Self::Value, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn incr<'life0, 'async_trait>( &'life0 self, key: Self::Key, ) -> Pin<Box<dyn Future<Output = Result<Self::Value, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn del<'life0, 'async_trait>( &'life0 self, key: Self::Key, ) -> Pin<Box<dyn Future<Output = Result<Option<Self::Value>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn clear<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

impl<T: Store> Store for Arc<T>

type Error = <T as Store>::Error

type Key = <T as Store>::Key

type Value = <T as Store>::Value

type Count = <T as Store>::Count

fn incr_by<'life0, 'async_trait>( &'life0 self, key: Self::Key, val: Self::Count, ) -> Pin<Box<dyn Future<Output = Result<Self::Value, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn incr<'life0, 'async_trait>( &'life0 self, key: Self::Key, ) -> Pin<Box<dyn Future<Output = Result<Self::Value, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn del<'life0, 'async_trait>( &'life0 self, key: Self::Key, ) -> Pin<Box<dyn Future<Output = Result<Option<Self::Value>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn clear<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Implementors

impl Store for MemStore

type Error = ()

type Key = String

type Value = DateCountUntil

type Count = u32