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

use http::Response as HttpResponse;
use http_body_util::Full;
use hyper::body::Bytes;
use hyper::header::HeaderValue;
use hyper::StatusCode;

pub struct Response {
    inner: HttpResponse<Full<Bytes>>,
}

impl Response {
    pub fn new<T: Into<Bytes>>(body: T) -> Self {
        Self {
            inner: HttpResponse::new(Full::new(body.into())),
        }
    }

    pub fn status(mut self, status: StatusCode) -> Self {
        *self.inner.status_mut() = status;
        self
    }

    pub fn header(mut self, key: &'static str, value: &'static str) -> Self {
        self.inner
            .headers_mut()
            .insert(key, HeaderValue::from_static(value));
        self
    }

    pub fn into_hyper(self) -> HttpResponse<Full<Bytes>> {
        self.inner
    }

    pub(crate) fn inner_mut(&mut self) -> &mut HttpResponse<Full<Bytes>> {
        &mut self.inner
    }
}

impl From<&'static str> for Response {
    fn from(body: &'static str) -> Self {
        Response::new(body)
    }
}

impl From<String> for Response {
    fn from(body: String) -> Self {
        Response::new(body)
    }
}

impl From<Bytes> for Response {
    fn from(body: Bytes) -> Self {
        Response::new(body)
    }
}