Struct flo_stream::BlockingPublisher

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

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_fully_subscribed(
    &mut self
) -> impl Future<Output = Result<(), Canceled>> + Send

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: 'static + Send + Clone> MessagePublisher for BlockingPublisher<Message>

type Message = Message

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

Creates a subscription to this publisher

fn when_ready(&mut self) -> BoxFuture<'static, MessageSender<Message>>

Reserves a space for a message with the subscribers, returning when it's ready

fn when_empty(&mut self) -> BoxFuture<'static, ()>

Waits until all subscribers have consumed all pending messages

fn is_closed(&self) -> bool

Returns true if this publisher is closed (will not publish any further messages to its subscribers)

fn when_closed(&self) -> BoxFuture<'static, ()>

Future that returns when this publisher is closed

fn publish(&mut self, message: Self::Message) -> BoxFuture<'static, ()>

Publishes a message to the subscribers of this object