pub trait GenericClient<C, R>: Debug + Send {
    // Required methods
    fn send<'life0, 'async_trait>(
        &'life0 mut self,
        cmd: C
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn recv<'life0, 'async_trait>(
        &'life0 mut self
    ) -> Pin<Box<dyn Future<Output = Result<Option<R>, Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;

    // Provided method
    fn as_stream<'a>(
        &'a mut self
    ) -> Pin<Box<dyn Stream<Item = Result<R, Error>> + Send + 'a>>
       where R: Send + 'a { ... }
}
Expand description

A generic client to a server that receives commands and asynchronously produces responses.

Required Methods§

source

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

Sends a command to the dataflow server.

The command can error for various reasons.

source

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

Receives the next response from the dataflow server.

This method blocks until the next response is available.

A return value of Ok(Some(_)) transmits a response.

A return value of Ok(None) indicates graceful termination of the connection. The owner of the client should not call recv again.

A return value of Err(_) indicates an unrecoverable error. After observing an error, the owner of the client must drop the client.

Implementations of this method must be cancellation safe. That means that work must not be lost if the future returned by this method is dropped.

Provided Methods§

source

fn as_stream<'a>( &'a mut self ) -> Pin<Box<dyn Stream<Item = Result<R, Error>> + Send + 'a>>
where R: Send + 'a,

Returns an adapter that treats the client as a stream.

The stream produces the responses that would be produced by repeated calls to recv.

Trait Implementations§

source§

impl<C, R> GenericClient<C, R> for Box<dyn GenericClient<C, R>>
where C: Send,

source§

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

Sends a command to the dataflow server. Read more
source§

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

Receives the next response from the dataflow server. Read more

Implementations on Foreign Types§

source§

impl<C, R> GenericClient<C, R> for Box<dyn GenericClient<C, R>>
where C: Send,

source§

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

source§

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

Implementors§

source§

impl<C, R, A> GenericClient<C, R> for LocalClient<C, R, A>
where C: Debug + Send, R: Debug + Send, A: Debug + Activatable + Send,

source§

impl<G, C, R> GenericClient<C, R> for GrpcClient<G>
where C: RustType<G::PC> + Send + Sync + 'static, R: RustType<G::PR> + Send + Sync + 'static, G: ProtoServiceTypes,

source§

impl<P, C, R> GenericClient<C, R> for Partitioned<P, C, R>
where P: GenericClient<C, R>, (C, R): Partitionable<C, R>, C: Debug + Send, R: Debug + Send,