Struct flo_stream::BlockingPublisher

pub struct BlockingPublisher<Message> { /* private fields */ }

A blocking publisher is a publisher that blocks messages until it has enough subscribers

This is useful for cases where a publisher is being used asynchronously and wants to ensure that its messages are sent to at least one subscriber. Once the required number of subscribers is reached, this will not block again even if some subscribers are dropped.

Implementations

impl<Message: Clone> BlockingPublisher<Message>

pub fn new(
    required_subscribers: usize,
    buffer_size: usize
) -> BlockingPublisher<Message>

Creates a new blocking publisher

This publisher will refuse to receive any items until at least required_subscribers are connected. The buffer size indicates the number of queued items permitted per buffer.

pub fn when_ready(&mut self) -> impl Future<Item = (), Error = Canceled>

Returns a future that will complete when this publisher has enough subscribers

This is useful as a way to avoid blocking with wait_send when setting up the publisher

Trait Implementations

impl<Message: Clone> PublisherSink<Message> for BlockingPublisher<Message>

fn subscribe(&mut self) -> Subscriber<Message>

Creates a subscription to this publisher

impl<Message: Clone> Sink for BlockingPublisher<Message>

type SinkItem = Message

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: Message) -> StartSend<Message, ()>

Begin the process of sending a value to the sink.

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

Flush all output from this sink, if necessary.

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>where
    Self: Sized,

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>,
    Self: Sized,

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>,
    Self: Sized,

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,
    Self: Sized,

Transforms the error returned by the sink.

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

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>where
    Self: Sized,

Adds a fixed-size buffer to the current sink.

fn flush(self) -> Flush<Self>where
    Self: Sized,

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

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

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>,
    Self: Sized,

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