indicator 0.4.4

Abstractions for stream aggregation, we call them `Indicator` s.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

use self::processed::Processed;

use super::{subscriber::Subscriber, Processor, StreamError};

pub use stream::stream;

/// Publisher implementation for streams.
pub mod stream;

/// Processed Publisher.
pub mod processed;

/// Publisher.
pub trait Publisher<'a> {
    /// Output.
    type Output;

    /// Subscribe.
    fn subscribe<S>(&mut self, subscriber: S) -> Result<(), StreamError>
    where
        S: Subscriber<Self::Output> + 'a;
}

impl<'a, 'b, P> Publisher<'a> for &'b mut P
where
    P: Publisher<'a>,
{
    type Output = P::Output;

    fn subscribe<S>(&mut self, subscriber: S) -> Result<(), StreamError>
    where
        S: Subscriber<Self::Output> + 'a,
    {
        Publisher::subscribe(&mut (**self), subscriber)
    }
}

/// Extension of [`Publisher`].
pub trait PublisherExt<'a>: Publisher<'a> {
    /// Combine with a processor.
    fn with<P>(&mut self, processor: P) -> Processed<'_, Self, P>
    where
        P: Processor<'a, Self::Output> + 'a,
    {
        Processed::new(self, processor)
    }
}

impl<'a, P> PublisherExt<'a> for P where P: Publisher<'a> {}