Struct StoreServiceClient 

pub struct StoreServiceClient<T> { /* private fields */ }

Store service definition with CRUD operations

Implementations

impl StoreServiceClient<Channel>

pub async fn connect<D>(dst: D) -> Result<Self, Error>

where D: TryInto<Endpoint>, D::Error: Into<StdError>,

Attempt to create a new client by connecting to a given endpoint.

impl<T> StoreServiceClient<T>

where T: GrpcService<BoxBody>, T::Error: Into<StdError>, T::ResponseBody: Body<Data = Bytes> + Send + 'static, <T::ResponseBody as Body>::Error: Into<StdError> + Send,

pub fn new(inner: T) -> Self

pub fn with_origin(inner: T, origin: Uri) -> Self

pub fn with_interceptor<F>( inner: T, interceptor: F, ) -> StoreServiceClient<InterceptedService<T, F>>

where F: Interceptor, T::ResponseBody: Default, T: Service<Request<BoxBody>, Response = Response<<T as GrpcService<BoxBody>>::ResponseBody>>, <T as Service<Request<BoxBody>>>::Error: Into<StdError> + Send + Sync,

pub fn send_compressed(self, encoding: CompressionEncoding) -> Self

Compress requests with the given encoding.

This requires the server to support it otherwise it might respond with an error.

pub fn accept_compressed(self, encoding: CompressionEncoding) -> Self

Enable decompressing responses.

pub fn max_decoding_message_size(self, limit: usize) -> Self

Limits the maximum size of a decoded message.

Default: 4MB

pub fn max_encoding_message_size(self, limit: usize) -> Self

Limits the maximum size of an encoded message.

Default: usize::MAX

pub async fn create_items( &mut self, request: impl IntoRequest<CreateItemsRequest>, ) -> Result<Response<CreateItemsResponse>, Status>

Create a new Items

pub async fn get_items( &mut self, request: impl IntoRequest<GetItemsRequest>, ) -> Result<Response<GetItemsResponse>, Status>

Get a Items by ID

pub async fn update_items( &mut self, request: impl IntoRequest<UpdateItemsRequest>, ) -> Result<Response<UpdateItemsResponse>, Status>

Update an existing Items

pub async fn delete_items( &mut self, request: impl IntoRequest<DeleteItemsRequest>, ) -> Result<Response<DeleteItemsResponse>, Status>

Delete a Items by ID

pub async fn create_packets( &mut self, request: impl IntoRequest<CreatePacketsRequest>, ) -> Result<Response<CreatePacketsResponse>, Status>

Create a new Packets

pub async fn get_packets( &mut self, request: impl IntoRequest<GetPacketsRequest>, ) -> Result<Response<GetPacketsResponse>, Status>

Get a Packets by ID

pub async fn update_packets( &mut self, request: impl IntoRequest<UpdatePacketsRequest>, ) -> Result<Response<UpdatePacketsResponse>, Status>

Update an existing Packets

pub async fn delete_packets( &mut self, request: impl IntoRequest<DeletePacketsRequest>, ) -> Result<Response<DeletePacketsResponse>, Status>

Delete a Packets by ID

pub async fn create_connections( &mut self, request: impl IntoRequest<CreateConnectionsRequest>, ) -> Result<Response<CreateConnectionsResponse>, Status>

Create a new Connections

pub async fn get_connections( &mut self, request: impl IntoRequest<GetConnectionsRequest>, ) -> Result<Response<GetConnectionsResponse>, Status>

Get a Connections by ID

pub async fn update_connections( &mut self, request: impl IntoRequest<UpdateConnectionsRequest>, ) -> Result<Response<UpdateConnectionsResponse>, Status>

Update an existing Connections

pub async fn delete_connections( &mut self, request: impl IntoRequest<DeleteConnectionsRequest>, ) -> Result<Response<DeleteConnectionsResponse>, Status>

Delete a Connections by ID

pub async fn create_crdt_messages( &mut self, request: impl IntoRequest<CreateCrdtMessagesRequest>, ) -> Result<Response<CreateCrdtMessagesResponse>, Status>

Create a new CrdtMessages

pub async fn get_crdt_messages( &mut self, request: impl IntoRequest<GetCrdtMessagesRequest>, ) -> Result<Response<GetCrdtMessagesResponse>, Status>

Get a CrdtMessages by ID

pub async fn update_crdt_messages( &mut self, request: impl IntoRequest<UpdateCrdtMessagesRequest>, ) -> Result<Response<UpdateCrdtMessagesResponse>, Status>

Update an existing CrdtMessages

