Struct tokio_bus::Bus

pub struct Bus<T: Clone + Sync> { /* fields omitted */ }

A bus which buffers messages for all of its readers to eventually read. Allows the dynamic addition and removal of readers.

Methods

impl<T: Clone + Sync> Bus<T>

pub fn new(len: usize) -> Self

Create a new Bus that will buffer at most len messages.

Note that until all readers have read a given message (or the reader has been dropped) it is kept in the buffer and counts against the buffer size.

pub fn add_rx(&mut self) -> BusReader<T>

Create a new BusReader instance which can be used to read messages from the Bus that were sent after the creation of this BusReader.

pub fn try_broadcast(&mut self, val: T) -> Result<(), T>

Attempt to broadcast a message synchronously, failing and returning the item set to be broadcast if the broadcast cannot be completed without blocking.

It can be inconvient in some cases to have to deal with the Sink trait as it necessarily needs to take and pass back ownership. The Bus does not need any blocking I/O except when the buffer is full, which in some systems is an easy situation to avoid.

This method will allow for synchronous sending while still allowing asynchronous readers to be woken up to read.

Trait Implementations

impl<T: Clone + Sync> Drop for Bus<T>

fn drop(&mut self)

Make readers aware of the Bus dropping in order to let them terminate their Stream.

impl<T: Clone + Sync> Sink for Bus<T>

type SinkItem = T

The type of value that the sink accepts.

type SinkError = ()

The type of value produced by the sink when an error occurs.

fn start_send(
    &mut self,
    item: Self::SinkItem
) -> StartSend<Self::SinkItem, Self::SinkError>

Either successfully buffer the item on the internal Bus' buffer, or indicate the Sink is full.

fn poll_complete(&mut self) -> Poll<(), Self::SinkError>

This sink uses the inner Bus' buffer and therefore a success with start_send has already completed the send

fn close(&mut self) -> Result<Async<()>, Self::SinkError>

A method to indicate that no more values will ever be pushed into this sink.

fn wait(self) -> Wait<Self>

Creates a new object which will produce a synchronous sink.

fn with<U, F, Fut>(self, f: F) -> With<Self, U, F, Fut> where
    F: FnMut(U) -> Fut,
    Fut: IntoFuture<Item = Self::SinkItem>,
    <Fut as IntoFuture>::Error: From<Self::SinkError>, 

Composes a function in front of the sink.

fn with_flat_map<U, F, St>(self, f: F) -> WithFlatMap<Self, U, F, St> where
    F: FnMut(U) -> St,
    St: Stream<Item = Self::SinkItem, Error = Self::SinkError>, 

Composes a function in front of the sink.

fn sink_map_err<F, E>(self, f: F) -> SinkMapErr<Self, F> where
    F: FnOnce(Self::SinkError) -> E, 

Transforms the error returned by the sink.

fn sink_from_err<E>(self) -> SinkFromErr<Self, E> where
    E: From<Self::SinkError>, 

Map this sink's error to any error implementing From for this sink's Error, returning a new sink.

fn buffer(self, amt: usize) -> Buffer<Self>

Adds a fixed-size buffer to the current sink.

fn fanout<S>(self, other: S) -> Fanout<Self, S> where
    S: Sink<SinkItem = Self::SinkItem, SinkError = Self::SinkError>,
    Self::SinkItem: Clone, 

Fanout items to multiple sinks.

fn flush(self) -> Flush<Self>

A future that completes when the sink has finished processing all pending requests.

fn send(self, item: Self::SinkItem) -> Send<Self>

A future that completes after the given item has been fully processed into the sink, including flushing.

fn send_all<S>(self, stream: S) -> SendAll<Self, S> where
    S: Stream<Item = Self::SinkItem>,
    Self::SinkError: From<<S as Stream>::Error>, 

A future that completes after the given stream has been fully processed into the sink, including flushing.