Struct BatchCallResult 

pub struct BatchCallResult<R, E> { /* private fields */ }

Result produced by crate::BatchExecutor::call.

The execution outcome contains the same failure aggregation as crate::BatchExecutor::execute. The value list is indexed by the original callable index; successful callables store Some(value), while failed or panicked callables store None.

use qubit_batch::{
    BatchExecutor,
    SequentialBatchExecutor,
};

fn count_users() -> Result<usize, &'static str> {
    Ok(3)
}

fn count_orders() -> Result<usize, &'static str> {
    Ok(5)
}

let result = SequentialBatchExecutor::new()
    .call([count_users, count_orders])
    .expect("array length should be exact");

assert!(result.outcome().is_success());
assert_eq!(result.values(), &[Some(3), Some(5)]);

Type Parameters

• R - Callable success value type.
• E - Callable error type.

Implementations

impl<R, E> BatchCallResult<R, E>

pub fn new(outcome: BatchOutcome<E>, values: Vec<Option<R>>) -> Self

Creates a new callable batch result.

Parameters

• outcome - Execution outcome and failures.
• values - Success values indexed by callable position.

Returns

A callable batch result.

pub const fn outcome(&self) -> &BatchOutcome<E>

Returns the execution outcome for the callable batch.

Returns

A shared reference to the underlying execution outcome.

pub fn values(&self) -> &[Option<R>]

Returns success values indexed by callable position.

Returns

A shared slice of optional success values.

pub fn into_outcome(self) -> BatchOutcome<E>

Consumes this result and returns the execution outcome.

Returns

The underlying execution outcome.

pub fn into_values(self) -> Vec<Option<R>>

Consumes this result and returns success values.

Returns

Success values indexed by callable position.

pub fn into_parts(self) -> (BatchOutcome<E>, Vec<Option<R>>)

Consumes this result and returns both stored parts.

Returns

A tuple containing the execution outcome and indexed success values.

Trait Implementations

impl<R: Clone, E: Clone> Clone for BatchCallResult<R, E>

fn clone(&self) -> BatchCallResult<R, E>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<R: Debug, E: Debug> Debug for BatchCallResult<R, E>

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

Formats the value using the given formatter.

impl<R: PartialEq, E: PartialEq> PartialEq for BatchCallResult<R, E>

fn eq(&self, other: &BatchCallResult<R, E>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<R: Eq, E: Eq> Eq for BatchCallResult<R, E>

impl<R, E> StructuralPartialEq for BatchCallResult<R, E>