Trait momento_protos::cache_client::scs_server::Scs

pub trait Scs: Send + Sync + 'static {
    // Required methods
    fn get<'life0, 'async_trait>(
        &'life0 self,
        request: Request<GetRequest>
    ) -> Pin<Box<dyn Future<Output = Result<Response<GetResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn set<'life0, 'async_trait>(
        &'life0 self,
        request: Request<SetRequest>
    ) -> Pin<Box<dyn Future<Output = Result<Response<SetResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn set_if_not_exists<'life0, 'async_trait>(
        &'life0 self,
        request: Request<SetIfNotExistsRequest>
    ) -> Pin<Box<dyn Future<Output = Result<Response<SetIfNotExistsResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn delete<'life0, 'async_trait>(
        &'life0 self,
        request: Request<DeleteRequest>
    ) -> Pin<Box<dyn Future<Output = Result<Response<DeleteResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn keys_exist<'life0, 'async_trait>(
        &'life0 self,
        request: Request<KeysExistRequest>
    ) -> Pin<Box<dyn Future<Output = Result<Response<KeysExistResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn increment<'life0, 'async_trait>(
        &'life0 self,
        request: Request<IncrementRequest>
    ) -> Pin<Box<dyn Future<Output = Result<Response<IncrementResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn update_ttl<'life0, 'async_trait>(
        &'life0 self,
        request: Request<UpdateTtlRequest>
    ) -> Pin<Box<dyn Future<Output = Result<Response<UpdateTtlResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn dictionary_get<'life0, 'async_trait>(
        &'life0 self,
        request: Request<DictionaryGetRequest>
    ) -> Pin<Box<dyn Future<Output = Result<Response<DictionaryGetResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn dictionary_fetch<'life0, 'async_trait>(
        &'life0 self,
        request: Request<DictionaryFetchRequest>
    ) -> Pin<Box<dyn Future<Output = Result<Response<DictionaryFetchResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn dictionary_set<'life0, 'async_trait>(
        &'life0 self,
        request: Request<DictionarySetRequest>
    ) -> Pin<Box<dyn Future<Output = Result<Response<DictionarySetResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn dictionary_increment<'life0, 'async_trait>(
        &'life0 self,
        request: Request<DictionaryIncrementRequest>
    ) -> Pin<Box<dyn Future<Output = Result<Response<DictionaryIncrementResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn dictionary_delete<'life0, 'async_trait>(
        &'life0 self,
        request: Request<DictionaryDeleteRequest>
    ) -> Pin<Box<dyn Future<Output = Result<Response<DictionaryDeleteResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn set_fetch<'life0, 'async_trait>(
        &'life0 self,
        request: Request<SetFetchRequest>
    ) -> Pin<Box<dyn Future<Output = Result<Response<SetFetchResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn set_union<'life0, 'async_trait>(
        &'life0 self,
        request: Request<SetUnionRequest>
    ) -> Pin<Box<dyn Future<Output = Result<Response<SetUnionResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn set_difference<'life0, 'async_trait>(
        &'life0 self,
        request: Request<SetDifferenceRequest>
    ) -> Pin<Box<dyn Future<Output = Result<Response<SetDifferenceResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn set_contains<'life0, 'async_trait>(
        &'life0 self,
        request: Request<SetContainsRequest>
    ) -> Pin<Box<dyn Future<Output = Result<Response<SetContainsResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn list_push_front<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ListPushFrontRequest>
    ) -> Pin<Box<dyn Future<Output = Result<Response<ListPushFrontResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn list_push_back<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ListPushBackRequest>
    ) -> Pin<Box<dyn Future<Output = Result<Response<ListPushBackResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn list_pop_front<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ListPopFrontRequest>
    ) -> Pin<Box<dyn Future<Output = Result<Response<ListPopFrontResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn list_pop_back<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ListPopBackRequest>
    ) -> Pin<Box<dyn Future<Output = Result<Response<ListPopBackResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn list_erase<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ListEraseRequest>
    ) -> Pin<Box<dyn Future<Output = Result<Response<ListEraseResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn list_remove<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ListRemoveRequest>
    ) -> Pin<Box<dyn Future<Output = Result<Response<ListRemoveResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn list_fetch<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ListFetchRequest>
    ) -> Pin<Box<dyn Future<Output = Result<Response<ListFetchResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn list_length<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ListLengthRequest>
    ) -> Pin<Box<dyn Future<Output = Result<Response<ListLengthResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn list_concatenate_front<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ListConcatenateFrontRequest>
    ) -> Pin<Box<dyn Future<Output = Result<Response<ListConcatenateFrontResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn list_concatenate_back<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ListConcatenateBackRequest>
    ) -> Pin<Box<dyn Future<Output = Result<Response<ListConcatenateBackResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn list_retain<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ListRetainRequest>
    ) -> Pin<Box<dyn Future<Output = Result<Response<ListRetainResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn sorted_set_put<'life0, 'async_trait>(
        &'life0 self,
        request: Request<SortedSetPutRequest>
    ) -> Pin<Box<dyn Future<Output = Result<Response<SortedSetPutResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn sorted_set_fetch<'life0, 'async_trait>(
        &'life0 self,
        request: Request<SortedSetFetchRequest>
    ) -> Pin<Box<dyn Future<Output = Result<Response<SortedSetFetchResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn sorted_set_get_score<'life0, 'async_trait>(
        &'life0 self,
        request: Request<SortedSetGetScoreRequest>
    ) -> Pin<Box<dyn Future<Output = Result<Response<SortedSetGetScoreResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn sorted_set_remove<'life0, 'async_trait>(
        &'life0 self,
        request: Request<SortedSetRemoveRequest>
    ) -> Pin<Box<dyn Future<Output = Result<Response<SortedSetRemoveResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn sorted_set_increment<'life0, 'async_trait>(
        &'life0 self,
        request: Request<SortedSetIncrementRequest>
    ) -> Pin<Box<dyn Future<Output = Result<Response<SortedSetIncrementResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn sorted_set_get_rank<'life0, 'async_trait>(
        &'life0 self,
        request: Request<SortedSetGetRankRequest>
    ) -> Pin<Box<dyn Future<Output = Result<Response<SortedSetGetRankResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
}

