Struct MiddleWare 

pub struct MiddleWare<'md, E> {
    pub marker: String,
    pub rank: i16,
    pub extensions: Extensions,
    /* private fields */
}

Represents a medium that handles the dataflow of App

In practise, it handles every data structure’s in-and-out during execution according to the marker and rank

Fields

marker: String

rank: i16

extensions: Extensions

Implementations

impl<'md, E> MiddleWare<'md, E>

pub fn builder() -> MiddleWareBuilder<'md, E>

Create an instance of MiddleWareBuilder that used to build a MiddleWare

Examples

async fn handle_task(&mut Vec<Task>, &mut App<E>) {}
let middleware = Middleware::builder()
    .task(handle_task)
    .build("marker");

pub fn rank(&self) -> i16

get the rank of MiddleWare

Examples

async fn handle_task(&mut Vec<Task>, &mut App<E>) {}
let middleware = MiddleWare::builder()
    .rank(1)
    .build("marker");
assert_eq!(middleware.rank(), 0);

pub fn rank_mut(&mut self) -> &mut i16

get mutable reference to rank of MiddleWare

Examples

async fn handle_task(&mut Vec<Task>, &mut App<E>) {}
let middleware = MiddleWare::builder()
    .task(handle_task)
    .build("marker");
middleware.rank_mut() = 3;
assert_eq!(middleware.rank(), 3);

pub fn extensions_mut(&mut self) -> &mut Extensions

mutate the extensions of MiddleWare

Examples

let mut middleware = Middleware::builder()
    .extensions(1i32)
    .build("marker");
middleware.extension_mut().insert(2i32);

pub fn extensions(&self) -> &Extensions

get extensions of MiddleWare

Examples

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

pub fn task_mut( 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 = MiddleWare::builder()
    .task_mut(&handle_task)
    .build("marker");
assert! (middleware.handle_task.is_some())

pub fn task( &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 = MiddleWare::builder()
    .task_mut(&handle_task)
    .build("marker");
assert_eq! (middleware.task (), Some(handle_task))

pub fn affix_mut( 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 = MiddleWare::builder()
    .affix_mut(&handle_affix)
    .build("marker");
assert! (middleware.handle_affix.is_some())

pub fn affix( &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 = MiddleWare::builder()
    .affix_mut(&handle_affix)
    .build("marker");
assert_eq! (middleware.affix (), Some(handle_affix))

pub fn entity_mut( 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 = MiddleWare::builder()
    .entity_mut(&handle_entity)
    .build("marker");
assert! (middleware.handle_entity.is_some())

pub fn entity( &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 = MiddleWare::builder()
    .entity_mut(&handle_entity)
    .build("marker");
assert_eq! (middleware.entity (), Some(handle_entity))

pub fn req_mut( 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 = MiddleWare::builder()
    .req_mut(&handle_req)
    .build("marker");
assert! (middleware.handle_req.is_some())

pub fn req( &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 = MiddleWare::builder()
    .req_mut(&handle_req)
    .build("marker");
assert_eq! (middleware.req (), Some(handle_req))

pub fn res_mut( 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 = MiddleWare::builder()
    .res_mut(&handle_res)
    .build("marker");
assert! (middleware.handle_res.is_some())

pub fn res( &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 = MiddleWare::builder()
    .res_mut(&handle_res)
    .build("marker");
assert_eq! (middleware.res (), Some(handle_res))

pub fn err_mut( 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 = MiddleWare::builder()
    .err_mut(&handle_err)
    .build("marker");
assert! (middleware.handle_err.is_some())

pub fn err( &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 = MiddleWare::builder()
    .err_mut(&handle_err)
    .build("marker");
assert_eq! (middleware.err (), Some(handle_err))

pub fn yerr_mut( 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 = MiddleWare::builder()
    .yerr_mut(&handle_yerr)
    .build("marker");
assert! (middleware.handle_yerr.is_some())

pub fn yerr( &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 = MiddleWare::builder()
    .yerr_mut(&handle_yerr)
    .build("marker");
assert_eq! (middleware.yerr (), Some(handle_yerr))