Struct ErrorAccumulator 

pub struct ErrorAccumulator<List> { /* private fields */ }

The entry-point to accumulate parsing results.

All parsing results are tracked, i.e. Ok values and errors alike.

Use the methods like field(), strukt(), or array() to tell the accumulator from where in the input the next parsing results are derived.

The final analyse() call returns all errors if at least one error was recorded else a tuple of all recorded Ok values is returned. There is also on_ok() to convert the recorded Ok values before retruning the tuple.

Implementations

impl ErrorAccumulator<Nil>

pub fn new() -> Self

Create a new, empty ErrorAccumulator.

impl<List> ErrorAccumulator<List>

pub fn field<FieldValue, E>( self, field: FieldName, result: Result<FieldValue, E>, ) -> ErrorAccumulator<List::Output>

where List: Append<FieldValue>, E: Error + Send + Sync + 'static,

Record a result of parsing a field of the input.

pub fn field_builder<FieldValue>( self, field: FieldName, ) -> FieldBuilder<Self, FieldValue, Nil>

where List: Append<FieldValue>,

Start a FieldBuilder to record results for parsing of a single input field.

This allows for more finegrained validation of a single input value, e.g. like testing for different properties.

See FieldBuilder for more information.

pub fn strukt<StructValue>( self, field: FieldName, ) -> StructBuilder<Self, StructValue, Nil>

where List: Append<StructValue>,

Start a StructBuilder to analyse the parsing results of a nested struct of the input.

This is mainly to record the correct source paths when walking the input’s structure.

See StructBuilder for more information.

pub fn array<ElementValue>( self, field: FieldName, ) -> ArrayBuilder<Self, ElementValue>

where List: Append<Vec<ElementValue>>,

Start an ArrayBuilder to analyse the elements of a nested array of the input.

See ArrayBuilder for more information.

pub fn with_previous<Valid, T, E>( self, validator: Valid, ) -> ErrorAccumulator<List::Output>

where Valid: ListValidator<List, T, E>, List: AsRefTuple + Append<T>, E: Error + Send + Sync + 'static,

Run another validation step on the previously recorded Ok values if there were no errors yet.

In case an error was already recorded the validator is not executed.

For an example, see the docs of StructBuilder::with_previous().

pub fn on_ok<C, Out>( self, constructor: C, ) -> ErrorAccumulatorFinisher<List, C, Out>

where List: ToTuple, C: Constructor<List::List, Out>,

Provide a Constructor function that is called on analyse() in case all recorded results (including nested results) where Ok.

• The input to the constructor are the recorded Ok values in order of recording.
• After providing the constructor no more results can be recorded.

pub fn analyse(self) -> Result<List::List, AccumulatedError>

where List: ToTuple,

Analyse all recorded results.

If at least one error was recorded the AccumulatedErrors are returned else a tuple of all recorded Ok values in recording order is returned.

Trait Implementations

impl<List: Debug> Debug for ErrorAccumulator<List>

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

Formats the value using the given formatter.

impl Default for ErrorAccumulator<Nil>

fn default() -> Self

Returns the “default value” for a type.

impl<ChildValue, List> ErrorBuilderParent<ChildValue> for ErrorAccumulator<List>

where List: Append<ChildValue>,

type AfterRecord = ErrorAccumulator<<List as Append<ChildValue>>::Output>

The parent builder after the child builder finished.

fn finish_child_builder( self, child_result: Result<ChildValue, AccumulatedError>, ) -> Self::AfterRecord

Record the final result of the child builder.