Struct async_backplane::Device

pub struct Device { /* fields omitted */ }

A Device connects a Future to the backplane.

Implementations

impl Device

pub fn new() -> Self

Creates a new Device.

pub fn device_id(&self) -> DeviceID

Get the ID of this Device.

pub fn line(&self) -> Line

Opens a line to the Device.

pub fn disconnect(self, fault: Option<Fault>)

Notify our peers we’re disconnecting.

pub fn link(&self, other: &Device, mode: LinkMode)

Link with another Device with the provided LinkMode. LinkModes are additive, so you can ‘upgrade’ a link this way.

This method is intended for static-style linking, where the topology is not expected to change. You should not link to a Device this way after linking to it through a Line.

pub fn unlink(&self, other: &Device, mode: LinkMode)

Unlink from another Device with the provided LinkMode. LinkModes are subtractive, so you can ‘downgrade’ a link this way.

This method is intended for static-style linking, where the topology is not expected to change. You should not link to a Device this way after linking to it through a Line.

pub fn link_line(&self, other: Line, mode: LinkMode) -> Result<(), LinkError>

Link with a line. This is safer than linking directly to a Device, but a little slower.

pub fn unlink_line(&self, other: &Line, mode: LinkMode)

Unlink with a line. This is safer than linking directly to a Device, but a little slower.

pub fn receive(&self) -> Option<Message>

Attempts to get the next message. Does not wait for one to arrive.

pub async fn watch<F, C>(
    &mut self,
    f: F
) -> Result<Watched<<F as Future>::Output>, Crash<C>> where
    F: Future + Unpin,
    F::Output: Debug,
    C: 'static + Any + Debug + Send, 

Returns the first of (with a bias towards the former):

• The next message to be received.
• The result of the completed future.
• The crash of the Device.

pub async fn part_manage<'a, F, T, C>(
    self,
    f: F
) -> Result<(Device, T), Crash<C>> where
    F: Future<Output = Result<T, C>> + Unpin,
    C: 'static + Debug + Send,
    T: Debug, 

Runs an async closure while monitoring for messages. Messages are handled as follows:

• Disconnects without fault are ignored.
• Disconnects with fault cause the Device to fault.
• Requests to disconnect cause the Device to crash but announce a successful completion.

If the provided closure returns successfully, the result is returned along with the Device for re-use. Monitors will not be notified.

If the Device faults, either because the provided closure returned an Err variant or because a fault was propagated, announces our fault to our monitors.

pub async fn manage<F, C, T>(self, f: F) -> Result<T, Crash<C>> where
    F: Future<Output = Result<T, C>> + Unpin,
    C: 'static + Debug + Send,
    T: Debug, 

Like part_manage(), but in the case of successful completion of the provided future, notifies our monitors and consumes self

Trait Implementations

impl Debug for Device

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

Formats the value using the given formatter.

impl Default for Device

fn default() -> Self

Returns the “default value” for a type.

impl Drop for Device

fn drop(&mut self)

Executes the destructor for this type.

impl Stream for Device

type Item = Message

Values yielded by the stream.

fn poll_next(
    self: Pin<&mut Self>,
    ctx: &mut Context<'_>
) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.

impl Unpin for Device