httpz 0.0.6

Code once, support every Rust webserver!
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

use http::Method;
use std::future::Future;

use crate::{Endpoint, HttpEndpoint, HttpResponse, Request};

/// represents an async function used to handle the HTTP request. I would highly recommend using [GenericHttpEndpoint] instead of implementing this trait yourself.
pub trait EndpointFn<'this>
where
    Self: Send + Sync + 'this,
{
    /// TODO
    type Response: HttpResponse;

    /// the type of the future returned by the handler function.
    type Fut: Future<Output = Self::Response> + Send + 'this;

    /// is called to handle the HTTP request.
    fn call(&self, req: Request) -> Self::Fut;
}

impl<'this, TFut, TFunc, TRes> EndpointFn<'this> for TFunc
where
    TFunc: Fn(Request) -> TFut + Send + Sync + 'this,
    TFut: Future<Output = TRes> + Send + 'this,
    TRes: HttpResponse,
{
    type Response = TRes;
    type Fut = TFut;

    fn call(&self, req: Request) -> Self::Fut {
        self(req)
    }
}

/// is an easy way of constructing an endpoint from an async function you provide.
pub struct GenericEndpoint<TMethods, TEndpointFn, TUrl>
where
    TMethods: AsRef<[Method]> + Send + Sync + 'static,
    TEndpointFn: for<'this> EndpointFn<'this>,
    TUrl: AsRef<str> + Send + Sync + 'static,
{
    methods: Option<TMethods>,
    func: TEndpointFn,
    url: Option<TUrl>,
}

impl<TMethods, TEndpointFn, TUrl> Clone for GenericEndpoint<TMethods, TEndpointFn, TUrl>
where
    TMethods: AsRef<[Method]> + Clone + Send + Sync + 'static,
    TEndpointFn: for<'this> EndpointFn<'this> + Clone,
    TUrl: AsRef<str> + Clone + Send + Sync + 'static,
{
    fn clone(&self) -> Self {
        Self {
            methods: self.methods.clone(),
            func: self.func.clone(),
            url: self.url.clone(),
        }
    }
}

impl<TMethods, TEndpointFn, TUrl> GenericEndpoint<TMethods, TEndpointFn, TUrl>
where
    TMethods: AsRef<[Method]> + Send + Sync + 'static,
    TEndpointFn: for<'this> EndpointFn<'this>,
    TUrl: AsRef<str> + Send + Sync + 'static,
{
    /// create a new [Endpoint] from a context, a list of methods and a function to handle the request.
    pub fn new(url: TUrl, methods: TMethods, func: TEndpointFn) -> Endpoint<Self> {
        Endpoint::from_endpoint(Self::new_raw(url, methods, func))
    }

    /// create a new generic endpoint from a context, a list of methods and a function to handle the request.
    pub fn new_raw(url: TUrl, methods: TMethods, func: TEndpointFn) -> Self {
        Self {
            methods: Some(methods),
            func,
            url: Some(url),
        }
    }
}

impl<TMethods, TEndpointFn, TUrl> HttpEndpoint for GenericEndpoint<TMethods, TEndpointFn, TUrl>
where
    TMethods: AsRef<[Method]> + Send + Sync + 'static,
    TEndpointFn: for<'this> EndpointFn<'this>,
    TUrl: AsRef<str> + Send + Sync + 'static,
{
    type Routes = TMethods;
    type Url = TUrl;
    type EndpointFn = TEndpointFn;

    fn register(&mut self) -> (Self::Url, Self::Routes) {
        (
            match self.url.take() {
                Some(url) => url,
                None => unreachable!(),
            },
            match self.methods.take() {
                Some(methods) => methods,
                None => unreachable!(),
            },
        )
    }

    fn handler(&self, req: Request) -> <Self::EndpointFn as EndpointFn<'_>>::Fut {
        self.func.call(req)
    }
}