dhttp 0.1.0

The True Internet
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

use std::any::Any;

use futures::future::BoxFuture;

use crate::endpoint::server::{Request, Response};

pub trait Serve {
    type Future<'s>: Future<Output = ()>;

    fn serve<'s>(&self, request: &'s mut Request, response: &'s mut Response) -> Self::Future<'s>;
}

/// A helper trait to allow using async closures as services.
pub trait ServiceFn<'s> {
    type Future: Future<Output = ()> + 's;

    fn call(&self, req: &'s mut Request, res: &'s mut Response) -> Self::Future;
}

impl<'s, F, Fut> ServiceFn<'s> for F
where
    F: Fn(&'s mut Request, &'s mut Response) -> Fut,
    Fut: Future<Output = ()> + Send + 's,
{
    type Future = Fut;

    fn call(&self, req: &'s mut Request, res: &'s mut Response) -> Self::Future {
        (self)(req, res)
    }
}

impl<S> Serve for S
where
    S: for<'s> ServiceFn<'s>,
{
    type Future<'s> = <S as ServiceFn<'s>>::Future;

    fn serve<'s>(&self, request: &'s mut Request, response: &'s mut Response) -> Self::Future<'s> {
        self.call(request, response)
    }
}

trait CloneableService: Any {
    fn serve<'s>(&self, request: &'s mut Request, response: &'s mut Response) -> BoxFuture<'s, ()>;

    fn clone_box(&self) -> Box<dyn CloneableService + Send + Sync>;
}

impl<H: for<'s> Serve<Future<'s>: Send> + Any + Clone + Send + Sync> CloneableService for H {
    fn serve<'s>(&self, request: &'s mut Request, response: &'s mut Response) -> BoxFuture<'s, ()> {
        Box::pin(self.serve(request, response))
    }

    fn clone_box(&self) -> Box<dyn CloneableService + Send + Sync> {
        Box::new(self.clone())
    }
}

pub trait IntoBoxService: for<'s> Serve<Future<'s>: Send> + Clone + Send + Sync + 'static {
    fn into_box_service(self) -> BoxService {
        BoxService(Box::new(self))
    }
}

impl<S: for<'s> Serve<Future<'s>: Send> + Clone + Send + Sync + 'static> IntoBoxService for S {}

pub type BoxServiceFuture<'s> = BoxFuture<'s, ()>;
type DynService = dyn CloneableService + Send + Sync;

pub struct BoxService(Box<DynService>);

impl std::fmt::Debug for BoxService {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_tuple("BoxService").finish()
    }
}

impl BoxService {
    pub fn downcast_ref<T: Any>(&self) -> Option<&T> {
        (self.0.as_ref() as &dyn Any).downcast_ref::<T>()
    }

    pub fn downcast_mut<T: Any>(&mut self) -> Option<&mut T> {
        (self.0.as_mut() as &mut dyn Any).downcast_mut::<T>()
    }

    pub fn downcast<T: Any>(self) -> Result<Box<T>, BoxService> {
        match (self.0.as_ref() as &dyn Any).is::<T>() {
            true => Ok((self.0 as Box<dyn Any>)
                .downcast::<T>()
                .expect("type checked by is::<T>()")),
            false => Err(self),
        }
    }
}

impl Serve for BoxService {
    type Future<'s> = BoxServiceFuture<'s>;

    fn serve<'s>(&self, request: &'s mut Request, response: &'s mut Response) -> Self::Future<'s> {
        self.0.serve(request, response)
    }
}

impl Clone for BoxService {
    fn clone(&self) -> Self {
        Self(self.0.clone_box())
    }
}

pub fn box_service(service: impl IntoBoxService) -> BoxService {
    service.into_box_service()
}