Struct ValidationContext 

pub struct ValidationContext { /* private fields */ }

Runs the four validation layers over one segment slice, collecting every issue into a single ValidationReport.

Layer	ValidationLayer	Default	Checks	Provided by
Envelope	Envelope	off	UNB/UNH/UNT/UNZ structure and counts	EnvelopeValidator
Structure	Structure	on	segment presence, order, arity	DirectoryValidator
Code-list	CodeList	on	DE values against the directory’s code lists	DirectoryValidator
Profile	Profile	on	partner and industry business rules	ProfileRulePack

Validators run in registration order within a layer; layers have no ordering beyond that. With the envelope layer on, UNB/UNZ/UNG/UNE are excluded from the slice later layers see.

A pack can be scoped by message type (for_message_type) and association-assigned code (for_release).

Group-aware validation

validate_grouped runs the flat pass and then a group pass over a SegmentGroupIndexed tree, so rules scoped to a segment group — “DTM must appear in every SG5” — can fire.

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(&segments);

Implementations

impl ValidationContext

pub fn builder() -> ValidationContextBuilder

Start building a validation context.

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

Execute validators in lenient mode for enabled layers.

pub fn validate_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_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::new("SG5", "LOC")];

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

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

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

Execute validators with per-call typed metadata.

message_type is set to None here; the concrete validation method (validate_with_context) re-extracts the message type from the UNH segment, so there is no information loss.

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(&message_segments);
}