Struct dyer::plugin::middleware::MiddleWare

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

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".into());

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".into());
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".into());
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".into());
middleware.extension_mut().insert(2i32);

pub fn extensions(&self) -> &Extensions

get extensions of MiddleWare

Examples

let middleware = Middleware::builder()
    .extensions(1i32)
    .build("marker".into());
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".into());
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".into());
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".into());
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".into());
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".into());
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".into());
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".into());
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".into());
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".into());
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".into());
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".into());
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".into());
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".into());
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".into());
assert_eq! (middleware.yerr (), Some(handle_yerr))