Trait Transport

pub trait Transport: 'static {
    type Error: Error + Send + Sync + 'static;
    type Sender: Send;
    type SendBuffer: Send;
    type Encoder<'b>: Encoder + Send
       where Self: 'b;
    type SendFuture<'s>: Future<Output = Result<(), Self::Error>> + Send
       where Self: 's;
    type Receiver: Send;
    type RecvFuture<'r>: Future<Output = Result<Option<Self::RecvBuffer>, Self::Error>> + Send
       where Self: 'r;
    type RecvBuffer: Send;
    type Decoder<'b>: Decoder<'b> + Send
       where Self: 'b;

    // Required methods
    fn split(self) -> (Self::Sender, Self::Receiver);
    fn acquire(sender: &Self::Sender) -> Self::SendBuffer;
    fn encoder(buffer: &mut Self::SendBuffer) -> Self::Encoder<'_>;
    fn send(
        sender: &Self::Sender,
        buffer: Self::SendBuffer,
    ) -> Self::SendFuture<'_>;
    fn recv(receiver: &mut Self::Receiver) -> Self::RecvFuture<'_>;
    fn decoder(buffer: &mut Self::RecvBuffer) -> Self::Decoder<'_>;
}

A transport layer which can send and receive messages.

The futures provided by this trait should be cancel-safe, which constrains their behavior:

• Operations should not partially complete.
• Operations should only complete during polling.

Required Associated Types

type Error: Error + Send + Sync + 'static

The error type for the transport.

type Sender: Send

The sender half of the transport.

type SendBuffer: Send

The buffer type for senders.

type Encoder<'b>: Encoder + Send where Self: 'b

The encoder for send buffers.

type SendFuture<'s>: Future<Output = Result<(), Self::Error>> + Send where Self: 's

The future type for send operations.

type Receiver: Send

The receiver half of the transport.

type RecvFuture<'r>: Future<Output = Result<Option<Self::RecvBuffer>, Self::Error>> + Send where Self: 'r

The future type for receive operations.

type RecvBuffer: Send

The buffer type for receivers.

type Decoder<'b>: Decoder<'b> + Send where Self: 'b

The decoder for receive buffers.

Required Methods

fn split(self) -> (Self::Sender, Self::Receiver)

Splits the transport into a sender and receiver.

fn acquire(sender: &Self::Sender) -> Self::SendBuffer

Acquires an empty send buffer for the transport.

fn encoder(buffer: &mut Self::SendBuffer) -> Self::Encoder<'_>

Gets the encoder for a buffer.

fn send(sender: &Self::Sender, buffer: Self::SendBuffer) -> Self::SendFuture<'_>

Sends an encoded message over the transport.

fn recv(receiver: &mut Self::Receiver) -> Self::RecvFuture<'_>

Receives an encoded message over the transport.

fn decoder(buffer: &mut Self::RecvBuffer) -> Self::Decoder<'_>

Gets the decoder for a buffer.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl Transport for Channel

type Error = Status

type Sender = Sender

type SendBuffer = Buffer

type Encoder<'b> = &'b mut Buffer

type SendFuture<'s> = SendFuture<'s>

type Receiver = Receiver

type RecvFuture<'r> = RecvFuture<'r>

type RecvBuffer = RecvBuffer

type Decoder<'b> = &'b mut RecvBuffer

fn split(self) -> (Self::Sender, Self::Receiver)

fn acquire(_: &Self::Sender) -> Self::SendBuffer

fn encoder(buffer: &mut Self::SendBuffer) -> Self::Encoder<'_>

fn send(sender: &Self::Sender, buffer: Self::SendBuffer) -> Self::SendFuture<'_>

fn recv(receiver: &mut Self::Receiver) -> Self::RecvFuture<'_>

fn decoder(buffer: &mut Self::RecvBuffer) -> Self::Decoder<'_>

Implementors

impl Transport for Mpsc

type Error = Error

type Sender = Sender

type SendBuffer = Vec<u64_le>

type Encoder<'b> = &'b mut Vec<u64_le>

type SendFuture<'s> = SendFuture<'s>

type Receiver = Receiver

type RecvFuture<'r> = RecvFuture<'r>

type RecvBuffer = RecvBuffer

type Decoder<'b> = &'b mut RecvBuffer