radixtree 0.1.1

A radix trie implementation for router, and provides CRUD operations.
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

use self::Inner::*;

/// The Request Method
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Method(Inner);

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
enum Inner {
    Get,
    Post,
    Head,
    Put,
    Patch,
    Delete,
    Options,
    Connect,
    Trace,
}

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

    /// POST
    pub const POST: Method = Method(Post);

    /// HEAD
    pub const HEAD: Method = Method(Head);

    /// PUT
    pub const PUT: Method = Method(Put);

    /// PATCH
    pub const PATCH: Method = Method(Patch);

    /// DELETE
    pub const DELETE: Method = Method(Delete);

    /// OPTIONS
    pub const OPTIONS: Method = Method(Options);

    /// CONNECT
    pub const CONNECT: Method = Method(Connect);

    /// TRACE
    pub const TRACE: Method = Method(Trace);

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

impl AsRef<str> for Method {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

impl From<&str> for Method {
    fn from(s: &str) -> Self {
        match s.to_uppercase().as_str() {
            "GET" => Method::GET,
            "POST" => Method::POST,
            "HEAD" => Method::HEAD,
            "PUT" => Method::PUT,
            "PATCH" => Method::PATCH,
            "DELETE" => Method::DELETE,
            "OPTIONS" => Method::OPTIONS,
            "CONNECT" => Method::CONNECT,
            "TRACE" => Method::TRACE,
            _ => Method::default(),
        }
    }
}

impl Default for Method {
    fn default() -> Self {
        Method::GET
    }
}