Struct mz_service::local::LocalClient

pub struct LocalClient<C, R, A: Activatable> {
    rx: UnboundedReceiver<R>,
    tx: Sender<C>,
    tx_activator: A,
}

A client to a thread in the same process.

The thread is unparked on every call to send and on Drop.

Fields

rx: UnboundedReceiver<R>

tx: Sender<C>

tx_activator: A

Implementations

impl<C, R, A: Activatable> LocalClient<C, R, A>

pub fn new(rx: UnboundedReceiver<R>, tx: Sender<C>, tx_activator: A) -> Self

Create a new instance of LocalClient from its parts.

pub fn new_partitioned( rxs: Vec<UnboundedReceiver<R>>, txs: Vec<Sender<C>>, tx_activators: Vec<A>, ) -> Partitioned<Self, C, R>

where (C, R): Partitionable<C, R>,

Create a new partitioned local client from parts for each client.

Trait Implementations

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

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

Formats the value using the given formatter.

impl<C, R, A: Activatable> Drop for LocalClient<C, R, A>

fn drop(&mut self)

Executes the destructor for this type.

impl<C, R, A> GenericClient<C, R> for LocalClient<C, R, A>

where C: Debug + Send, R: Debug + Send, A: Debug + Activatable + Send,

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,

Cancel safety

This method is cancel safe. If recv is used as the event in a tokio::select! statement and some other branch completes first, it is guaranteed that no messages were received by this client.

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.

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.