Struct MiddleWareBuilder 

pub struct MiddleWareBuilder<'md, E> { /* private fields */ }

Serve as an medium to create an instance of MiddleWare

This type can be used to construct an instance or MiddleWare through a builder-like pattern.

Implementations

impl<'md, E> MiddleWareBuilder<'md, E>

pub fn new() -> Self

Create an instance of MiddleWare

Examples

let middleware = MiddlewareBuilder::new();
assert!(middleware.entity_ref().is_none());

pub fn build<T: Into<String>>(self, marker: T) -> MiddleWare<'md, E>

Consume it and return an instance of MiddleWare

Examples

async fn handle_entity(_: &mut Vec<E>, _: &mut App<E>) {}
let middleware = MiddlewareBuilder::new();
    .entity(handle_entity)
    .build("marker");

pub fn extensions<S>(self, extensions: S) -> Self

where S: Any + Send + Sync + 'static,

set the extensions of MiddleWareBuilder

Examples

let middleware = middleware::builder()
    .extensions(1i32)
    .build("marker");
assert_eq!(middleware.extensions().get::<i32>(), 1);

pub fn extensions_ref(&self) -> &Extensions

get extensions of MiddleWareBuilder

Examples

let middleware = middleware::builder()
    .extensions(1i32)
    .build("marker");
assert_eq!(middleware.extensions_ref().get::<i32>(), 1);

pub fn rank(self, rank: i16) -> Self

set the rank of MiddleWareBuilder

Examples

let middleware = MiddleWareBuilder::new()
    .rank(1)
    .build("marker");
assert_eq!(middleware.rank_ref(), 1);

pub fn rank_ref(&self) -> i16

get rank of MiddleWareBuilder

Examples

let middleware = MiddleWareBuilder::new()
    .rank(1)
    .build("marker");
middleware.rank_mut() = 3;
assert_eq!(middleware.rank_ref(), 3);

