Struct BatchedErrors 

pub(crate) struct BatchedErrors {
    listed: Vec<(usize, String)>,
    total: usize,
}

Bounded accumulator that folds per-element conversion failures into one batched SexpError::InvalidValue, with the elements numbered as R counts them (1-based).

Backs every vector conversion that walks its input: Vec<T> / Vec<Option<T>> for a string-parsed type (ParsedRStr, #1143), the numeric-coercion vector shells from_numeric_vec_with / collect_coerced / coerce_slice_to_vec (#1192), tuples, factors, the As*Vec markers and the optional integrations. Instead of bailing on the first NA or failing element, they walk the whole vector and record each failure here with its 0-based index; the message says where each one is, (element 2).

Only the first BATCHED_ERROR_CAP failures are retained; every later failure is counted but its closure is never invoked. This keeps an all-failing N-element vector from materialising N Strings just to discard all but 10: the memory held is bounded regardless of input size. The remainder is summarized as "; and N more".

Two foldings:

• into_element_error: each entry is the failure’s reason (NA is not allowed, value out of range); entries with the same reason share one position list: NA is not allowed (elements 2, 4); value out of range (element 3).
• into_value_error: each entry is the offending value, listed with the positions after them, as AsNumericVec does: non-numeric value(s): "n/a", "<0.1" (elements 2, 5).

Neither names the Rust type: an argument’s conversion condition carries it as e$rust_type (#1591).

Fields

listed: Vec<(usize, String)>

(0-based index, reason or value) of the first BATCHED_ERROR_CAP failures.

total: usize

Implementations

impl BatchedErrors

pub fn push(&mut self, index: usize, item: impl FnOnce() -> String)

Record the failure of the element at 0-based index. item (its reason or value) is evaluated, with whatever it allocates, only for the first BATCHED_ERROR_CAP failures; later ones are counted for the "and N more" tail but never built.

pub fn is_empty(&self) -> bool

Whether any failure has been recorded.

fn write_more_tail(&self, msg: &mut String)

Append the "; and N more" tail when failures past the cap were counted.

pub fn into_element_error(self) -> SexpError

Fold the recorded (index, reason) failures into one SexpError::InvalidValue; see element_message.

pub fn element_message(&self) -> String

The message behind into_element_error: each distinct reason once, in the order it first occurred, followed by the 1-based positions of the elements that failed with it:

NA is not allowed (elements 2, 4); value out of range (element 3)

pub fn into_value_error(self, what: &str) -> SexpError

Fold recorded (0-based index, offending value) pairs into one SexpError::InvalidValue that shows the values and where they are:

<what> value(s): "n/a", "<0.1" (elements 2, 5)

Values are quoted (Rust Debug escaping, so invisible characters show), and element numbers are 1-based, as R counts them. Past the cap, the "; and N more" tail matches into_element_error.

fn value_message(&self, what: &str) -> String

The message behind into_value_error.

Trait Implementations

impl Default for BatchedErrors

fn default() -> Self

Returns the “default value” for a type.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 32 bytes