Struct ValidationContext 

pub struct ValidationContext { /* private fields */ }

Runtime validation context for progressive layered validation.

Architecture

edifact-rs validation is organized into four independent layers, each responsible for a distinct class of checks. All layers run against the same segment slice; their issues are collected into a single ValidationReport.

Layer	ValidationLayer variant	Default	Type
Envelope	Envelope	disabled	EnvelopeValidator
Structure	Structure	enabled	external (e.g. DirectoryValidator)
Code-list	CodeList	enabled	external
Profile	Profile	enabled	ProfileRulePack / Arc<ProfileRulePack>

Validators are run in registration order within each enabled layer. Layers themselves have no enforced ordering beyond the order in which they are added via the builder.

Envelope layer

Checks UNB/UNH/UNT/UNZ structural invariants: presence, message count, and segment count. Enabled by calling ValidationContextBuilder::with_envelope_validation. When enabled, the envelope segments (UNB, UNZ, UNG, UNE) are excluded from the slice passed to validators in subsequent layers.

Structure layer

Validates segment presence, order, and arity against an EDIFACT directory. Implemented by DirectoryValidator (registered as a Structure-layer validator via ValidationContextBuilder::with_validator).

Code-list layer

Validates DE values against EDIFACT code lists from the directory. Also implemented by DirectoryValidator.

Profile layer

Applies downstream business rules (BDEW AHB / MIG rules, custom constraints) via ProfileRulePack. A pack can be scoped to specific EDIFACT message types (for_message_type) and association-assigned codes (for_release).

Group-aware validation

Validators that implement Validator::validate_group_batch can additionally enforce rules scoped to specific segment groups (e.g. “DTM must appear in every SG5 occurrence”). Call validate_lenient_grouped with a pre-built SegmentGroupIndexed tree to activate both the flat and group passes.

Example — building a context

use std::sync::{Arc, LazyLock};
use edifact_rs::{ProfileRulePack, ValidationContext, ValidationLayer};

static ORDERS_PACK: LazyLock<Arc<ProfileRulePack>> = LazyLock::new(|| {
    Arc::new(
        ProfileRulePack::new("ORDERS-MIG-5.5")
            .for_message_type("ORDERS")
            .require_segment("BGM", "MIG-BGM-M")
            .require_segment_in_group("SG2", "NAD", "SG2-NAD-M"),
    )
});

let ctx = ValidationContext::builder()
    .with_envelope_validation()
    .with_profile_pack_arc(Arc::clone(&*ORDERS_PACK))
    .build();

let report = ctx.validate_lenient(&segments);

Implementations

impl ValidationContext

pub fn builder() -> ValidationContextBuilder

Start building a validation context.

pub fn validate_lenient(&self, segments: &[Segment<'_>]) -> ValidationReport

Execute validators in lenient mode for enabled layers.

pub fn validate_lenient_grouped( &self, root: &SegmentGroupIndexed, segments: &[Segment<'_>], ) -> ValidationReport

Execute flat + group-aware validators in lenient mode.

This method runs the full flat validation pass (same as validate_lenient) and then runs the group-aware pass by calling Validator::validate_group_batch on every validator. Validators without group rules treat validate_group_batch as a no-op, so this is safe to call for any context.

When to use

Use this method when you have already grouped your segments with group_segments_indexed or group_owned_segments_indexed and want group-presence or cross-group rules (via ProfileRulePack::with_scoped_group_rule_fn) to fire.

Example

use edifact_rs::{group_segments_indexed, ValidationContext};
use edifact_rs::group::GroupDef;

static SCHEMA: &[GroupDef] = &[
    GroupDef { name: "SG5", trigger: "LOC", children: &[] },
];

let tree = group_segments_indexed(&segments, SCHEMA, "ROOT");
let pack = ProfileRulePack::new("AHB")
    .require_segment_in_group("SG5", "DTM", "SG5-DTM-M");
let ctx = ValidationContext::builder().with_profile_pack(pack).build();

let report = ctx.validate_lenient_grouped(&tree, &segments);

pub fn validate_strict_grouped( &self, root: &SegmentGroupIndexed, segments: &[Segment<'_>], ) -> Result<ValidationReport, ValidationReport>

Execute flat + group-aware validators in strict mode.

pub fn validate_lenient_grouped_owned( &self, root: &SegmentGroupIndexed, segments: &[OwnedSegment], ) -> ValidationReport

Execute flat + group-aware validators against owned segments in lenient mode.

pub fn validate_strict_grouped_owned( &self, root: &SegmentGroupIndexed, segments: &[OwnedSegment], ) -> Result<ValidationReport, ValidationReport>

Execute flat + group-aware validators against owned segments in strict mode.

pub fn validate_lenient_with<T: Any + Send + Sync>( &self, segments: &[Segment<'_>], value: &T, ) -> ValidationReport

Execute validators with per-call typed metadata.

pub fn validate_strict( &self, segments: &[Segment<'_>], ) -> Result<ValidationReport, ValidationReport>

Execute validators in strict mode for enabled layers.

pub fn validate_strict_with<T: Any + Send + Sync>( &self, segments: &[Segment<'_>], value: &T, ) -> Result<ValidationReport, ValidationReport>

Execute validators in strict mode with per-call typed metadata.

pub fn validate_lenient_owned( &self, segments: &[OwnedSegment], ) -> ValidationReport

Execute validators in lenient mode against an owned-segment slice.

pub fn validate_strict_owned( &self, segments: &[OwnedSegment], ) -> Result<ValidationReport, ValidationReport>

Execute validators in strict mode against an owned-segment slice.

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

Message type metadata associated with this context, if provided.

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

Message reference (UNH element 0) associated with this context, if provided.

pub fn fork_with_message_ref(&self, message_ref: impl Into<String>) -> Self

Create a child context that inherits all rules and configuration from self but is scoped to a specific message reference (UNH DE 0062).

Issues produced by the child context are automatically stamped with message_ref, making it easy to correlate findings in a multi-message interchange back to the originating UNH/UNT envelope.

Example

let base_ctx = ValidationContext::builder()
    .with_profile_pack(mig_pack)
    .build();

for (ref_no, message_segments) in messages {
    let child = base_ctx.fork_with_message_ref(&ref_no);
    let report = child.validate_lenient(&message_segments);
}