[go: up one dir, main page]

rocket 0.1.3

Web framework for nightly with a focus on ease-of-use, expressability, and speed.
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

use std::fmt;
use std::str::FromStr;

use error::Error;
use http::hyper;
use self::Method::*;

// TODO: Support non-standard methods, here and in codegen.

/// Representation of HTTP methods.
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
pub enum Method {
    Get,
    Put,
    Post,
    Delete,
    Options,
    Head,
    Trace,
    Connect,
    Patch
}

impl Method {
    #[doc(hidden)]
    pub fn from_hyp(method: &hyper::Method) -> Option<Method> {
        match *method {
            hyper::Method::Get => Some(Get),
            hyper::Method::Put => Some(Put),
            hyper::Method::Post => Some(Post),
            hyper::Method::Delete => Some(Delete),
            hyper::Method::Options => Some(Options),
            hyper::Method::Head => Some(Head),
            hyper::Method::Trace => Some(Trace),
            hyper::Method::Connect => Some(Connect),
            hyper::Method::Patch => Some(Patch),
            hyper::Method::Extension(_) => None,
        }
    }

    #[doc(hidden)]
    #[inline(always)]
    pub fn to_hyp(&self) -> hyper::Method {
        self.to_string().as_str().parse().unwrap()
    }

    /// Whether an HTTP request with the given method supports a payload.
    pub fn supports_payload(&self) -> bool {
        match *self {
            Put | Post | Delete | Patch => true,
            Get | Head | Connect | Trace | Options => false,
        }
    }
}

impl FromStr for Method {
    type Err = Error;

    fn from_str(s: &str) -> Result<Method, Error> {
        match s {
            "GET" | "get" => Ok(Get),
            "PUT" | "put" => Ok(Put),
            "POST" | "post" => Ok(Post),
            "DELETE" | "delete" => Ok(Delete),
            "OPTIONS" | "options" => Ok(Options),
            "HEAD" | "head" => Ok(Head),
            "TRACE" | "trace" => Ok(Trace),
            "CONNECT" | "connect" => Ok(Connect),
            "PATCH" | "patch" => Ok(Patch),
            _ => Err(Error::BadMethod),
        }
    }
}

impl fmt::Display for Method {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.write_str(match *self {
            Get => "GET",
            Put => "PUT",
            Post => "POST",
            Delete => "DELETE",
            Options => "OPTIONS",
            Head => "HEAD",
            Trace => "TRACE",
            Connect => "CONNECT",
            Patch => "PATCH",
        })
    }
}