oxidized 0.1.0

A hyper-performant, modular, and asynchronous web framework for Rust, built on hyper and tokio. Featuring a Tower-inspired, Service-based architecture for maximum performance and composability.
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

pub mod logger;

pub use self::logger::LogLayer;
use crate::service::Service;
use std::sync::Arc;

pub trait Layer<S> {
    type Service;

    fn layer(&self, inner: S) -> Self::Service;
}

#[derive(Clone)]
pub struct Stack<L, S> {
    layer: L,
    service: S,
}

impl<L, S> Stack<L, S> {
    pub fn new(layer: L, service: S) -> Self {
        Self { layer, service }
    }
}

impl<L, S, Req> Service<Req> for Stack<L, S>
where
    L: Layer<S>,
    S: Clone,
    L::Service: Service<Req>,
{
    type Response = <L::Service as Service<Req>>::Response;
    type Error = <L::Service as Service<Req>>::Error;
    type Future = <L::Service as Service<Req>>::Future;

    fn call(&self, req: Req) -> Self::Future {
        let s = self.layer.layer(self.service.clone());
        s.call(req)
    }
}

#[derive(Clone)]
pub struct ArcLayer<S>(Arc<S>);

impl<S> ArcLayer<S> {
    pub fn new(service: S) -> Self {
        Self(Arc::new(service))
    }
}

impl<S> Layer<S> for ArcLayer<S>
where
    S: Service<crate::Request>,
{
    type Service = Arc<S>;

    fn layer(&self, _inner: S) -> Self::Service {
        self.0.clone()
    }
}