xrutes 0.1.3

Routing and event handling
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

#[allow(dead_code)]
enum Inner {
    Options,
    Get,
    Post,
    Put,
    Delete,
    Head,
    Trace,
    Connect,
    Patch,
    // // If the extension is short enough, store it inline
    // ExtensionInline(InlineExtension),
    // // Otherwise, allocate it
    // ExtensionAllocated(AllocatedExtension),
}
#[allow(dead_code)]
pub struct Method(Inner);

impl Method{
        // / GET
        // pub const GET: Method = Method(Get);

//         /// POST
//         pub const POST: Method = Method(Post);
    
//         /// PUT
//         pub const PUT: Method = Method(Put);
    
//         /// DELETE
//         pub const DELETE: Method = Method(Delete);
    
//         /// HEAD
//         pub const HEAD: Method = Method(Head);
    
//         /// OPTIONS
//         pub const OPTIONS: Method = Method(Options);
    
//         /// CONNECT
//         pub const CONNECT: Method = Method(Connect);
    
//         /// PATCH
//         pub const PATCH: Method = Method(Patch);
    
//         /// TRACE
//         pub const TRACE: Method = Method(Trace);

//             /// Converts a slice of bytes to an HTTP method.
//     pub fn from_bytes(src: &[u8]) -> Result<Method, InvalidMethod> {
//         match src.len() {
//             0 => Err(InvalidMethod::new()),
//             3 => match src {
//                 b"GET" => Ok(Method(Get)),
//                 b"PUT" => Ok(Method(Put)),
//                 _ => Method::extension_inline(src),
//             },
//             4 => match src {
//                 b"POST" => Ok(Method(Post)),
//                 b"HEAD" => Ok(Method(Head)),
//                 _ => Method::extension_inline(src),
//             },
//             5 => match src {
//                 b"PATCH" => Ok(Method(Patch)),
//                 b"TRACE" => Ok(Method(Trace)),
//                 _ => Method::extension_inline(src),
//             },
//             6 => match src {
//                 b"DELETE" => Ok(Method(Delete)),
//                 _ => Method::extension_inline(src),
//             },
//             7 => match src {
//                 b"OPTIONS" => Ok(Method(Options)),
//                 b"CONNECT" => Ok(Method(Connect)),
//                 _ => Method::extension_inline(src),
//             },
//             _ => {
//                 if src.len() < InlineExtension::MAX {
//                     Method::extension_inline(src)
//                 } else {
//                     let allocated = AllocatedExtension::new(src)?;

//                     Ok(Method(ExtensionAllocated(allocated)))
//                 }
//             }
//         }
//     }
//       /// Return a &str representation of the HTTP method
//       #[inline]
//       pub fn as_str(&self) -> &str {
//           match self.0 {
//               Options => "OPTIONS",
//               Get => "GET",
//               Post => "POST",
//               Put => "PUT",
//               Delete => "DELETE",
//               Head => "HEAD",
//               Trace => "TRACE",
//               Connect => "CONNECT",
//               Patch => "PATCH",
//             //   ExtensionInline(ref inline) => inline.as_str(),
//             //   ExtensionAllocated(ref allocated) => allocated.as_str(),
//           }
//       }
    
}