pub async fn delete_crdt_messages( &mut self, request: impl IntoRequest<DeleteCrdtMessagesRequest>, ) -> Result<Response<DeleteCrdtMessagesResponse>, Status>

Delete a CrdtMessages by ID

pub async fn create_crdt_merkles( &mut self, request: impl IntoRequest<CreateCrdtMerklesRequest>, ) -> Result<Response<CreateCrdtMerklesResponse>, Status>

Create a new CrdtMerkles

pub async fn get_crdt_merkles( &mut self, request: impl IntoRequest<GetCrdtMerklesRequest>, ) -> Result<Response<GetCrdtMerklesResponse>, Status>

Get a CrdtMerkles by ID

pub async fn update_crdt_merkles( &mut self, request: impl IntoRequest<UpdateCrdtMerklesRequest>, ) -> Result<Response<UpdateCrdtMerklesResponse>, Status>

Update an existing CrdtMerkles

pub async fn delete_crdt_merkles( &mut self, request: impl IntoRequest<DeleteCrdtMerklesRequest>, ) -> Result<Response<DeleteCrdtMerklesResponse>, Status>

Delete a CrdtMerkles by ID

pub async fn create_sync_endpoints( &mut self, request: impl IntoRequest<CreateSyncEndpointsRequest>, ) -> Result<Response<CreateSyncEndpointsResponse>, Status>

Create a new SyncEndpoints

pub async fn get_sync_endpoints( &mut self, request: impl IntoRequest<GetSyncEndpointsRequest>, ) -> Result<Response<GetSyncEndpointsResponse>, Status>

Get a SyncEndpoints by ID

pub async fn update_sync_endpoints( &mut self, request: impl IntoRequest<UpdateSyncEndpointsRequest>, ) -> Result<Response<UpdateSyncEndpointsResponse>, Status>

Update an existing SyncEndpoints

pub async fn delete_sync_endpoints( &mut self, request: impl IntoRequest<DeleteSyncEndpointsRequest>, ) -> Result<Response<DeleteSyncEndpointsResponse>, Status>

Delete a SyncEndpoints by ID

pub async fn create_queues( &mut self, request: impl IntoRequest<CreateQueuesRequest>, ) -> Result<Response<CreateQueuesResponse>, Status>

Create a new Queues

pub async fn get_queues( &mut self, request: impl IntoRequest<GetQueuesRequest>, ) -> Result<Response<GetQueuesResponse>, Status>

Get a Queues by ID

pub async fn update_queues( &mut self, request: impl IntoRequest<UpdateQueuesRequest>, ) -> Result<Response<UpdateQueuesResponse>, Status>

Update an existing Queues

pub async fn delete_queues( &mut self, request: impl IntoRequest<DeleteQueuesRequest>, ) -> Result<Response<DeleteQueuesResponse>, Status>

Delete a Queues by ID

pub async fn create_queue_items( &mut self, request: impl IntoRequest<CreateQueueItemsRequest>, ) -> Result<Response<CreateQueueItemsResponse>, Status>

Create a new QueueItems

pub async fn get_queue_items( &mut self, request: impl IntoRequest<GetQueueItemsRequest>, ) -> Result<Response<GetQueueItemsResponse>, Status>

Get a QueueItems by ID

pub async fn update_queue_items( &mut self, request: impl IntoRequest<UpdateQueueItemsRequest>, ) -> Result<Response<UpdateQueueItemsResponse>, Status>

Update an existing QueueItems

pub async fn delete_queue_items( &mut self, request: impl IntoRequest<DeleteQueueItemsRequest>, ) -> Result<Response<DeleteQueueItemsResponse>, Status>

Delete a QueueItems by ID

pub async fn create_transactions( &mut self, request: impl IntoRequest<CreateTransactionsRequest>, ) -> Result<Response<CreateTransactionsResponse>, Status>

Create a new Transactions

pub async fn get_transactions( &mut self, request: impl IntoRequest<GetTransactionsRequest>, ) -> Result<Response<GetTransactionsResponse>, Status>

Get a Transactions by ID

pub async fn update_transactions( &mut self, request: impl IntoRequest<UpdateTransactionsRequest>, ) -> Result<Response<UpdateTransactionsResponse>, Status>

Update an existing Transactions

pub async fn delete_transactions( &mut self, request: impl IntoRequest<DeleteTransactionsRequest>, ) -> Result<Response<DeleteTransactionsResponse>, Status>

Delete a Transactions by ID

Trait Implementations

impl<T: Clone> Clone for StoreServiceClient<T>

fn clone(&self) -> StoreServiceClient<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for StoreServiceClient<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.