water_http 4.0.1

fast web http framework that support http 1 and http 2 with very easy use
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

use std::fmt::{Display};
// use bytes::{BytesMut};
use  water_buffer::WaterBuffer as BM; type BytesMut = BM<u8>;
use crate::http::status_code::HttpStatusCode as StatusCode;



/// for writing http response format bytes to given buffer
pub struct HttpResponseBufferWriter<'a> {
    /// writable given buffer
    write_able_buffer:&'a mut BytesMut
}




 impl<'a> HttpResponseBufferWriter<'a> {
     /// for creating ok response with 200 status code
     #[inline]
     pub  fn success(buffer:&'a mut BytesMut)->HttpResponseBufferWriter<'a>{
         Self::with_version_and_status(buffer,StatusCode::OK)
     }

     /// for initiating new [HttpResponseBufferWriter] struct
     pub fn new(buffer:&'a mut BytesMut)->HttpResponseBufferWriter<'a>{
         HttpResponseBufferWriter{
             write_able_buffer:buffer
         }
     }

     /// for creating ok response with 200 status code
     #[inline]
     pub fn with_version_and_status(buffer:&'a mut BytesMut,status:StatusCode)->HttpResponseBufferWriter<'a>{
         buffer.extend_from_slice(format!("HTTP/1.1 {} {}\r\n",
          status.status,
          status.label
         ).as_bytes());
         HttpResponseBufferWriter {
             write_able_buffer:buffer
         }
     }
     
     /// for setting header key and value pair to response
     #[inline]
     pub fn set_header_pair(&mut self,key:impl Display,value:impl Display){
         self.write_able_buffer.extend_from_slice(
             format!("{key}: {value}\r\n")
                 .as_bytes()
         );
     }
     
     /// setting data to the response
     #[inline]
     pub fn send_data_with_content_length(&mut self,data:ResponseData<'a>){
         let data = data.as_bytes();
         self.write_able_buffer.extend_from_slice(format!("Content-Length: {}\r\n\r\n",data.len()).as_bytes());
         self.write_able_buffer.extend_from_slice(data);
     }

     /// setting custom data to the response buffer without counting content-length
     /// so that means that you need to count content-length and write it to headers manually
     #[inline]
     pub fn send_data(&mut self,data:ResponseData<'a>){
         let data = data.as_bytes();
         self.write_able_buffer.extend_from_slice(data);
     }
 }

 /// for specifying response data
 pub enum ResponseData<'a> {
     Str(&'static str),
     Slice(&'a [u8]),
     String(String),
 }

impl<'a> ResponseData<'a> {

    pub  fn as_bytes(&'a self)->&'a[u8]{
        match self {
            ResponseData::Str(s) => {s.as_bytes()}
            ResponseData::Slice(s) => {*s}
            ResponseData::String(s) => {s.as_bytes()}
        }
    }
}
unsafe impl<'a>  Send for ResponseData<'a> {

}
#[cfg(test)]
mod test_buffer {
    // use bytes::BytesMut;
    use  water_buffer::WaterBuffer as BM; type BytesMut = BM<u8>;
    use crate::http::status_code::HttpStatusCode as StatusCode;
    use crate::http::HttpVersion;

    #[test]
    pub fn buffer_writing_speed(){
        let status = StatusCode::OK;
        let version = HttpVersion::Http1_1.to_str();


        let v1 = std::time::SystemTime::now();
        let mut buffer =BytesMut::with_capacity(4048);
        buffer.extend_from_slice(version.as_bytes());
        buffer.extend_from_slice(b" ");
        let (code,la) = status.to_bytes();
        buffer.extend_from_slice(format!("{}",code).as_bytes());
        buffer.extend_from_slice(b" ");
        buffer.extend_from_slice(la);
        buffer.extend_from_slice(b"\r\n");
        let v2 = std::time::SystemTime::now();
        let dif = v1.duration_since(v2);
        println!("difference with each writing mod {:?}",dif);

        let v1 = std::time::SystemTime::now();
        let mut buffer =BytesMut::with_capacity(4048);
        buffer.extend_from_slice(
            format!("{} {} {}\r\n",version,status.status,status.label).as_bytes()
        );
        let v2 = std::time::SystemTime::now();
        let dif = v1.duration_since(v2);
        println!("difference with each format mod {:?}",dif);
    }
}