Struct tower_http::classify::SharedClassifier

pub struct SharedClassifier<C> { /* private fields */ }

A MakeClassifier that produces new classifiers by cloning an inner classifier.

When a type implementing ClassifyResponse doesn’t depend on information from the request, SharedClassifier can be used to turn an instance of that type into a MakeClassifier.

Example

use std::fmt;
use tower_http::classify::{
    ClassifyResponse, ClassifiedResponse, NeverClassifyEos,
    SharedClassifier, MakeClassifier,
};
use http::Response;

// A response classifier that only considers errors to be failures.
#[derive(Clone, Copy)]
struct MyClassifier;

impl ClassifyResponse for MyClassifier {
    type FailureClass = String;
    type ClassifyEos = NeverClassifyEos<Self::FailureClass>;

    fn classify_response<B>(
        self,
        _res: &Response<B>,
    ) -> ClassifiedResponse<Self::FailureClass, Self::ClassifyEos> {
        ClassifiedResponse::Ready(Ok(()))
    }

    fn classify_error<E>(self, error: &E) -> Self::FailureClass
    where
        E: fmt::Display + 'static,
    {
        error.to_string()
    }
}

// Some function that requires a `MakeClassifier`
fn use_make_classifier<M: MakeClassifier>(make: M) {
    // ...
}

// `MyClassifier` doesn't implement `MakeClassifier` but since it doesn't
// care about the incoming request we can make `MyClassifier`s by cloning.
// That is what `SharedClassifier` does.
let make_classifier = SharedClassifier::new(MyClassifier);

// We now have a `MakeClassifier`!
use_make_classifier(make_classifier);

Implementations

impl<C> SharedClassifier<C>

pub fn new(classifier: C) -> Self where
    C: ClassifyResponse + Clone, 

Create a new SharedClassifier from the given classifier.

Trait Implementations

impl<C: Clone> Clone for SharedClassifier<C>

fn clone(&self) -> SharedClassifier<C>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<C: Debug> Debug for SharedClassifier<C>

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

Formats the value using the given formatter.

impl<C> MakeClassifier for SharedClassifier<C> where
    C: ClassifyResponse + Clone, 

type FailureClass = C::FailureClass

The type of failure classifications.

type ClassifyEos = C::ClassifyEos

The type used to classify the response end of stream (EOS).

type Classifier = C

The response classifier produced.

fn make_classifier<B>(&self, _req: &Request<B>) -> Self::Classifier

Returns a response classifier for this request