pub fn task( self, task: &'md dyn for<'a> Fn(&'a mut Vec<Task>, &'a mut App<E>) -> BoxFuture<'a, ()>, ) -> Self

Set the Task handler of MiddleWare, if not called, the default value is None

Examples

async fn handle_task(_: &mut Vec<Task>, _: &mut App<E>) {}
let middleware = MiddleWareBuilder::new()
    .task(&handle_task)
    .build("marker");
assert! (middleware.handle_task.is_some())

pub fn task_ref( &self, ) -> Option<&'md dyn for<'a> Fn(&'a mut Vec<Task>, &'a mut App<E>) -> BoxFuture<'a, ()>>

Get the shared reference of Task handler of MiddleWare, if not set before, None is returned

Examples

async fn handle_task(_: &mut Vec<Task>, _: &mut App<E>) {}
let middleware = MiddleWareBuilder::new()
    .task(&handle_task)
    .build("marker");
assert_eq! (middleware.task_ref (), Some(handle_task))

pub fn affix( self, affix: &'md dyn for<'a> Fn(&'a mut Vec<Affix>, &'a mut App<E>) -> BoxFuture<'a, ()>, ) -> Self

Set the Affix handler of MiddleWare, if not called, the default value is None

Examples

async fn handle_affix(_: &mut Vec<Affix>, _: &mut App<E>) {}
let middleware = MiddleWareBuilder::new()
    .affix(&handle_affix)
    .build("marker");
assert! (middleware.handle_affix.is_some())

pub fn affix_ref( &self, ) -> Option<&'md dyn for<'a> Fn(&'a mut Vec<Affix>, &'a mut App<E>) -> BoxFuture<'a, ()>>

Get the shared reference of Affix handler of MiddleWare, if not set before, None is returned

Examples

async fn handle_affix(_: &mut Vec<Affix>, _: &mut App<E>) {}
let middleware = MiddleWareBuilder::new()
    .affix(&handle_affix)
    .build("marker");
assert_eq! (middleware.affix_ref (), Some(handle_affix))

pub fn entity( self, entity: &'md dyn for<'a> Fn(&'a mut Vec<E>, &'a mut App<E>) -> BoxFuture<'a, ()>, ) -> Self

Set the E handler of MiddleWare, if not called, the default value is None

Examples

async fn handle_entity(_: &mut Vec<E>, _: &mut App<E>) {}
let middleware = MiddleWareBuilder::new()
    .entity(&handle_entity)
    .build("marker");
assert! (middleware.handle_entity.is_some())

pub fn entity_ref( &self, ) -> Option<&'md dyn for<'a> Fn(&'a mut Vec<E>, &'a mut App<E>) -> BoxFuture<'a, ()>>

Get the shared reference of E handler of MiddleWare, if not set before, None is returned

Examples

async fn handle_entity(_: &mut Vec<E>, _: &mut App<E>) {}
let middleware = MiddleWareBuilder::new()
    .entity(&handle_entity)
    .build("marker");
assert_eq! (middleware.entity_ref (), Some(handle_entity))

pub fn req( self, req: &'md dyn for<'a> Fn(&'a mut Vec<Request>, &'a mut App<E>) -> BoxFuture<'a, ()>, ) -> Self

Set the Request handler of MiddleWare, if not called, the default value is None

Examples

async fn handle_req(_: &mut Vec<Request>, _: &mut App<E>) {}
let middleware = MiddleWareBuilder::new()
    .req(&handle_req)
    .build("marker");
assert! (middleware.handle_req.is_some())

pub fn req_ref( &self, ) -> Option<&'md dyn for<'a> Fn(&'a mut Vec<Request>, &'a mut App<E>) -> BoxFuture<'a, ()>>

Get the shared reference of Request handler of MiddleWare, if not set before, None is returned

Examples

async fn handle_req(_: &mut Vec<Request>, _: &mut App<E>) {}
let middleware = MiddleWareBuilder::new()
    .req(&handle_req)
    .build("marker");
assert_eq! (middleware.req_ref (), Some(handle_req))

pub fn res( self, res: &'md dyn for<'a> Fn(&'a mut Vec<Response>, &'a mut App<E>) -> BoxFuture<'a, ()>, ) -> Self

Set the Response handler of MiddleWare, if not called, the default value is None

Examples

async fn handle_res(_: &mut Vec<Response>, _: &mut App<E>) {}
let middleware = MiddleWareBuilder::new()
    .res(&handle_res)
    .build("marker");
assert! (middleware.handle_res.is_some())

pub fn res_ref( &self, ) -> Option<&'md dyn for<'a> Fn(&'a mut Vec<Response>, &'a mut App<E>) -> BoxFuture<'a, ()>>

Get the shared reference of Response handler of MiddleWare, if not set before, None is returned

Examples

async fn handle_res(_: &mut Vec<Response>, _: &mut App<E>) {}
let middleware = MiddleWareBuilder::new()
    .res(&handle_res)
    .build("marker");
assert_eq! (middleware.res_ref (), Some(handle_res))

pub fn err( self, err: &'md dyn for<'a> Fn(&'a mut Vec<Result<Response, MetaResponse>>, &'a mut App<E>) -> BoxFuture<'a, ()>, ) -> Self

Set the Result<Response, MetaResponse> handler of MiddleWare, if not called, the default value is None

Examples

async fn handle_err(_: &mut Vec<Result<Response, MetaResponse>>, _: &mut App<E>) {}
let middleware = MiddleWareBuilder::new()
    .err(&handle_err)
    .build("marker");
assert! (middleware.handle_err.is_some())

pub fn err_ref( &self, ) -> Option<&'md dyn for<'a> Fn(&'a mut Vec<Result<Response, MetaResponse>>, &'a mut App<E>) -> BoxFuture<'a, ()>>

Get the shared reference of Result<Response, MetaResponse> handler of MiddleWare, if not set before, None is returned

Examples

async fn handle_err(_: &mut Vec<Result<Response, MetaResponse>>, _: &mut App<E>) {}
let middleware = MiddleWareBuilder::new()
    .err(&handle_err)
    .build("marker");
assert_eq! (middleware.err_ref (), Some(handle_err))

pub fn yerr( self, yerr: &'md dyn for<'a> Fn(&'a mut Vec<Result<Response, MetaResponse>>, &'a mut App<E>) -> BoxFuture<'a, ()>, ) -> Self

Set the Result<Response, MetaResponse> handler of MiddleWare, if not called, the default value is None

Examples

async fn handle_yerr(_: &mut Vec<Result<Response, MetaResponse>>, _: &mut App<E>) {}
let middleware = MiddleWareBuilder::new()
    .yerr(&handle_yerr)
    .build("marker");
assert! (middleware.handle_yerr.is_some())

pub fn yerr_ref( &self, ) -> Option<&'md dyn for<'a> Fn(&'a mut Vec<Result<Response, MetaResponse>>, &'a mut App<E>) -> BoxFuture<'a, ()>>

Get the shared reference of Result<Response, MetaResponse> handler of MiddleWare, if not set before, None is returned

Examples

async fn handle_yerr(_: &mut Vec<Result<Response, MetaResponse>>, _: &mut App<E>) {}
let middleware = MiddleWareBuilder::new()
    .yerr(&handle_yerr)
    .build("marker");
assert_eq! (middleware.yerr_ref (), Some(handle_yerr))