salvo_cache/
skipper.rs

1use std::collections::HashSet;
2
3use salvo_core::handler::Skipper;
4use salvo_core::http::Method;
5use salvo_core::{Depot, Request};
6
7/// Skipper for `Method`. You can use it to skip some methods.
8///
9/// If the request method is in the skip list, the request will be skipped.
10#[derive(Default, Clone, Debug)]
11pub struct MethodSkipper {
12    skipped_methods: HashSet<Method>,
13}
14impl MethodSkipper {
15    /// Create a new `MethodSkipper`.
16    #[must_use]
17    pub fn new() -> Self {
18        Self {
19            skipped_methods: HashSet::new(),
20        }
21    }
22    /// Add the [`Method::GET`] method to skipped methods.
23    #[must_use]
24    pub fn skip_get(self, value: bool) -> Self {
25        self.skip_method(Method::GET, value)
26    }
27    /// Add the [`Method::POST`] method to skipped methods.
28    #[must_use]
29    pub fn skip_post(self, value: bool) -> Self {
30        self.skip_method(Method::POST, value)
31    }
32    /// Add the [`Method::PUT`] method to skipped methods.
33    #[must_use]
34    pub fn skip_put(self, value: bool) -> Self {
35        self.skip_method(Method::PUT, value)
36    }
37    /// Add the [`Method::DELETE`] method to skipped methods.
38    #[must_use]
39    pub fn skip_delete(self, value: bool) -> Self {
40        self.skip_method(Method::DELETE, value)
41    }
42    /// Add the [`Method::HEAD`] method to skipped methods.
43    #[must_use]
44    pub fn skip_head(self, value: bool) -> Self {
45        self.skip_method(Method::HEAD, value)
46    }
47    /// Add the [`Method::PATCH`] method to skipped methods.
48    #[must_use]
49    pub fn skip_patch(self, value: bool) -> Self {
50        self.skip_method(Method::PATCH, value)
51    }
52    /// Add the [`Method::OPTIONS`] method to skipped methods.
53    #[must_use]
54    pub fn skip_options(self, value: bool) -> Self {
55        self.skip_method(Method::OPTIONS, value)
56    }
57    /// Add the [`Method::CONNECT`] method to skipped methods.
58    #[must_use]
59    pub fn skip_connect(self, value: bool) -> Self {
60        self.skip_method(Method::CONNECT, value)
61    }
62    /// Add the [`Method::TRACE`] method to skipped methods.
63    #[must_use]
64    pub fn skip_trace(self, value: bool) -> Self {
65        self.skip_method(Method::TRACE, value)
66    }
67    /// Add a [`Method`] to skipped methods.
68    #[must_use]
69    pub fn skip_method(mut self, method: Method, value: bool) -> Self {
70        if value {
71            self.skipped_methods.insert(method);
72        } else {
73            self.skipped_methods.remove(&method);
74        }
75        self
76    }
77    /// Add all methods to skipped methods.
78    #[must_use]
79    pub fn skip_all(mut self) -> Self {
80        self.skipped_methods = [
81            Method::GET,
82            Method::POST,
83            Method::PUT,
84            Method::DELETE,
85            Method::HEAD,
86            Method::PATCH,
87            Method::OPTIONS,
88            Method::CONNECT,
89            Method::TRACE,
90        ]
91        .into_iter()
92        .collect();
93        self
94    }
95}
96impl Skipper for MethodSkipper {
97    fn skipped(&self, req: &mut Request, _depot: &Depot) -> bool {
98        self.skipped_methods.contains(req.method())
99    }
100}