Struct fuchsia_async::Fifo

pub struct Fifo<R, W = R> { /* private fields */ }

An I/O object representing a Fifo.

Implementations

impl<R: FifoEntry, W: FifoEntry> Fifo<R, W>

pub fn from_fifo(fifo: impl Into<Fifo<R, W>>) -> Self

Creates a new Fifo from a previously-created zx::Fifo.

Panics

If called on a thread that does not have a current async executor.

pub fn try_write<B: ?Sized + FifoWriteBuffer<W>>( &self, cx: &mut Context<'_>, entries: &B, ) -> Poll<Result<usize, Status>>

Writes entries to the fifo and registers this Fifo as needing a write on receiving a zx::Status::SHOULD_WAIT.

Returns the number of elements processed.

pub fn try_read<B: ?Sized + FifoReadBuffer<R>>( &self, cx: &mut Context<'_>, entries: &mut B, ) -> Poll<Result<usize, Status>>

Reads entries from the fifo into entries and registers this Fifo as needing a read on receiving a zx::Status::SHOULD_WAIT.

Trait Implementations

impl<R, W> AsHandleRef for Fifo<R, W>

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

Get a reference to the handle. One important use of such a reference is for object_wait_many.

fn raw_handle(&self) -> u32

Interpret the reference as a raw handle (an integer type). Two distinct handles will have different raw values (so it can perhaps be used as a key in a data structure).

fn signal_handle( &self, clear_mask: Signals, set_mask: Signals, ) -> Result<(), Status>

Set and clear userspace-accessible signal bits on an object. Wraps the zx_object_signal syscall.

fn wait_handle( &self, signals: Signals, deadline: Instant<MonotonicTimeline>, ) -> Result<Signals, Status>

Waits on a handle. Wraps the zx_object_wait_one syscall.

fn wait_async_handle( &self, port: &Port, key: u64, signals: Signals, options: WaitAsyncOpts, ) -> Result<(), Status>

Causes packet delivery on the given port when the object changes state and matches signals. zx_object_wait_async syscall.

fn get_name(&self) -> Result<Name, Status>

Get the Property::NAME property for this object.

fn set_name(&self, name: &Name) -> Result<(), Status>

Set the Property::NAME property for this object.

fn basic_info(&self) -> Result<HandleBasicInfo, Status>

Wraps the zx_object_get_info syscall for the ZX_INFO_HANDLE_BASIC topic.

fn count_info(&self) -> Result<HandleCountInfo, Status>

Wraps the zx_object_get_info syscall for the ZX_INFO_HANDLE_COUNT topic.

fn get_koid(&self) -> Result<Koid, Status>

Returns the koid (kernel object ID) for this handle.

impl<R, W> AsRef<Fifo<R, W>> for Fifo<R, W>

fn as_ref(&self) -> &Fifo<R, W>

Converts this type into a shared reference of the (usually inferred) input type.

impl<R, W> Debug for Fifo<R, W>

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

Formats the value using the given formatter.

impl<R: FifoEntry, W: FifoEntry> FifoReadable<R> for Fifo<R, W>

fn read<B: ?Sized + FifoReadBuffer<R>>( &self, cx: &mut Context<'_>, entries: &mut B, ) -> Poll<Result<usize, Status>>

Reads entries from the fifo and registers this Fifo as needing a read on receiving a zx::Status::SHOULD_WAIT.

fn read_entries<'a, B: ?Sized + FifoReadBuffer<R>>( &'a self, entries: &'a mut B, ) -> ReadEntries<'a, Self, B, R>

Creates a future that receives entries into entries.

fn read_entry<'a>(&'a self) -> ReadOne<'a, Self, R>

Creates a future that receives a single entry.

fn read_one(&self, cx: &mut Context<'_>) -> Poll<Result<R, Status>>

Reads a single entry and registers this Fifo as needing a read on receiving a zx::Status::SHOULD_WAIT.

impl<R: FifoEntry, W: FifoEntry> FifoWritable<W> for Fifo<R, W>

fn write<B: ?Sized + FifoWriteBuffer<W>>( &self, cx: &mut Context<'_>, entries: &B, ) -> Poll<Result<usize, Status>>

Writes entries to the fifo and registers this Fifo as needing a write on receiving a zx::Status::SHOULD_WAIT.

fn write_entries<'a, B: ?Sized + FifoWriteBuffer<W>>( &'a self, entries: &'a B, ) -> WriteEntries<'a, Self, B, W>

Creates a future that transmits entries to be written.

impl<R, W> From<Fifo<R, W>> for Fifo<R, W>

fn from(fifo: Fifo<R, W>) -> Fifo<R, W>

Converts to this type from the input type.