Struct RootHandlerBuilder 

pub struct RootHandlerBuilder<S = RouterService, SE = DynErrorPageHandler> { /* private fields */ }

A helper struct to build the root handler for the project.

This is mainly useful for attaching middlewares to the project.

Examples

use cot::Project;
use cot::middleware::LiveReloadMiddleware;
use cot::project::{MiddlewareContext, RootHandler, RootHandlerBuilder};

struct MyProject;
impl Project for MyProject {
    fn middlewares(
        &self,
        handler: RootHandlerBuilder,
        context: &MiddlewareContext,
    ) -> RootHandler {
        handler
            .middleware(LiveReloadMiddleware::from_context(context))
            .build()
    }
}

Implementations

impl<RootService, ErrorHandlerService> RootHandlerBuilder<RootService, ErrorHandlerService>

where RootService: Service<Request, Response = Response, Error = Error> + Send + Sync + Clone + 'static, RootService::Future: Send, ErrorHandlerService: Service<Request, Response = Response, Error = Error> + Send + Sync + Clone + 'static, ErrorHandlerService::Future: Send,

pub fn middleware<M>( self, middleware: M, ) -> RootHandlerBuilder<WrappedMiddleware<M, RootService>, WrappedMiddleware<M, ErrorHandlerService>>

where M: Layer<RootService> + Layer<ErrorHandlerService>,

Adds middleware to the project.

This method is used to add middleware to the project. The middleware will be applied to all routes in the project.

Examples

use cot::Project;
use cot::middleware::LiveReloadMiddleware;
use cot::project::{MiddlewareContext, RootHandler, RootHandlerBuilder};

struct MyProject;
impl Project for MyProject {
    fn middlewares(
        &self,
        handler: RootHandlerBuilder,
        context: &MiddlewareContext,
    ) -> RootHandler {
        handler
            .middleware(LiveReloadMiddleware::from_context(context))
            .build()
    }
}

pub fn main_handler_middleware<M>( self, middleware: M, ) -> RootHandlerBuilder<WrappedMiddleware<M, RootService>, ErrorHandlerService>

where M: Layer<RootService>,

Adds middleware only to the main request handler.

This method is used to add middleware that should only be applied to the main request handler, not to the error handler. This is useful when you have middleware that should only run for successful requests, such as logging middleware that should not interfere with error handling.

Examples

use cot::Project;
use cot::middleware::LiveReloadMiddleware;
use cot::project::{MiddlewareContext, RootHandler, RootHandlerBuilder};

struct MyProject;
impl Project for MyProject {
    fn middlewares(
        &self,
        handler: RootHandlerBuilder,
        context: &MiddlewareContext,
    ) -> RootHandler {
        handler
            .main_handler_middleware(LiveReloadMiddleware::from_context(context))
            .build()
    }
}

pub fn error_handler_middleware<M>( self, middleware: M, ) -> RootHandlerBuilder<RootService, WrappedMiddleware<M, ErrorHandlerService>>

where M: Layer<ErrorHandlerService>,

Adds middleware only to the error handler.

This method is used to add middleware that should only be applied to the error handler, not to the main request handler. This is useful when you have middleware that should only run when handling errors, such as error reporting middleware or middleware that modifies error responses.

Examples

use cot::Project;
use cot::project::{MiddlewareContext, RootHandler, RootHandlerBuilder};
use cot::static_files::StaticFilesMiddleware;

struct MyProject;
impl Project for MyProject {
    fn middlewares(
        &self,
        handler: RootHandlerBuilder,
        context: &MiddlewareContext,
    ) -> RootHandler {
        handler
            .error_handler_middleware(StaticFilesMiddleware::from_context(context))
            .build()
    }
}

pub fn build(self) -> RootHandler

Builds the root handler for the project.

Examples

use cot::Project;
use cot::middleware::LiveReloadMiddleware;
use cot::project::{MiddlewareContext, RootHandler, RootHandlerBuilder};

struct MyProject;
impl Project for MyProject {
    fn middlewares(
        &self,
        handler: RootHandlerBuilder,
        context: &MiddlewareContext,
    ) -> RootHandler {
        handler
            .middleware(LiveReloadMiddleware::from_context(context))
            .build()
    }
}

Trait Implementations

impl<S: Clone, SE: Clone> Clone for RootHandlerBuilder<S, SE>

fn clone(&self) -> RootHandlerBuilder<S, SE>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S, SE> Debug for RootHandlerBuilder<S, SE>

where S: Debug, SE: Debug,

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

Formats the value using the given formatter.

impl<S: Hash, SE: Hash> Hash for RootHandlerBuilder<S, SE>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<S: PartialEq, SE: PartialEq> PartialEq for RootHandlerBuilder<S, SE>

fn eq(&self, other: &RootHandlerBuilder<S, SE>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<S: Eq, SE: Eq> Eq for RootHandlerBuilder<S, SE>

impl<S, SE> StructuralPartialEq for RootHandlerBuilder<S, SE>