Struct AsyncChannel 

pub struct AsyncChannel<D> { /* private fields */ }

A fidl-compatible channel that uses a libasync dispatcher.

Implementations

impl<D> AsyncChannel<D>

pub fn new_on_dispatcher(dispatcher: D, channel: Channel) -> Self

Creates an async channel bound to the dispatcher d that can be used with fidl bindings.

pub fn client_from_zx_channel_on_dispatcher<P>( from: ClientEnd<P, Channel>, dispatcher: D, ) -> ClientEnd<P, Self>

A shortcut for creating a fidl_next compatible [ClientEnd] out of a Channel and dispatcher.

pub fn server_from_zx_channel_on_dispatcher<P>( from: ServerEnd<P, Channel>, dispatcher: D, ) -> ServerEnd<P, Self>

A shortcut for creating a fidl_next compatible [ServerEnd] out of a Channel and dispatcher.

impl<D: Default> AsyncChannel<D>

pub fn new(channel: Channel) -> Self

Creates an async channel bound to the Default instance of dispatcher D that can be used with fidl bindings.

pub fn client_from_zx_channel<P>( from: ClientEnd<P, Channel>, ) -> ClientEnd<P, Self>

A shortcut for creating a fidl_next compatible [ClientEnd] out of a Channel.

pub fn server_from_zx_channel<P>( from: ServerEnd<P, Channel>, ) -> ServerEnd<P, Self>

A shortcut for creating a fidl_next compatible [ServerEnd] out of a Channel.

Trait Implementations

impl<D: Debug> Debug for AsyncChannel<D>

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

Formats the value using the given formatter.

impl<D: OnDispatcher + 'static> HasExecutor for AsyncChannel<D>

type Executor = FidlExecutor<D>

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

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

Returns a reference to the executor for this transport.

impl<D: OnDispatcher> NonBlockingTransport for AsyncChannel<D>

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<D: PartialEq> PartialEq for AsyncChannel<D>

fn eq(&self, other: &AsyncChannel<D>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<D: OnDispatcher> Transport for AsyncChannel<D>

type Error = Status

The error type for the transport.

type Shared = Arc<Channel>

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 = Exclusive<D>

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 = Buffer

The buffer type for sending.

type SendFutureState = SendFutureState

The future state for send operations.

type RecvFutureState = RecvFutureState

The future state for receive operations.

type RecvBuffer = 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( _: &Self::Shared, buffer: Self::SendBuffer, ) -> Self::SendFutureState

Begins sending a SendBuffer over this transport.

fn poll_send( future_state: Pin<&mut Self::SendFutureState>, _: &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_state: 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.

impl<D: OnDispatcher> RunsTransport<AsyncChannel<D>> for FidlExecutor<D>

impl<D> StructuralPartialEq for AsyncChannel<D>