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

use std::marker::PhantomData;

use axum::{handler::Handler, routing::MethodRouter, Router};

use crate::prepare_behave::effect_traits::PrepareRouteEffect;

/// [PrepareRouteEffect] add route
///
/// ## Note
/// calling [Router::route](Router::route)
pub struct Route<S>(&'static str, MethodRouter<S>);

impl<S> Route<S> {
    pub fn new(router: &'static str, service: MethodRouter<S>) -> Self {
        Self(router, service)
    }
}

impl<S: 'static> PrepareRouteEffect<S> for Route<S> {
    fn set_route(self, route: Router<S>) -> Router<S>
    where
        S: Clone + Send + Sync + 'static,
    {
        route.route(self.0, self.1)
    }
}

/// [PrepareRouteEffect] merge router
///
/// ## Note
/// calling [Router::merge](Router::merge)
pub struct Merge<R>(R);

impl<R> Merge<R> {
    pub fn new(merge: R) -> Self
    where
        Router: From<R>,
    {
        Self(merge)
    }
}
impl<S, R> PrepareRouteEffect<S> for Merge<R>
where
    R: 'static,
    Router<S>: From<R>,
    S: Clone + Send + Sync + 'static,
{
    fn set_route(self, route: Router<S>) -> Router<S> {
        route.merge(self.0)
    }
}

/// [PrepareRouteEffect] nest router
///
/// ## Note
/// calling [Router::nest](Router::nest)
pub struct Nest<S> {
    path: &'static str,
    router: Router<S>,
}

impl<S> Nest<S> {
    pub fn new(path: &'static str, router: Router<S>) -> Self {
        Self { path, router }
    }
}

impl<S> PrepareRouteEffect<S> for Nest<S>
where
    S: Clone + Send + Sync + 'static,
{
    fn set_route(self, route: Router<S>) -> Router<S> {
        route.nest(self.path, self.router)
    }
}

/// [PrepareRouteEffect] set fallback handle
///
/// ## Note
/// calling [Router::fallback](Router::fallback)
pub struct Fallback<H, T> {
    handle: H,
    __phantom: PhantomData<T>,
}

impl<R, T> Fallback<R, T> {
    pub fn new(handle: R) -> Self {
        Self {
            handle,
            __phantom: PhantomData,
        }
    }
}
impl<S, R, T> PrepareRouteEffect<S> for Fallback<R, T>
where
    R: Handler<T, S>,
    T: 'static,
    S: Clone + Send + Sync + 'static,
{
    fn set_route(self, route: Router<S>) -> Router<S> {
        route.fallback(self.handle)
    }
}