siwi 0.0.1

A minimal Rust web application framework
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use crate::{Error, Response, Result};
use bytes::{Bytes, BytesMut};
use http_body_util::Full;
use hyper::header;
use std::borrow::Cow;
pub trait IntoResponse {
  fn into_response(self) -> Result;
}

impl IntoResponse for Full<Bytes> {
  fn into_response(self) -> Result {
    let response = hyper::http::Response::builder().body(self)?.into();
    Ok(response)
  }
}

impl IntoResponse for &'static str {
  fn into_response(self) -> Result {
    Cow::Borrowed(self).into_response()
  }
}

impl IntoResponse for String {
  fn into_response(self) -> Result {
    Cow::<'static, str>::Owned(self).into_response()
  }
}

impl IntoResponse for Cow<'static, str> {
  fn into_response(self) -> Result {
    let mut res = Full::from(self).into_response()?;
    res.inner.headers_mut().insert(
      header::CONTENT_TYPE,
      header::HeaderValue::from_static(mime::TEXT_PLAIN_UTF_8.as_ref()),
    );
    Ok(res)
  }
}

impl<T, E> IntoResponse for std::result::Result<T, E>
where
  T: IntoResponse,
  E: IntoResponse,
{
  fn into_response(self) -> Result {
    match self {
      Ok(response) => response.into_response(),
      Err(err) => err.into_response(),
    }
  }
}

impl IntoResponse for Error {
  fn into_response(self) -> Result {
    let val = self.to_string();
    Response::with_status(500, val)
  }
}

impl IntoResponse for () {
  fn into_response(self) -> Result {
    let response = hyper::http::Response::builder()
      .body(Full::new(Bytes::default()))?
      .into();
    Ok(response)
  }
}

impl IntoResponse for Response {
  fn into_response(self) -> Result {
    Ok(self)
  }
}

impl IntoResponse for (hyper::StatusCode, String) {
  fn into_response(self) -> Result {
    let response = hyper::http::Response::builder()
      .header(header::CONTENT_TYPE, mime::TEXT_PLAIN_UTF_8.to_string())
      .status(self.0)
      .body(Full::new(Bytes::from(self.1)))?
      .into();
    Ok(response)
  }
}

impl IntoResponse for (hyper::StatusCode, &'static str) {
  fn into_response(self) -> Result {
    let response = hyper::http::Response::builder()
      .header(header::CONTENT_TYPE, mime::TEXT_PLAIN_UTF_8.to_string())
      .status(self.0)
      .body(Full::new(Bytes::from(self.1)))?
      .into();
    Ok(response)
  }
}

impl IntoResponse for (u16, String) {
  fn into_response(self) -> Result {
    let response = hyper::http::Response::builder()
      .header(header::CONTENT_TYPE, mime::TEXT_PLAIN_UTF_8.to_string())
      .status(hyper::StatusCode::from_u16(self.0)?)
      .body(Full::new(Bytes::from(self.1)))?
      .into();
    Ok(response)
  }
}

impl IntoResponse for (u16, &'static str) {
  fn into_response(self) -> Result {
    let response = hyper::http::Response::builder()
      .header(header::CONTENT_TYPE, mime::TEXT_PLAIN_UTF_8.to_string())
      .status(hyper::StatusCode::from_u16(self.0)?)
      .body(Full::new(Bytes::from(self.1)))?
      .into();
    Ok(response)
  }
}

impl IntoResponse for Bytes {
  fn into_response(self) -> Result {
    let mut res = Full::from(self).into_response()?;
    res.inner.headers_mut().insert(
      header::CONTENT_TYPE,
      header::HeaderValue::from_static(mime::APPLICATION_OCTET_STREAM.as_ref()),
    );
    Ok(res)
  }
}

impl IntoResponse for BytesMut {
  fn into_response(self) -> Result {
    self.freeze().into_response()
  }
}