micro-web 0.3.0

the async micro web 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

//! HTTP header extraction implementations
//!
//! This module provides extractors for HTTP header-related information from requests,
//! including HTTP methods, header maps and raw request headers. These extractors allow
//! handlers to directly access header information in a type-safe way.
//!
//! The extractors support both owned and borrowed access to the header data:
//! - Owned extractors like `Method` and `HeaderMap` take ownership of the data
//! - Borrowed extractors like `&Method` and `&HeaderMap` provide reference access
//!
//! # Examples
//!
//! ```no_run
//! use http::{HeaderMap, Method};
//!
//! // Access HTTP method
//! async fn handle_method(method: Method) {
//!     match method {
//!         Method::GET => println!("Handling GET request"),
//!         Method::POST => println!("Handling POST request"),
//!         _ => println!("Handling other request method")
//!     }
//! }
//!
//! // Access headers
//! async fn handle_headers(headers: &HeaderMap) {
//!     if let Some(content_type) = headers.get("content-type") {
//!         println!("Content-Type: {:?}", content_type);
//!     }
//! }
//! ```

use crate::RequestContext;
use crate::body::OptionReqBody;
use crate::extract::from_request::FromRequest;
use http::{HeaderMap, Method};
use micro_http::protocol::{ParseError, RequestHeader};

/// Extracts the HTTP method by value
///
/// This extractor takes ownership of the request method.
impl FromRequest for Method {
    type Output<'any> = Method;
    type Error = ParseError;

    async fn from_request(req: &RequestContext<'_, '_>, _body: OptionReqBody) -> Result<Self::Output<'static>, Self::Error> {
        Ok(req.method().clone())
    }
}

/// Extracts a reference to the HTTP method
///
/// This extractor borrows the request method, avoiding cloning.
impl FromRequest for &Method {
    type Output<'r> = &'r Method;
    type Error = ParseError;

    async fn from_request<'r>(req: &'r RequestContext<'_, '_>, _body: OptionReqBody) -> Result<Self::Output<'r>, Self::Error> {
        Ok(req.method())
    }
}

/// Extracts a reference to the raw request header
///
/// Provides access to the underlying HTTP request header structure.
impl FromRequest for &RequestHeader {
    type Output<'r> = &'r RequestHeader;
    type Error = ParseError;

    async fn from_request<'r>(req: &'r RequestContext<'_, '_>, _body: OptionReqBody) -> Result<Self::Output<'r>, Self::Error> {
        Ok(req.request_header())
    }
}

/// Extracts a reference to the header map
///
/// This extractor provides borrowed access to all HTTP headers.
impl FromRequest for &HeaderMap {
    type Output<'r> = &'r HeaderMap;
    type Error = ParseError;

    async fn from_request<'r>(req: &'r RequestContext<'_, '_>, _body: OptionReqBody) -> Result<Self::Output<'r>, Self::Error> {
        Ok(req.headers())
    }
}

/// Extracts the header map by value
///
/// This extractor clones and takes ownership of all HTTP headers.
impl FromRequest for HeaderMap {
    type Output<'any> = HeaderMap;
    type Error = ParseError;

    async fn from_request(req: &RequestContext<'_, '_>, _body: OptionReqBody) -> Result<Self::Output<'static>, Self::Error> {
        Ok(req.headers().clone())
    }
}