Struct ErrorRouter

pub struct ErrorRouter { /* private fields */ }

Implementations

impl ErrorRouter

pub fn new() -> Self

Examples found in repository

examples/basic.rs (line 14)

fn main() {
    let handler = |_: &mut Request| {
        Ok(Response::with((status::NotFound)))
    };

    let mut chain = Chain::new(handler);
    chain.link_after({
        let mut error_router = iron_error_router::ErrorRouter::new();

        // In case the response is a 404, replace the response with your own.

        error_router.handle_status(status::NotFound, |_: &mut Request| {
            Ok(Response::with((
                status::NotFound,
                "Content not found."
            )))
        });

        // Instead of writing a handler, you can just use a modifier:

        error_router.modifier_for_status(
            status::NotFound,
            (status::NotFound, "Content not found.")
        );

        // Or an AfterMiddleware:

        error_router.after_status(status::NotFound, |_: &mut Request, _: Response| {
            Ok(Response::with((status::NotFound, "Content not found.")))
        });

        error_router
    });

    Iron::new(chain).http("localhost:3000").unwrap();
}

pub fn handle_status<T: Handler>(&mut self, status: Status, handler: T)

Examples found in repository

examples/basic.rs (lines 18-23)

fn main() {
    let handler = |_: &mut Request| {
        Ok(Response::with((status::NotFound)))
    };

    let mut chain = Chain::new(handler);
    chain.link_after({
        let mut error_router = iron_error_router::ErrorRouter::new();

        // In case the response is a 404, replace the response with your own.

        error_router.handle_status(status::NotFound, |_: &mut Request| {
            Ok(Response::with((
                status::NotFound,
                "Content not found."
            )))
        });

        // Instead of writing a handler, you can just use a modifier:

        error_router.modifier_for_status(
            status::NotFound,
            (status::NotFound, "Content not found.")
        );

        // Or an AfterMiddleware:

        error_router.after_status(status::NotFound, |_: &mut Request, _: Response| {
            Ok(Response::with((status::NotFound, "Content not found.")))
        });

        error_router
    });

    Iron::new(chain).http("localhost:3000").unwrap();
}

pub fn after_status<T: AfterMiddleware>( &mut self, status: Status, middleware: T, )

Examples found in repository

examples/basic.rs (lines 34-36)

fn main() {
    let handler = |_: &mut Request| {
        Ok(Response::with((status::NotFound)))
    };

    let mut chain = Chain::new(handler);
    chain.link_after({
        let mut error_router = iron_error_router::ErrorRouter::new();

        // In case the response is a 404, replace the response with your own.

        error_router.handle_status(status::NotFound, |_: &mut Request| {
            Ok(Response::with((
                status::NotFound,
                "Content not found."
            )))
        });

        // Instead of writing a handler, you can just use a modifier:

        error_router.modifier_for_status(
            status::NotFound,
            (status::NotFound, "Content not found.")
        );

        // Or an AfterMiddleware:

        error_router.after_status(status::NotFound, |_: &mut Request, _: Response| {
            Ok(Response::with((status::NotFound, "Content not found.")))
        });

        error_router
    });

    Iron::new(chain).http("localhost:3000").unwrap();
}

pub fn modifier_for_status<T: Modifier<Response> + Send + Sync + Clone + 'static>( &mut self, status: Status, modifier: T, )

Examples found in repository

examples/basic.rs (lines 27-30)

fn main() {
    let handler = |_: &mut Request| {
        Ok(Response::with((status::NotFound)))
    };

    let mut chain = Chain::new(handler);
    chain.link_after({
        let mut error_router = iron_error_router::ErrorRouter::new();

        // In case the response is a 404, replace the response with your own.

        error_router.handle_status(status::NotFound, |_: &mut Request| {
            Ok(Response::with((
                status::NotFound,
                "Content not found."
            )))
        });

        // Instead of writing a handler, you can just use a modifier:

        error_router.modifier_for_status(
            status::NotFound,
            (status::NotFound, "Content not found.")
        );

        // Or an AfterMiddleware:

        error_router.after_status(status::NotFound, |_: &mut Request, _: Response| {
            Ok(Response::with((status::NotFound, "Content not found.")))
        });

        error_router
    });

    Iron::new(chain).http("localhost:3000").unwrap();
}

Trait Implementations

impl AfterMiddleware for ErrorRouter

fn after( &self, req: &mut Request<'_, '_>, res: Response, ) -> IronResult<Response>

Do whatever post-processing this middleware should do.

fn catch( &self, req: &mut Request<'_, '_>, err: IronError, ) -> IronResult<Response>

Respond to an error thrown by previous AfterMiddleware, the Handler, or a BeforeMiddleware.

impl Default for ErrorRouter

fn default() -> ErrorRouter

Returns the “default value” for a type.