FilesExpand file tree

master

/

method.rs

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

69 lines (63 loc) · 1.88 KB

master

/

method.rs

Copy path

Top

File metadata and controls

• Code
• Blame

69 lines (63 loc) · 1.88 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

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

//! HTTP request methods.

use std::fmt;

/// An HTTP request method.

///

/// Common methods are represented as dedicated variants; anything else is kept

/// verbatim in [`Method::Other`] so the engine never rejects a request purely

/// because the method is unusual.

#[derive(Debug, Clone, PartialEq, Eq)]

#[allow(missing_docs)] // the variant names are the canonical method tokens

pub enum Method {

Get,

Head,

Post,

Put,

Delete,

Connect,

Options,

Trace,

Patch,

/// Any other (still syntactically valid) method token.

Other(String),

}

impl Method {

/// Parse a method token from the request line.

pub fn parse(token: &str) -> Method {

match token {

"GET" => Method::Get,

"HEAD" => Method::Head,

"POST" => Method::Post,

"PUT" => Method::Put,

"DELETE" => Method::Delete,

"CONNECT" => Method::Connect,

"OPTIONS" => Method::Options,

"TRACE" => Method::Trace,

"PATCH" => Method::Patch,

other => Method::Other(other.to_owned()),

}

}

/// The canonical uppercase token for this method.

pub fn as_str(&self) -> &str {

match self {

Method::Get => "GET",

Method::Head => "HEAD",

Method::Post => "POST",

Method::Put => "PUT",

Method::Delete => "DELETE",

Method::Connect => "CONNECT",

Method::Options => "OPTIONS",

Method::Trace => "TRACE",

Method::Patch => "PATCH",

Method::Other(s) => s,

}

}

/// Whether a response to this method must omit its body (RFC 9110 §9.3.2).

pub fn is_head(&self) -> bool {

matches!(self, Method::Head)

}

}

impl fmt::Display for Method {

fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

f.write_str(self.as_str())

}

}