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
50
51
52

use super::AsyncOperator;
use core::task::{Context, Poll};
use tower_service::Service;

/// A wrapper converting a [`Service`] into an [`AsyncOperator`].
#[derive(Debug, Clone, Copy)]
pub struct ServiceOp<S> {
    inner: S,
    // _input: PhantomData<fn() -> I>,
}

impl<S> ServiceOp<S> {
    /// Create from a service.
    fn new<I>(inner: S) -> Self
    where
        S: Service<I>,
    {
        Self { inner }
    }
}

impl<S, I, O> AsyncOperator<I> for ServiceOp<S>
where
    S: Service<I, Response = O>,
{
    type Output = O;

    type Error = S::Error;

    type Future<'a> = S::Future where S: 'a;

    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
        self.inner.poll_ready(cx)
    }

    fn next(&mut self, input: I) -> Self::Future<'_> {
        self.inner.call(input)
    }
}

/// A trait that converts a [`Service`] into an [`AsyncOperator`]
pub trait ServiceOperator<I>: Service<I> {
    /// Convert into an [`AsyncOperator`].
    fn into_async_operator(self) -> ServiceOp<Self>
    where
        Self: Sized,
    {
        ServiceOp::new(self)
    }
}

impl<T, I> ServiceOperator<I> for T where T: Service<I> {}