via 2.0.0-gm.12

An async multi-threaded web framework for people who appreciate simplicity.
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

mod body;
mod builder;
mod redirect;

#[cfg(feature = "file")]
mod file;

pub use body::{Json, ResponseBody};
pub use builder::{Finalize, ResponseBuilder};
pub use redirect::Redirect;

#[cfg(feature = "file")]
pub use file::File;

use bytes::Bytes;
use cookie::CookieJar;
use http::{Extensions, HeaderMap, StatusCode, Version};
use http_body::Body;
use http_body_util::combinators::BoxBody;
use std::fmt::{self, Debug, Formatter};

use crate::error::BoxError;

pub struct Response {
    http: http::Response<ResponseBody>,
    cookies: CookieJar,
}

impl Response {
    #[inline]
    pub fn build() -> ResponseBuilder {
        Default::default()
    }

    #[inline]
    pub fn new(body: ResponseBody) -> Self {
        Self {
            cookies: CookieJar::new(),
            http: http::Response::new(body),
        }
    }

    /// Consumes the response returning a new response with body mapped to the
    /// return type of the provided closure.
    ///
    #[inline]
    pub fn map<U, F>(self, map: F) -> Self
    where
        F: FnOnce(ResponseBody) -> U,
        U: Body<Data = Bytes, Error = BoxError> + Send + Sync + 'static,
    {
        Self {
            cookies: self.cookies,
            http: self.http.map(|body| BoxBody::new(map(body)).into()),
        }
    }

    #[inline]
    pub fn status(&self) -> StatusCode {
        self.http.status()
    }

    #[inline]
    pub fn status_mut(&mut self) -> &mut StatusCode {
        self.http.status_mut()
    }

    #[inline]
    pub fn version(&self) -> Version {
        self.http.version()
    }

    #[inline]
    pub fn headers(&self) -> &HeaderMap {
        self.http.headers()
    }

    #[inline]
    pub fn headers_mut(&mut self) -> &mut HeaderMap {
        self.http.headers_mut()
    }

    /// Returns a reference to the response cookies.
    ///
    #[inline]
    pub fn cookies(&self) -> &CookieJar {
        &self.cookies
    }

    /// Returns a mutable reference to the response cookies.
    ///
    #[inline]
    pub fn cookies_mut(&mut self) -> &mut CookieJar {
        &mut self.cookies
    }

    #[inline]
    pub fn extensions(&self) -> &Extensions {
        self.http.extensions()
    }

    #[inline]
    pub fn extensions_mut(&mut self) -> &mut Extensions {
        self.http.extensions_mut()
    }

    #[inline]
    pub fn body(&self) -> &ResponseBody {
        self.http.body()
    }
}

impl Debug for Response {
    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
        f.debug_struct("Response")
            .field("version", &self.version())
            .field("status", &self.status())
            .field("headers", self.headers())
            .field("cookies", &self.cookies)
            .field("body", self.http.body())
            .finish()
    }
}

impl From<Response> for http::Response<ResponseBody> {
    #[inline]
    fn from(response: Response) -> Self {
        response.http
    }
}

impl From<http::Response<ResponseBody>> for Response {
    #[inline]
    fn from(http: http::Response<ResponseBody>) -> Self {
        Self {
            cookies: CookieJar::new(),
            http,
        }
    }
}