flo_stream is a crate providing some extra utilities for streams in Rust's
futures library, in particular the 'pubsub' pattern.
The primary new feature is a "pubsub" mechanism - a way to subscribe to updates sent to a futures
Sink. This differs
Receiver mechanism provided in the main futures library in two key ways: it's possible to have
multiple receivers, and messages sent when there is no subscriber connected will be ignored.
The sink type provided is
Publisher. You can create one with
let publisher = Publisher::new(10). This implements
Sink trait so can be used in a very similar way to send messages. The number passed in is the maximum number
of waiting messages allowed for any given subscriber.
A subscription can be created using
let subscription = publisher.subscribe(). Any messages sent to the sink after
this is called is relayed to all subscriptions. A subscription is a
Stream so can interact with other parts of the
futures library in the usual way.
Here's a full worked example with a single subscriber.
let publisher = Publisher::new(10); let mut publisher = executor::spawn(publisher); let subscriber = publisher.subscribe(); let mut subscriber = executor::spawn(subscriber); publisher.wait_send(1).unwrap(); publisher.wait_send(2).unwrap(); publisher.wait_send(3).unwrap(); assert!(subscriber.wait_stream() == Some(Ok(1))); assert!(subscriber.wait_stream() == Some(Ok(2))); assert!(subscriber.wait_stream() == Some(Ok(3)));
A blocking publisher is a publisher that blocks messages until it has enough subscribers
An 'expiring' publisher is one that responds to backpressure from its subscribers by expiring the most recent message.
A publisher represents a sink that sends messages to zero or more subscribers
A single publisher is a publisher that sends each message to only a single subscriber rather than all of them
Represents a subscriber stream from a publisher sink
Trait implemented by sinks that act as a publisher