Struct Immediate 

pub struct Immediate;

Immediate execution strategy.

This strategy executes a given task immediately, and is primarily intended for testing and debugging purposes. No threading is involved, which makes it much easier to reason about execution order. Additionally, it can act as a baseline for comparison with worker-based strategies.

Warning: When channels are involved, this strategy might deadlock, i.e., when a task from a worker thread tries to send on a bounded channel that is full. In this case, make sure to either use unbounded channels, or actively drain the channel before sending on it.

Examples

use zrx_executor::strategy::{Immediate, Strategy};

// Create strategy and submit task
let strategy = Immediate::default();
strategy.submit(Box::new(|| println!("Task")))?;

Implementations

impl Immediate

pub fn new() -> Self

Creates an immediate execution strategy.

Examples

use zrx_executor::strategy::Immediate;

// Create strategy
let strategy = Immediate::new();

Trait Implementations

impl Debug for Immediate

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

Formats the execution strategy for debugging.

impl Default for Immediate

fn default() -> Self

Creates an immediate execution strategy.

Examples

use zrx_executor::strategy::Immediate;

// Create strategy
let strategy = Immediate::default();

impl Strategy for Immediate

fn submit(&self, task: Box<dyn Task>) -> Result

Submits a task.

This method immediately executes the given Task, so that it runs on the main thread, which is primarily intended for testing and debugging.

Note that tasks are intended to only run once, which is why they are consumed. If a task needs to be run multiple times, it must be wrapped in a closure that creates a new task each time. This allows for safe sharing of state between tasks.

Errors

This method is infallible, and will always return Ok.

Errors

Examples

use zrx_executor::strategy::{Immediate, Strategy};

// Create strategy and submit task
let strategy = Immediate::default();
strategy.submit(Box::new(|| println!("Task")))?;

fn num_workers(&self) -> usize

Returns the number of workers.

The number of usable workers is always 1 for this strategy, as tasks are immediately executed on the main thread when submitted.

Examples

use zrx_executor::strategy::{Immediate, Strategy};

// Get number of workers
let strategy = Immediate::new();
assert_eq!(strategy.num_workers(), 1);

fn num_tasks_running(&self) -> usize

Returns the number of running tasks.

The number of running tasks is always 0 for this strategy, as tasks are immediately executed on the main thread when submitted.

Examples

use zrx_executor::strategy::{Immediate, Strategy};

// Get number of running tasks
let strategy = Immediate::default();
assert_eq!(strategy.num_tasks_running(), 0);

fn num_tasks_pending(&self) -> usize

Returns the number of pending tasks.

The number of pending tasks is always 0 for this strategy, as tasks are immediately executed on the main thread when submitted.

Examples

use zrx_executor::strategy::{Immediate, Strategy};

// Get number of pending tasks
let strategy = Immediate::default();
assert_eq!(strategy.num_tasks_pending(), 0);

fn capacity(&self) -> usize

Returns the capacity.

Examples

use zrx_executor::strategy::{Immediate, Strategy};

// Get capacity
let strategy = Immediate::default();
assert_eq!(strategy.capacity(), 0);