Struct DriverChannel

pub struct DriverChannel<D = CurrentDispatcher> { /* private fields */ }

A fidl-compatible driver channel that also holds a reference to the dispatcher. Defaults to using CurrentDispatcher.

Implementations

impl<D> DriverChannel<D>

pub fn new_with_dispatcher(dispatcher: D, channel: Channel<[Chunk]>) -> Self

Create a new driver fidl channel that will perform its operations on the given dispatcher handle.

pub fn create_with_dispatchers(dispatcher1: D, dispatcher2: D) -> (Self, Self)

Create a new driver fidl channel pair that will perform its operations on the given dispatcher handles.

pub fn create_with_dispatcher(dispatcher: D) -> (Self, Self)

where D: Clone,

Create a new driver fidl channel pair that will perform its operations on the given dispatcher handle, if the dispatcher implements Clone

pub fn into_channel(self) -> Channel<[Chunk]>

Returns the underlying data channel

pub fn into_driver_handle(self) -> DriverHandle

Returns the underlying fdf_handle_t for this channel

impl DriverChannel<CurrentDispatcher>

pub fn new(channel: Channel<[Chunk]>) -> Self

Create a new driver fidl channel that will perform its operations on the CurrentDispatcher.

pub fn create() -> (Self, Self)

Create a new driver fidl channel pair that will perform its operations on the CurrentDispatcher.

Trait Implementations

impl<D: Debug> Debug for DriverChannel<D>

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

Formats the value using the given formatter.

impl Encodable for DriverChannel

type Encoded = WireDriverChannel

The wire type for the value.

const COPY_OPTIMIZATION: CopyOptimization<Self, Self::Encoded> = _

Whether the conversion from Self to Self::Encoded is equivalent to copying the raw bytes of Self.

impl EncodableOption for DriverChannel

type EncodedOption = WireOptionalDriverChannel

The wire type for the optional value.

impl<E: HandleEncoder + ?Sized> Encode<E> for DriverChannel

fn encode( self, encoder: &mut E, out: &mut MaybeUninit<Self::Encoded>, ) -> Result<(), EncodeError>

Encodes this value into an encoder and output.

impl<E: HandleEncoder + ?Sized> EncodeOption<E> for DriverChannel

fn encode_option( this: Option<Self>, encoder: &mut E, out: &mut MaybeUninit<Self::EncodedOption>, ) -> Result<(), EncodeError>

Encodes this optional value into an encoder and output.

impl FromWire<WireDriverChannel> for DriverChannel

fn from_wire(wire: WireDriverChannel) -> Self

Converts the given wire to this type.

const COPY_OPTIMIZATION: CopyOptimization<W, Self> = _

Whether the conversion from W to Self is equivalent to copying the raw bytes of W.

impl FromWireOption<WireOptionalDriverChannel> for DriverChannel

fn from_wire_option(wire: WireOptionalDriverChannel) -> Option<Self>

Converts the given wire to an option of this type.

impl<D> HasExecutor for DriverChannel<D>

type Executor = FuchsiaAsync

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> Transport for DriverChannel<D>

type Error = Status

The error type for the transport.

type Shared = Shared<D>

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

The buffer type for sending.

type SendFutureState = SendBuffer

The future state for send operations.

type Exclusive = 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 RecvFutureState = DriverRecvState

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( _shared: &Self::Shared, buffer: Self::SendBuffer, ) -> Self::SendFutureState

Begins sending a SendBuffer over this transport.

fn poll_send( buffer: 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.

impl<D> RunsTransport<DriverChannel<D>> for FuchsiaAsync