tihu 0.1.3

tihu is a toolset written in Rust.
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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

use async_trait::async_trait;
use std::future::Future;

#[async_trait]
pub trait Handler<In>: Send + Sync + 'static {
    type Out;
    async fn handle(&self, input: In) -> Self::Out;
    fn map_output<NewOut, M>(self, output_mapper: M) -> OutputMapperHandler<Self, M>
    where
        Self: Sized,
        M: Fn(Self::Out) -> NewOut + Send + Sync + 'static,
    {
        OutputMapperHandler {
            handler: self,
            output_mapper: output_mapper,
        }
    }
}

#[async_trait]
impl<In, Out, FutRet, T> Handler<In> for T
where
    In: Send + 'static,
    Out: Send + 'static,
    FutRet: Future<Output = Out> + Send + 'static,
    T: Fn(In) -> FutRet + Send + Sync + 'static,
{
    type Out = Out;
    async fn handle(&self, input: In) -> Out {
        self(input).await
    }
}

pub struct Mapper<M>(pub M);

impl<M> Mapper<M> {
    pub fn chain<H, In, Out>(self, handler: H) -> InputMapperHandler<H, M>
    where
        M: Fn(In) -> Out + Send + Sync + 'static,
        H: Handler<Out>,
    {
        InputMapperHandler {
            input_mapper: self.0,
            handler: handler,
        }
    }
}

pub struct InputMapperHandler<H, M> {
    input_mapper: M,
    handler: H,
}

#[async_trait]
impl<In, NewIn, H, M> Handler<In> for InputMapperHandler<H, M>
where
    In: Send + 'static,
    NewIn: Send + 'static,
    H: Handler<NewIn>,
    M: Fn(In) -> NewIn + Send + Sync + 'static,
{
    type Out = H::Out;
    async fn handle(&self, input: In) -> H::Out {
        let new_input = (self.input_mapper)(input);
        self.handler.handle(new_input).await
    }
}

pub struct OutputMapperHandler<H, M> {
    handler: H,
    output_mapper: M,
}

#[async_trait]
impl<In, H, NewOut, M> Handler<In> for OutputMapperHandler<H, M>
where
    In: Send + 'static,
    NewOut: Send + 'static,
    H: Handler<In>,
    M: Fn(H::Out) -> NewOut + Send + Sync + 'static,
{
    type Out = NewOut;
    async fn handle(&self, input: In) -> NewOut {
        let output = self.handler.handle(input).await;
        (self.output_mapper)(output)
    }
}