Struct reactive_rs::Broadcast

pub struct Broadcast<'a, C: ?Sized, T: ?Sized> { /* private fields */ }

Event source that transmits context/value pairs to multiple observers.

In order to “fork” the broadcast (creating a new stream that will be subscribed to it), the broadcast object can be simply cloned via the Clone trait. Note that cloning the broadcast only increases its reference count; no values are being cloned or copied.

A broadcast may receive a value in one of two ways. First, the user may explicitly call one of its methods: send(), send_ctx(), feed(), feed_ctx(). Second, the broadcast may be created from a parent stream via broadcast() method of the stream object. Either way, each context/value pair received is passed on to each of the subscribed observers, by reference.

Examples

let out = RefCell::new(Vec::new());
let stream = SimpleBroadcast::<i32>::new();
let child1 = stream
    .clone()
    .subscribe(|x| out.borrow_mut().push(*x + 1));
let child2 = stream
    .clone()
    .subscribe(|x| out.borrow_mut().push(*x + 7));
stream.feed(1..=3);
assert_eq!(&*out.borrow(), &[2, 8, 3, 9, 4, 10]);

Implementations

impl<'a, C: 'a + ?Sized, T: 'a + ?Sized> Broadcast<'a, C, T>

pub fn new() -> Self

Creates a new broadcast with specified context and item types.

pub fn from_stream<S>(stream: S) -> Selfwhere
    S: Stream<'a, Context = C, Item = T>,

Create a broadcast from a stream, enabling multiple observers (“fork” the stream).

Note: this is equivalent to calling broadcast() on the stream object.

pub fn send_ctx<K, B>(&self, ctx: K, value: B)where
    K: Borrow<C>,
    B: Borrow<T>,

Send a value along with context to all observers of the broadcast.

pub fn send<B>(&self, value: B)where
    B: Borrow<T>,
    C: Default,

Similar to send_ctx(), but the context is set to the type’s default value.

pub fn feed_ctx<K, B, I>(&self, ctx: K, iter: I)where
    K: Borrow<C>,
    I: Iterator<Item = B>,
    B: Borrow<T>,

Convenience method to feed an iterator of values to all observers of the broadcast, along with a given context.

pub fn feed<B, I>(&self, iter: I)where
    I: Iterator<Item = B>,
    B: Borrow<T>,
    C: Default,

Similar to feed_ctx(), but the context is set to the type’s default value.

Trait Implementations

impl<'a, C: 'a + ?Sized, T: 'a + ?Sized> Clone for Broadcast<'a, C, T>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a, C: 'a + ?Sized, T: 'a + ?Sized> Default for Broadcast<'a, C, T>

fn default() -> Self

Returns the “default value” for a type.

impl<'a, C: 'a + ?Sized, T: 'a + ?Sized> Stream<'a> for Broadcast<'a, C, T>

type Context = C

The type of the context attached to emitted elements.

type Item = T

The type of the elements being emitted.

fn subscribe_ctx<O>(self, observer: O)where
    O: FnMut(&Self::Context, &Self::Item) + 'a,

Same as subscribe(), but the closure receives two arguments (context/value), by reference.

fn subscribe<O>(self, observer: O)where
    O: 'a + FnMut(&Self::Item),

Attaches an observer (a user-provided mutable closure) to the stream, which consumes the stream object.

fn broadcast(self) -> Broadcast<'a, Self::Context, Self::Item>where
    Self: 'a,

Create a broadcast from a stream, enabling multiple observers. This is the only Stream trait method that incurs a slight runtime cost, due to the broadcast object having to store observers as boxed trait objects in a reference-counted container; all other methods can be inlined.

fn ctx(self) -> Context<Self>

Convenience method to extract the context into a separate stream.

fn with_ctx<T>(self, ctx: T) -> WithContext<Self, T>

Set the context to a fixed constant value.

fn with_ctx_map<F, T>(self, func: F) -> WithContextMap<Self, F>where
    F: 'a + FnMut(&Self::Context, &Self::Item) -> T,

Creates a new stream which calls a closure on each context/value and uses that as the context.

fn map<F, T>(self, func: F) -> Map<Self, NoContext<F>>where
    F: 'a + FnMut(&Self::Item) -> T,

Creates a new stream which calls a closure on each element and uses that as the value.

fn map_ctx<F, T>(self, func: F) -> Map<Self, F>where
    F: 'a + FnMut(&Self::Context, &Self::Item) -> T,

Same as map(), but the closure receives two arguments (context/value), by reference.

fn map_both<F, C, T>(self, func: F) -> MapBoth<Self, NoContext<F>>where
    F: 'a + FnMut(&Self::Item) -> (C, T),

Same as map(), but the closure is expected to return a (context, value) tuple, so that both the context and the value can be changed at the same time.

fn map_both_ctx<F, C, T>(self, func: F) -> MapBoth<Self, F>where
    F: 'a + FnMut(&Self::Context, &Self::Item) -> (C, T),

Same as map_both(), but the closure receives two arguments (context/value), by reference.

fn filter<F>(self, func: F) -> Filter<Self, NoContext<F>>where
    F: 'a + FnMut(&Self::Item) -> bool,

Creates a stream which uses a closure to determine if an element should be yielded.

fn filter_ctx<F>(self, func: F) -> Filter<Self, F>where
    F: 'a + FnMut(&Self::Context, &Self::Item) -> bool,

Same as filter(), but the closure receives two arguments (context/value), by reference.

fn filter_map<F, T>(self, func: F) -> FilterMap<Self, NoContext<F>>where
    F: 'a + FnMut(&Self::Item) -> Option<T>,

Creates a stream that both filters and maps.

fn filter_map_ctx<F, T>(self, func: F) -> FilterMap<Self, F>where
    F: 'a + FnMut(&Self::Context, &Self::Item) -> Option<T>,

Same as filter_map(), but the closure receives two arguments (context/value), by reference.

fn fold<F, T: 'a>(self, init: T, func: F) -> Fold<Self, NoContext<F>, T>where
    F: 'a + FnMut(&T, &Self::Item) -> T,

‘Reduce’ operation on streams.

fn fold_ctx<F, T: 'a>(self, init: T, func: F) -> Fold<Self, F, T>where
    F: 'a + FnMut(&Self::Context, &T, &Self::Item) -> T,

Same as fold(), but the closure receives three arguments (context/accumulator/value), by reference.

fn inspect<F>(self, func: F) -> Inspect<Self, NoContext<F>>where
    F: 'a + FnMut(&Self::Item),

Do something with each element of a stream, passing the value on.

fn inspect_ctx<F>(self, func: F) -> Inspect<Self, F>where
    F: 'a + FnMut(&Self::Context, &Self::Item),

Same as inspect(), but the closure receives two arguments (context/value), by reference.