weber 0.1.1

Simple web server with VERY limited functionality
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

use std::collections::HashMap;
use crate::parser::{
    Error,
    Result,
    request::parser::RequestParser,
    response::parser::ResponseParser
};

///Enum contains parsed request or response
///
///> **Created to be able to return not only a request,
///    but also a response from a Connection::Parse_incoming**
///
///# Remark
///The methods in this enum are **VERY unoptimized**
pub enum HttpData {
    Request(RequestParser),
    Response(ResponseParser)
}

impl HttpData {
    pub fn parse(content: &[u8]) -> Result<Self> {
        if let Ok(parsed) = RequestParser::parse(content) {
            Ok( HttpData::Request(parsed) )
        } else if let Ok(parsed) = ResponseParser::parse(content) {
            Ok( HttpData::Response(parsed) )
        } else {
            Err(Error::InvalidFormat)
        }
    }

    pub fn headers(&self) -> &HashMap<String, Vec<u8>> {
        match &self {
            HttpData::Request(parsed) => &parsed.headers,
            HttpData::Response(parsed) => &parsed.headers
        }
    }

    pub fn content(&self) -> Option<&Vec<u8>> {
        match &self {
            HttpData::Request(parsed) => parsed.content.as_ref(),
            HttpData::Response(parsed) => parsed.content.as_ref()
        }
    }

    pub fn version(&self) -> u8 {
        match &self {
            HttpData::Request(parsed) => parsed.version,
            HttpData::Response(parsed) => parsed.version
        }
    }

    ///*Consumes* a structure and if it is a **request** returns the result of the parser, if not - ***panic!***
    ///
    ///# Example
    ///```
    ///use weber::{
    ///    net::HttpData,
    ///    parser::{
    ///        Builder,
    ///        request::RequestBuilder
    ///    }
    ///};
    ///
    ///let parsed = HttpData::parse(&RequestBuilder::new().build());
    ///let parsed = parsed.unwrap().as_request();
    ///```
    pub fn as_request(self) -> RequestParser {
        match self {
            Self::Request(parsed) => parsed,
            _ => panic!("This is not a request")
        }
    }

    ///*Consumes* a structure and if it is a **response** returns the result of the parser, if not - ***panic!***
    ///
    ///# Example
    ///```
    ///use weber::{
    ///    net::HttpData,
    ///    parser::{
    ///        Builder,
    ///        response::ResponseBuilder
    ///    }
    ///};
    ///
    ///let parsed = HttpData::parse(&ResponseBuilder::new().build());
    ///let parsed = parsed.unwrap().as_response();
    ///```
    pub fn as_response(self) -> ResponseParser {
        match self {
            Self::Response(parsed) => parsed,
            _ => panic!("This is not a response")
        }
    }

    pub(crate) fn set_content(&mut self, content: Option<Vec<u8>>) {
        match self {
            HttpData::Request(parsed) => parsed.content = content,
            HttpData::Response(parsed) => parsed.content = content
        }
    }
}