fnroute 0.1.0

A small function router with axum-style handler extraction.
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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

use alloc::boxed::Box;
use core::future::Future;

use crate::{BoxFuture, FromRoute, RouteContext, RouteResult};

pub trait Handler<T, S, R>: Clone + 'static {
    fn call(self, context: RouteContext, state: S) -> BoxFuture<RouteResult<R>>;
}

pub trait SyncHandler<T, S, R>: Clone + 'static {
    fn call_sync(self, context: RouteContext, state: S) -> RouteResult<R>;
}

impl<Func, Fut, Out, S, R> Handler<(), S, R> for Func
where
    Func: FnOnce() -> Fut + Clone + 'static,
    Fut: Future<Output = Out> + 'static,
    Out: Into<R>,
    S: 'static,
    R: 'static,
{
    fn call(self, _context: RouteContext, _state: S) -> BoxFuture<RouteResult<R>> {
        let future = self();
        Box::pin(async move { Ok(future.await.into()) })
    }
}

impl<Func, Out, S, R> SyncHandler<(), S, R> for Func
where
    Func: FnOnce() -> Out + Clone + 'static,
    Out: Into<R>,
    S: 'static,
    R: 'static,
{
    fn call_sync(self, _context: RouteContext, _state: S) -> RouteResult<R> {
        Ok(self().into())
    }
}

macro_rules! impl_handler {
    ($($ty:ident),+) => {
        impl<Func, Fut, Out, S, R, $($ty,)+> Handler<($($ty,)+), S, R> for Func
        where
            Func: FnOnce($($ty),+) -> Fut + Clone + 'static,
            Fut: Future<Output = Out> + 'static,
            Out: Into<R>,
            S: Clone + 'static,
            R: 'static,
            $($ty: FromRoute<S>,)+
        {
            #[allow(non_snake_case)]
            fn call(self, context: RouteContext, state: S) -> BoxFuture<RouteResult<R>> {
                Box::pin(async move {
                    $(
                        let $ty = $ty::from_route(&context, &state)?;
                    )+

                    Ok(self($($ty),+).await.into())
                })
            }
        }
    };
}

macro_rules! impl_sync_handler {
    ($($ty:ident),+) => {
        impl<Func, Out, S, R, $($ty,)+> SyncHandler<($($ty,)+), S, R> for Func
        where
            Func: FnOnce($($ty),+) -> Out + Clone + 'static,
            Out: Into<R>,
            S: Clone + 'static,
            R: 'static,
            $($ty: FromRoute<S>,)+
        {
            #[allow(non_snake_case)]
            fn call_sync(self, context: RouteContext, state: S) -> RouteResult<R> {
                $(
                    let $ty = $ty::from_route(&context, &state)?;
                )+

                Ok(self($($ty),+).into())
            }
        }
    };
}

impl_handler!(A);
impl_handler!(A, B);
impl_handler!(A, B, C);
impl_handler!(A, B, C, D);
impl_handler!(A, B, C, D, E);
impl_handler!(A, B, C, D, E, F);
impl_handler!(A, B, C, D, E, F, G);
impl_handler!(A, B, C, D, E, F, G, H);
impl_handler!(A, B, C, D, E, F, G, H, I);
impl_handler!(A, B, C, D, E, F, G, H, I, J);
impl_handler!(A, B, C, D, E, F, G, H, I, J, K);
impl_handler!(A, B, C, D, E, F, G, H, I, J, K, L);
impl_handler!(A, B, C, D, E, F, G, H, I, J, K, L, M);
impl_handler!(A, B, C, D, E, F, G, H, I, J, K, L, M, N);
impl_handler!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O);
impl_handler!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P);

impl_sync_handler!(A);
impl_sync_handler!(A, B);
impl_sync_handler!(A, B, C);
impl_sync_handler!(A, B, C, D);
impl_sync_handler!(A, B, C, D, E);
impl_sync_handler!(A, B, C, D, E, F);
impl_sync_handler!(A, B, C, D, E, F, G);
impl_sync_handler!(A, B, C, D, E, F, G, H);
impl_sync_handler!(A, B, C, D, E, F, G, H, I);
impl_sync_handler!(A, B, C, D, E, F, G, H, I, J);
impl_sync_handler!(A, B, C, D, E, F, G, H, I, J, K);
impl_sync_handler!(A, B, C, D, E, F, G, H, I, J, K, L);
impl_sync_handler!(A, B, C, D, E, F, G, H, I, J, K, L, M);
impl_sync_handler!(A, B, C, D, E, F, G, H, I, J, K, L, M, N);
impl_sync_handler!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O);
impl_sync_handler!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P);