Struct Channel 

pub struct Channel(/* private fields */);

A channel in a remote FDomain.

Implementations

impl Channel

pub fn recv_msg( &self, ) -> impl Future<Output = Result<MessageBuf, Error>> + use<>

Reads a message from the channel.

pub fn recv_from( &self, cx: &mut Context<'_>, buf: &mut MessageBuf, ) -> Poll<Result<(), Error>>

Poll a channel for a message to read.

pub fn write(&self, bytes: &[u8], handles: Vec<Handle>) -> Result<(), Error>

Writes a message into the channel.

pub fn fdomain_write( &self, bytes: &[u8], handles: Vec<Handle>, ) -> impl Future<Output = Result<(), Error>> + use<>

Writes a message into the channel. Returns a future that will allow you to wait for the write to move across the FDomain connection and return with the result of the actual write call on the target.

pub fn on_closed(&self) -> OnFDomainSignals

A future that returns when the channel is closed.

pub fn is_closed(&self) -> bool

Whether this handle is closed.

pub fn fdomain_write_etc<'b>( &self, bytes: &[u8], handles: Vec<HandleOp<'b>>, ) -> impl Future<Output = Result<(), Error>> + use<'b>

Writes a message into the channel. Optionally duplicates some of the handles rather than consuming them, and can update the handle’s rights before sending.

pub fn stream(self) -> Result<(ChannelMessageStream, ChannelWriter), Error>

Split this channel into a streaming reader and a writer. This is more efficient on the read side if you intend to consume all of the messages from the channel. However it will prevent you from transferring the handle in the future. It also means messages will build up in the buffer, so it may lead to memory issues if you don’t intend to use the messages from the channel as fast as they come.

Trait Implementations

impl AsHandleRef for Channel

fn as_handle_ref(&self) -> HandleRef<'_>

fn object_type() -> ObjectType

fn signal_handle( &self, set: Signals, clear: Signals, ) -> impl Future<Output = Result<(), Error>>

fn domain(&self) -> Arc<Client>

Get the client supporting this handle. See fidl::Proxy::domain.

impl ChannelLike for Channel

fn write_epitaph(&self, bytes: &[u8]) -> Result<(), TransportError>

Write an epitaph to a channel. Same as write_etc but is never fed handles.

impl Debug for Channel

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

Formats the value using the given formatter.

impl Encodable for Channel

type Encoded = WireHandle

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 EncodableAsHandle for Channel

type Dialect = FDomainResourceDialect

What resource dialect can encode this object as a handle.

impl EncodableOption for Channel

type EncodedOption = WireOptionalHandle

The wire type for the optional value.

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

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 Channel

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<T: ProtocolMarker> From<Channel> for ClientEnd<T>

fn from(chan: Channel) -> Self

Converts to this type from the input type.

impl From<Channel> for Handle

fn from(other: Channel) -> Handle

Converts to this type from the input type.

impl<T: ProtocolMarker> From<Channel> for ServerEnd<T>

fn from(chan: Channel) -> Self

Converts to this type from the input type.

impl From<Handle> for Channel

fn from(other: Handle) -> Channel

Converts to this type from the input type.

impl FromWire<WireHandle> for Channel

fn from_wire(wire: WireHandle) -> 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<WireOptionalHandle> for Channel

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

Converts the given wire to an option of this type.

impl HandleBased for Channel

fn close(self) -> impl Future<Output = Result<(), Error>>

Closes this handle. Surfaces errors that dropping the handle will not.

fn duplicate_handle( &self, rights: Rights, ) -> impl Future<Output = Result<Self, Error>>

Duplicate this handle.

fn replace_handle( self, rights: Rights, ) -> impl Future<Output = Result<Self, Error>>

Replace this handle with an equivalent one with different rights.

fn into_handle(self) -> Handle

Convert this handle-based value into a pure Handle.

fn from_handle(handle: Handle) -> Self

Construct a new handle-based value from a Handle.

fn into_handle_based<H: HandleBased>(self) -> H

Turn this handle-based value into one of a different type.

fn from_handle_based<H: HandleBased>(h: H) -> Self

Turn another handle-based type into this one.

impl HasExecutor for Channel

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 Hash for Channel

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Channel

fn cmp(&self, other: &Channel) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Channel

fn eq(&self, other: &Channel) -> 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 PartialOrd for Channel

fn partial_cmp(&self, other: &Channel) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Peered for Channel

fn signal_peer( &self, set: Signals, clear: Signals, ) -> impl Future<Output = Result<(), Error>>

Assert and deassert signals on this handle’s peer.

impl ProxyChannelFor<FDomainResourceDialect> for Channel

type Boxed = FDomainProxyChannel

Box we put around a ProxyChannel when using it within a client.

type Error = Error

Type of the errors we get from this proxy channel.

type HandleDisposition = HandleInfo

Handle disposition used in this dialect.

fn boxed(self) -> Self::Boxed

Construct a new box around a proxy channel.

fn write_etc( &self, bytes: &[u8], handles: &mut [HandleInfo], ) -> Result<(), Option<Error>>

Write data to a Proxy channel

impl Transport for Channel

type Error = Error

The error type for the transport.

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

The buffer type for sending.

type SendFutureState = SendFutureState

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 = ()

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(_: &Self::Shared) -> Self::SendBuffer

Acquires an empty send buffer for the transport.

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

Begins sending a SendBuffer over this transport.

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

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

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

Begins receiving a RecvBuffer over this transport.

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

Polls a RecvFutureState for completion with a receiver.

impl Eq for Channel

impl RunsTransport<Channel> for FuchsiaAsync

impl StructuralPartialEq for Channel