Struct AnyMiddleware 

pub struct AnyMiddleware(/* private fields */);

Type-erased middleware that can hold any middleware implementation behind a trait object.

AnyMiddleware provides dynamic dispatch for middleware, allowing you to store different middleware types in the same collection or pass them around without knowing their concrete types at compile time. This is particularly useful for:

• Building flexible middleware chains with different middleware types
• Plugin systems where middleware is loaded dynamically
• Configuration-driven middleware stacks
• Storing middleware in collections or registries

Performance Considerations

Using AnyMiddleware involves dynamic dispatch and heap allocation, which has a small performance overhead compared to using concrete types directly. However, this overhead is typically negligible in HTTP server contexts where network I/O dominates performance characteristics.

Examples

Storing Mixed Middleware Types

use http_kit::{Request, Response, Result, Middleware, Endpoint, middleware::AnyMiddleware};

struct LoggingMiddleware;
impl Middleware for LoggingMiddleware {
    async fn handle(&self, request: &mut Request, next: impl Endpoint) -> Result<Response> {
        println!("Request: {}", request.uri());
        next.respond(request).await
    }
}

struct TimingMiddleware;
impl Middleware for TimingMiddleware {
    async fn handle(&self, request: &mut Request, next: impl Endpoint) -> Result<Response> {
        let start = std::time::Instant::now();
        let response = next.respond(request).await;
        println!("Duration: {:?}", start.elapsed());
        response
    }
}

// Store different middleware types in a collection
let middleware_stack: Vec<AnyMiddleware> = vec![
    AnyMiddleware::new(LoggingMiddleware),
    AnyMiddleware::new(TimingMiddleware),
];

Dynamic Middleware Configuration

use http_kit::{Request, Response, Result, Middleware, Endpoint, middleware::AnyMiddleware};

fn create_middleware(name: &str) -> Option<AnyMiddleware> {
    match name {
        "logging" => Some(AnyMiddleware::new(LoggingMiddleware)),
        "timing" => Some(AnyMiddleware::new(TimingMiddleware)),
        _ => None,
    }
}

Implementations

impl AnyMiddleware

pub fn new(middleware: impl Middleware + 'static) -> Self

Creates a new type-erased middleware wrapper around the given middleware implementation.

This method takes any type that implements Middleware and wraps it in an AnyMiddleware that can be stored alongside other middleware of different types. The original middleware type information is erased, but the functionality is preserved.

Arguments

• middleware - Any middleware implementation

Examples

use http_kit::{Request, Response, Result, Middleware, Endpoint, middleware::AnyMiddleware};

struct CustomMiddleware {
    prefix: String,
}

impl Middleware for CustomMiddleware {
    async fn handle(&self, request: &mut Request, next: impl Endpoint) -> Result<Response> {
        println!("{}: Processing {}", self.prefix, request.uri());
        next.respond(request).await
    }
}

let middleware = CustomMiddleware { prefix: "API".to_string() };
let any_middleware = AnyMiddleware::new(middleware);

pub fn name(&self) -> &'static str

Returns the type name of the underlying middleware implementation.

This method provides introspection capabilities for debugging, logging, or monitoring purposes. The returned string is the fully qualified type name of the original middleware type.

Examples

use http_kit::{Request, Response, Result, Middleware, Endpoint, middleware::AnyMiddleware};

struct MyMiddleware;
impl Middleware for MyMiddleware {
    async fn handle(&self, request: &mut Request, next: impl Endpoint) -> Result<Response> {
        next.respond(request).await
    }
}

let any_middleware = AnyMiddleware::new(MyMiddleware);
println!("Middleware type: {}", any_middleware.name());
// Output: Middleware type: my_crate::MyMiddleware

Trait Implementations

impl Debug for AnyMiddleware

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

Formats the value using the given formatter.

impl Middleware for AnyMiddleware

async fn handle( &mut self, request: &mut Request, next: impl Endpoint, ) -> Result<Response>

Processes a request through the middleware chain.