sena 0.2.0

Library for composable event handlers
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

use std::future::Future;

use crate::utils::captures::Captures;

use super::handler::Handler;

/// Forward output from `from` to `to`,
/// or "pipe" output from one handler to another
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Pipe<Src, Dst> {
    pub from: Src,
    pub to: Dst,
}

impl<Src, Dst, T, E> Handler<T, E> for Pipe<Src, Dst>
where
    T: Send,
    Src: Handler<T, E>,
    Dst: Handler<Src::Output, E>,
{
    type Output = Dst::Output;

    fn handle<'a>(
        &'a self,
        request: T,
    ) -> impl Future<Output = Result<Self::Output, E>> + Send + Captures<(&'a Self, T)> {
        async move {
            let left = self.from.handle(request).await?;
            self.to.handle(left).await
        }
    }
}

impl<Src, Dst> Pipe<Src, Dst> {
    pub const fn new(from: Src, to: Dst) -> Self {
        Self { from, to }
    }
}