Struct CombinedInvoker

pub struct CombinedInvoker<O: Invoker, I: Invoker> { /* private fields */ }

Struct that enables combining two Invokers by calling the second invoker inside the first one.

Implementations

impl<O: Invoker, I: Invoker> CombinedInvoker<O, I>

pub fn combine(outer: O, inner: I) -> CombinedInvoker<O, I>

Trait Implementations

impl<O: Invoker, I: Invoker> Invoker for CombinedInvoker<O, I>

fn invoke_with_mode_optional<'f, T: 'f, F: FnOnce() -> T + 'f>( &'f self, mode: Option<&'f Mode<'f, T>>, task: F, ) -> T

Invoke a task, optionally with a Mode supplied.

fn pre_invoke(&self)

Called by invoke_with_mode_optional before invoking each task. Can be used to run code before a task is invoked.

fn invoke_with_mode<'f, T: 'f, F: FnOnce() -> T + 'f>( &'f self, mode: &'f Mode<'f, T>, task: F, ) -> T

Invoke a task with a Mode. The default implementation for do_invoke delegates to crate::invoke if a mode was supplied. The Mode is applied to the task invoked by this Invoker, meaning the task of modes will run inside the do_invoke invocation so that logic run by the invoker before the task runs executes before the modes and logic run by the invoker after the task executes after the modes.

fn invoke<'f, T: 'f, F: FnOnce() -> T + 'f>(&'f self, task: F) -> T

Invoke a task using this invoker without a Mode.

fn do_invoke<'f, T: 'f, F: FnOnce() -> T + 'f>( &'f self, mode: Option<&'f Mode<'f, T>>, task: F, ) -> T

Core function responsible for actually invoking the task. This allows implementors to easily override how tasks are invoked without having to worry about doing any administrative tasks such as calling pre_invoke and post_invoke as would be the case when overriding invoke_with_mode_optional.

fn post_invoke(&self)

Called by invoke_with_mode_optional after invoking each task. Can be used to run code after a task is invoked.

fn invoke_post_invoke_on_panic(&self) -> bool

Return true if post_invoke should be called even if the task panicked using a Sentinel, defaults to false.

fn and_then<I: Invoker>(self, inner: I) -> CombinedInvoker<Self, I>

where Self: Sized,

Combines this Invoker with another Invoker by creating a CombinedInvoker that invokes tasks by first calling this Invoker with a task that submits the supplied task to the other Invoker, meaning the other Invoker will run inside this Invoker in such a way that the logic of this Invoker that runs before the task executes before the logic of the other Invoker but the logic of this Invoker that runs after the task executes after the logic of the other Invoker.