Struct Method 

pub struct Method<P> { /* private fields */ }

A predicate that matches requests by HTTP method.

Type Parameters

• P - The inner predicate to chain with. Use Method::new to start a new predicate chain (uses Neutral internally), or use the MethodPredicate extension trait to chain onto an existing predicate.

Examples

Match only GET requests:

use hitbox_http::predicates::request::Method;

let predicate = Method::new(http::Method::GET).unwrap();

Match GET or HEAD requests (using the builder pattern):

use hitbox::Neutral;
use hitbox_http::predicates::request::Method;

let predicate = Method::new_in(
    Neutral::new(),
    vec![http::Method::GET, http::Method::HEAD],
);

Implementations

impl<S> Method<Neutral<S>>

pub fn new<E, T>(method: T) -> Result<Self, E>

where T: TryInto<Method, Error = E>,

Creates a predicate matching requests with the specified HTTP method.

Returns Cacheable when the request method matches, NonCacheable otherwise.

Errors

Returns an error if method cannot be converted to http::Method. When passing http::Method directly, this is infallible. When passing a string, returns http::method::InvalidMethod if the string is not a valid HTTP method.

impl<P> Method<P>

pub fn new_in(inner: P, methods: Vec<Method>) -> Self

Creates a predicate matching requests with any of the specified HTTP methods.

Returns Cacheable when the request method is in the provided list, NonCacheable otherwise.

Use this for caching strategies that apply to multiple methods (e.g., GET and HEAD).

Trait Implementations

impl<P: Debug> Debug for Method<P>

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

Formats the value using the given formatter.

impl<P, ReqBody> Predicate for Method<P>

where P: Predicate<Subject = CacheableHttpRequest<ReqBody>> + Send + Sync, ReqBody: Body + Send + 'static, ReqBody::Error: Send,

type Subject = <P as Predicate>::Subject

The type being evaluated by this predicate.

fn check<'life0, 'async_trait>( &'life0 self, request: Self::Subject, ) -> Pin<Box<dyn Future<Output = PredicateResult<Self::Subject>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Evaluate whether the subject should be cached.