Struct ValidationErrors 

pub struct ValidationErrors { /* private fields */ }

A non-empty collection of ValidationErrors, rendered as a Pydantic-style report.

Extends the Pydantic report with:

• fitness — Van der Aalst alignment conformance score
• variant_id — fingerprint for recurring failure patterns
• by_section — object-centric grouping

2 validation errors for Server
host
  must not be empty (got: `""`) [empty]
port
  input must be in range 1..=65535 (got: `0`) [out_of_range]

Implementations

impl ValidationErrors

pub fn errors(&self) -> &[ValidationError]

The individual errors, in the order they were discovered (depth-first).

pub fn len(&self) -> usize

Number of collected errors (always ≥ 1).

pub fn is_empty(&self) -> bool

Always false — ValidationErrors only exists when there is ≥ 1 error.

pub fn title(&self) -> Option<&str>

The model/type name this report is about, if set.

pub fn set_title_for<T: ?Sized>(&mut self)

Set the report title to the short name of T (e.g. ServerConfig).

pub fn has_fatal(&self) -> bool

Whether any error is Severity::Fatal (requires immediate halt).

pub fn errors_above( &self, min: Severity, ) -> impl Iterator<Item = &ValidationError>

Errors at or above the given severity threshold.

pub fn fitness(&self) -> f64

Van der Aalst alignment fitness — proportion of checks that passed.

Returns 1.0 when all checks pass (no errors), 0.0 when every check failed. Analogous to the replay-fitness metric from conformance checking: how well does the observed config align to the declared validation model?

Example

use star_toml::{Validate, Validator};

struct Pair { a: u32, b: u32 }
impl Validate for Pair {
    fn validate(&self, v: &mut Validator) {
        v.check_range("a", self.a, 1..=10);  // passes
        v.check_range("b", self.b, 1..=10);  // fails
    }
}
let errs = Pair { a: 5, b: 0 }.check().unwrap_err();
assert_eq!(errs.fitness(), 0.5);  // 1 of 2 checks passed

pub fn variant_id(&self) -> u64

Variant fingerprint — a deterministic hash of the failure pattern.

Two ValidationErrors instances with the same set of (location, code) pairs produce the same variant ID, regardless of message text or input values. Useful for deduplicating recurring failure patterns across runs.

Uses FNV-1a over the sorted "loc:code" pairs.

pub fn by_section(&self) -> BTreeMap<String, Vec<&ValidationError>>

Object-centric grouping — errors indexed by their top-level config section.

Implements Van der Aalst’s object-centric view: each top-level TOML table is an “object type”; this groups all its constraint violations together.

Root-level errors are keyed "(root)".

Trait Implementations

impl Clone for ValidationErrors

fn clone(&self) -> ValidationErrors

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ValidationErrors

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

Formats the value using the given formatter.

impl Display for ValidationErrors

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

Formats the value using the given formatter.

impl Eq for ValidationErrors

impl Error for ValidationErrors

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

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

Provides type-based access to context intended for error reports.

impl From<ValidationErrors> for Error

fn from(source: ValidationErrors) -> Self

Converts to this type from the input type.

impl PartialEq for ValidationErrors

fn eq(&self, other: &ValidationErrors) -> 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 StructuralPartialEq for ValidationErrors