Crate fuchsia_async

A futures-rs executor design specifically for Fuchsia OS.

Example:

A simple, singlethreaded print server:

#[fuchsia_async::run_singlethreaded]
async fn main() {
    let op = say_world();

    // This println! will happen first
    println!("Hello...");

    // Calling `.await` on `op` starts executing `say_world`.
    op.await;
}


async fn say_world() {
    println!("...world");
}

Modules

atomic_future

A future which can be used by multiple threads at once.

net

Asynchronous networking abstractions.

test_support

Testing support for repeated runs

Macros

invoke_for_handle_types

invoke_for_handle_types!{mmm} calls the macro mmm! with two arguments: one is the name of a Zircon handle, the second is one of:

pin_mut

Pins a value on the stack.

Structs

Channel

An I/O object representing a Channel.

Duration

EHandle

A handle to an executor.

Fifo

An I/O object representing a Fifo.

Interval

An asynchronous interval timer. This is a stream of events resolving at a rate of once-per interval.

LocalExecutor

A single-threaded port-based executor for Fuchsia OS.

OnSignals

A future that completes when some set of signals become available on a Handle.

OnStalled

A wrapper for a future who’s steady progress is monitored and will complete with the provided closure if no progress is made before the timeout.

OnTimeout

A wrapper for a future which will complete with a provided closure when a timeout occurs.

RWHandle

A Handle that receives notifications when it is readable/writable.

ReadEntries

ReadEntries represents the future of a single read with multiple entries.

ReadOne

ReadOne represents the future of a single read yielding a single entry.

ReceiverRegistration

A registration of a PacketReceiver. When dropped, it will automatically deregister the PacketReceiver.

RecvMsg

A future used to receive a message from a channel.

SendExecutor

A multi-threaded port-based executor for Fuchsia OS. Requires that tasks scheduled on it implement Send so they can be load balanced between worker threads.

Socket

An I/O object representing a Socket.

Task

A handle to a future that is owned and polled by the executor.

TestExecutor

A single-threaded executor for testing. Exposes additional APIs for manipulating executor state and validating behavior of executed tasks.

Time

A time relative to the executor’s clock.

Timer

An asynchronous timer.

WriteEntries

WriteEntries represents the future of one or more writes.

Enums

WaitState

Indicates whether the executor can run, or is stuck waiting.

Traits

DurationExt

An extension trait to provide after_now on zx::Duration.

FifoEntry

Marker trait for types that can be read/written with a Fifo. Unsafe because not all types may be represented by arbitrary bit patterns.

FifoReadable

Identifies that the object may be used to read entries from a FIFO.

FifoWritable

Identifies that the object may be used to write entries into a FIFO.

PacketReceiver

A trait for handling the arrival of a packet on a zx::Port.

TimeoutExt

A trait which allows futures to be easily wrapped in a timeout.

WakeupTime

The time when a Timer should wakeup.

Functions

unblock

Offload a blocking function call onto a different thread.

Attribute Macros

run

Define an async function that should run to completion on N threads.

run_singlethreaded

Define an async function that should run to completion on a single thread.

run_until_stalled

Define an async function that should complete without stalling.