Struct Mpsc

pub struct Mpsc { /* private fields */ }

A paired mpsc transport which runs on fuchsia-async by default.

Implementations

impl Mpsc

pub fn new<P>() -> (ClientEnd<P, Self>, ServerEnd<P, Self>)

Creates client and server end mpscs which can communicate with each other.

Trait Implementations

impl HasExecutor for Mpsc

fn executor(&self) -> Self::Executor

Returns a reference to the executor for this transport.

type Executor = FuchsiaAsync

The executor to spawn on. It must be able to run this transport.

impl NonBlockingTransport for Mpsc

fn send_immediately( future_state: &mut Self::SendFutureState, shared: &Self::Shared, ) -> Result<(), Option<Self::Error>>

Completes a SendFutureState with the shared part of the transport without blocking.

impl Transport for Mpsc

type Error = <Mpsc as Transport>::Error

The error type for the transport.

type Shared = <Mpsc as Transport>::Shared

The shared part of the transport. It is provided by shared reference while sending and receiving. For an MPSC, this would contain a sender.

type Exclusive = <Mpsc as Transport>::Exclusive

The exclusive part of the transport. It is provided by mutable reference only while receiving. For an MPSC, this would contain a receiver.

type SendBuffer = <Mpsc as Transport>::SendBuffer

The buffer type for sending.

type SendFutureState = <Mpsc as Transport>::SendFutureState

The future state for send operations.

type RecvFutureState = <Mpsc as Transport>::RecvFutureState

The future state for receive operations.

type RecvBuffer = <Mpsc as Transport>::RecvBuffer

The buffer type for receivers.

fn split(self) -> (Self::Shared, Self::Exclusive)

Splits the transport into shared and exclusive pieces.

fn acquire(shared: &Self::Shared) -> Self::SendBuffer

Acquires an empty send buffer for the transport.

fn begin_send( shared: &Self::Shared, buffer: Self::SendBuffer, ) -> Self::SendFutureState

Begins sending a SendBuffer over this transport.

fn poll_send( future: Pin<&mut Self::SendFutureState>, cx: &mut Context<'_>, shared: &Self::Shared, ) -> Poll<Result<(), Option<Self::Error>>>

Polls a SendFutureState for completion with the shared part of the transport.

fn begin_recv( shared: &Self::Shared, exclusive: &mut Self::Exclusive, ) -> Self::RecvFutureState

Begins receiving a RecvBuffer over this transport.

fn poll_recv( future: Pin<&mut Self::RecvFutureState>, cx: &mut Context<'_>, shared: &Self::Shared, exclusive: &mut Self::Exclusive, ) -> Poll<Result<Self::RecvBuffer, Option<Self::Error>>>

Polls a RecvFutureState for completion with a receiver.