Struct darling::error::Accumulator

pub struct Accumulator(/* private fields */);

Accumulator for errors, for helping call Error::multiple.

See the docs for darling::Error for more discussion of error handling with darling.

Panics

Accumulator panics on drop unless finish, finish_with, or into_inner has been called, even if it contains no errors. If you want to discard an Accumulator that you know to be empty, use accumulator.finish().unwrap().

Example

fn validate_things(inputs: Vec<Thing>) -> darling::Result<Vec<Output>> {
    let mut errors = darling::Error::accumulator();

    let outputs = inputs
        .into_iter()
        .filter_map(|thing| errors.handle_in(|| thing.validate()))
        .collect::<Vec<_>>();

    errors.finish()?;
    Ok(outputs)
}

Implementations

impl Accumulator

pub fn handle_in<T, F>(&mut self, f: F) -> Option<T>where F: FnOnce() -> Result<T, Error>,

Runs a closure, returning the successful value as Some, or collecting the error

The closure’s return type is darling::Result, so inside it one can use ?.

pub fn handle<T>(&mut self, result: Result<T, Error>) -> Option<T>

Handles a possible error.

Returns a successful value as Some, or collects the error and returns None.

pub fn finish(self) -> Result<(), Error>

Stop accumulating errors, producing Ok if there are no errors or producing an error with all those encountered by the accumulator.

pub fn finish_with<T>(self, success: T) -> Result<T, Error>

Bundles the collected errors if there were any, or returns the success value

Call this at the end of your input processing.

If there were no errors recorded, returns Ok(success). Otherwise calls Error::multiple and returns the result as an Err.

pub fn into_inner(self) -> Vec<Error>

Returns the accumulated errors as a Vec.

This function defuses the drop bomb.

pub fn push(&mut self, error: Error)

Add one error to the collection.

pub fn checkpoint(self) -> Result<Accumulator, Error>

Finish the current accumulation, and if there are no errors create a new Self so processing may continue.

This is shorthand for:

errors.finish()?;
errors = Error::accumulator();

Drop Behavior

This function returns a new Accumulator in the success case. This new accumulator is “armed” and will detonate if dropped without being finished.

Example

fn validate(lorem_inputs: &[Thing], ipsum_inputs: &[Thing])
            -> darling::Result<(Vec<Output>, Vec<Output>)> {
    let mut errors = darling::Error::accumulator();

    let lorems = lorem_inputs.iter().filter_map(|l| {
        errors.handle(l.validate())
    }).collect();

    errors = errors.checkpoint()?;

    let ipsums = ipsum_inputs.iter().filter_map(|l| {
        errors.handle(l.validate())
    }).collect();

    errors.finish_with((lorems, ipsums))
}

Trait Implementations

impl Debug for Accumulator

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

Formats the value using the given formatter.

impl Default for Accumulator

fn default() -> Accumulator

Returns the “default value” for a type.

impl Drop for Accumulator

fn drop(&mut self)

Executes the destructor for this type.

impl Extend<Error> for Accumulator

fn extend<I>(&mut self, iter: I)where I: IntoIterator<Item = Error>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.