Generated trait containing gRPC methods that should be implemented for use with ScsServer.

Required Methods

fn get<'life0, 'async_trait>( &'life0 self, request: Request<GetRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<GetResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn set<'life0, 'async_trait>( &'life0 self, request: Request<SetRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<SetResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn set_if_not_exists<'life0, 'async_trait>( &'life0 self, request: Request<SetIfNotExistsRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<SetIfNotExistsResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn delete<'life0, 'async_trait>( &'life0 self, request: Request<DeleteRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<DeleteResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn keys_exist<'life0, 'async_trait>( &'life0 self, request: Request<KeysExistRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<KeysExistResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn increment<'life0, 'async_trait>( &'life0 self, request: Request<IncrementRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<IncrementResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn update_ttl<'life0, 'async_trait>( &'life0 self, request: Request<UpdateTtlRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<UpdateTtlResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn dictionary_get<'life0, 'async_trait>( &'life0 self, request: Request<DictionaryGetRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<DictionaryGetResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn dictionary_fetch<'life0, 'async_trait>( &'life0 self, request: Request<DictionaryFetchRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<DictionaryFetchResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn dictionary_set<'life0, 'async_trait>( &'life0 self, request: Request<DictionarySetRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<DictionarySetResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn dictionary_increment<'life0, 'async_trait>( &'life0 self, request: Request<DictionaryIncrementRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<DictionaryIncrementResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn dictionary_delete<'life0, 'async_trait>( &'life0 self, request: Request<DictionaryDeleteRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<DictionaryDeleteResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn set_fetch<'life0, 'async_trait>( &'life0 self, request: Request<SetFetchRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<SetFetchResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn set_union<'life0, 'async_trait>( &'life0 self, request: Request<SetUnionRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<SetUnionResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn set_difference<'life0, 'async_trait>( &'life0 self, request: Request<SetDifferenceRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<SetDifferenceResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn set_contains<'life0, 'async_trait>( &'life0 self, request: Request<SetContainsRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<SetContainsResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn list_push_front<'life0, 'async_trait>( &'life0 self, request: Request<ListPushFrontRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<ListPushFrontResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn list_push_back<'life0, 'async_trait>( &'life0 self, request: Request<ListPushBackRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<ListPushBackResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn list_pop_front<'life0, 'async_trait>( &'life0 self, request: Request<ListPopFrontRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<ListPopFrontResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn list_pop_back<'life0, 'async_trait>( &'life0 self, request: Request<ListPopBackRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<ListPopBackResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn list_erase<'life0, 'async_trait>( &'life0 self, request: Request<ListEraseRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<ListEraseResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn list_remove<'life0, 'async_trait>( &'life0 self, request: Request<ListRemoveRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<ListRemoveResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn list_fetch<'life0, 'async_trait>( &'life0 self, request: Request<ListFetchRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<ListFetchResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn list_length<'life0, 'async_trait>( &'life0 self, request: Request<ListLengthRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<ListLengthResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn list_concatenate_front<'life0, 'async_trait>( &'life0 self, request: Request<ListConcatenateFrontRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<ListConcatenateFrontResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn list_concatenate_back<'life0, 'async_trait>( &'life0 self, request: Request<ListConcatenateBackRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<ListConcatenateBackResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn list_retain<'life0, 'async_trait>( &'life0 self, request: Request<ListRetainRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<ListRetainResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn sorted_set_put<'life0, 'async_trait>( &'life0 self, request: Request<SortedSetPutRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<SortedSetPutResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Add or Updates new element with its score to the Sorted Set. If sorted set doesn’t exist, a new one is created with the specified element and its associated score. If an element exists, then its associate score gets overridden with the one provided in this operation.

fn sorted_set_fetch<'life0, 'async_trait>( &'life0 self, request: Request<SortedSetFetchRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<SortedSetFetchResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Fetches a subset of elements in the sorted set.

fn sorted_set_get_score<'life0, 'async_trait>( &'life0 self, request: Request<SortedSetGetScoreRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<SortedSetGetScoreResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Gets the specified element and its associated score if it exists in the sorted set.

fn sorted_set_remove<'life0, 'async_trait>( &'life0 self, request: Request<SortedSetRemoveRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<SortedSetRemoveResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Removes specified elements and their associated scores

fn sorted_set_increment<'life0, 'async_trait>( &'life0 self, request: Request<SortedSetIncrementRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<SortedSetIncrementResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Changes the score associated with the element by specified amount. If the provided amount is negative, then the score associated with the element is decremented. If the element that needs to be incremented isn’t present in the sorted set, it is added with specified number as the score. If the set itself doesn’t exist then a new one with specified element and score is created.

fn sorted_set_get_rank<'life0, 'async_trait>( &'life0 self, request: Request<SortedSetGetRankRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<SortedSetGetRankResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Gives the rank of an element.

Implementors