Struct distant_net::common::InmemoryTransport

pub struct InmemoryTransport { /* private fields */ }

Represents a Transport comprised of two inmemory channels

Implementations

impl InmemoryTransport

pub fn new(tx: Sender<Vec<u8>>, rx: Receiver<Vec<u8>>) -> Self

Creates a new transport where tx is used to send data out of the transport during try_write and rx is used to receive data into the transport during try_read.

pub fn make(buffer: usize) -> (Sender<Vec<u8>>, Receiver<Vec<u8>>, Self)

Returns (incoming_tx, outgoing_rx, transport) where incoming_tx is used to send data to the transport where it will be consumed during try_read and outgoing_rx is used to receive data from the transport when it is written using try_write.

pub fn pair(buffer: usize) -> (Self, Self)

Returns pair of transports that are connected such that one sends to the other and vice versa

pub fn link(&mut self, other: &mut InmemoryTransport, buffer: usize)

Links two independent InmemoryTransport together by dropping their internal channels and generating new ones of buffer capacity to connect these transports.

Note

This will drop any pre-existing data in the internal storage to avoid corruption.

Trait Implementations

impl Debug for InmemoryTransport

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

Formats the value using the given formatter.

impl Reconnectable for InmemoryTransport

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

Once the underlying channels have closed, there is no way for this transport to re-establish those channels; therefore, reconnecting will fail with ErrorKind::ConnectionRefused if either underlying channel has closed.

impl Transport for InmemoryTransport

fn try_read(&self, buf: &mut [u8]) -> Result<usize>

Tries to read data from the transport into the provided buffer, returning how many bytes were read.

fn try_write(&self, buf: &[u8]) -> Result<usize>

Try to write a buffer to the transport, returning how many bytes were written.

fn ready<'life0, 'async_trait>(
    &'life0 self,
    interest: Interest
) -> Pin<Box<dyn Future<Output = Result<Ready>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Waits for the transport to be ready based on the given interest, returning the ready status.