Struct ProfileRulePack 

pub struct ProfileRulePack { /* private fields */ }

A profile/MIG rule pack that can be plugged into ValidationContext.

Implementations

impl ProfileRulePack

pub fn new(name: impl Into<String>) -> Self

Create an empty rule pack.

pub fn name(&self) -> &str

Return the pack name.

pub fn message_types(&self) -> impl Iterator<Item = &str>

Return the message types this pack is scoped to.

pub fn rule_count(&self) -> usize

Return the number of rules in this pack.

pub fn rule_ids(&self) -> impl Iterator<Item = &str>

Iterate over the stable identifiers of all named rules in this pack.

Anonymous rules (added without an id) are skipped.

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

Return the association-assigned release code this pack is bound to, if any.

None means the pack applies to messages of any association code.

pub fn for_message_type(self, message_type: impl Into<String>) -> Self

Restrict this pack to one or more EDIFACT message types from the UNH segment.

When a pack has one or more message-type restrictions, its rules are only evaluated against messages whose UNH element 1, component 0 matches one of the registered types (e.g. "ORDERS", "INVOIC").

Silent-skip behaviour

If the input segments do not contain a UNH segment, or if the UNH message-type element is absent, the pack will silently skip all rules rather than returning an error. This is intentional: without a readable message type the pack cannot determine whether its rules apply, so it errs on the side of no false positives.

If you need a hard failure on a missing UNH, add a dedicated ProfileRule that checks for the segment’s presence before other rules run.

pub fn for_release(self, release: impl Into<String>) -> Self

Bind this pack to a specific association-assigned code (DE 0057).

When a release is set, rules are only evaluated against messages whose UNH element 1, component 4 matches release exactly (e.g. "5.5.3a"). Packs with no bound release are universal — they run for every message regardless of its association code.

Example

let pack = ProfileRulePack::new("UTILMD-5.5.3a")
    .for_message_type("UTILMD")
    .for_release("5.5.3a");

pub fn bail_on_first_error(self, bail: bool) -> Self

Stop evaluating rules in this pack after the first Error- or Critical-severity finding.

Bail applies per pack, not globally — other packs in the ValidationContext still run even when this pack bails early. This avoids flooding validation reports with cascading false positives when a mandatory segment is missing and all subsequent rules reference its content.

pub fn with_rule_fn<F>(self, rule: F) -> Self

where F: for<'a> Fn(&[Segment<'a>], &ValidationRuleContext<'_>) -> Option<ValidationIssue> + Send + Sync + 'static,

Add a context-aware rule closure.

The closure receives both the segment slice and a ValidationRuleContext that may carry typed metadata injected at validation call time via ValidationContext::validate_lenient_with.

For rules that do not need context, use with_stateless_rule_fn.

pub fn with_named_rule_fn<F>(self, id: impl Into<Arc<str>>, rule: F) -> Self

where F: for<'a> Fn(&[Segment<'a>], &ValidationRuleContext<'_>) -> Option<ValidationIssue> + Send + Sync + 'static,

Add a context-aware rule closure with a stable identifier.

The id is used by merge_with_override to de-duplicate rules across packs: if other has a rule with the same id, it replaces the corresponding rule in self.

pub fn with_stateless_rule_fn<F>(self, rule: F) -> Self

where F: for<'a> Fn(&[Segment<'a>]) -> Option<ValidationIssue> + Send + Sync + 'static,

Add a context-free rule closure.

Convenience wrapper for rules that do not inspect the ValidationRuleContext.

pub fn with_named_stateless_rule_fn<F>( self, id: impl Into<Arc<str>>, rule: F, ) -> Self

where F: for<'a> Fn(&[Segment<'a>]) -> Option<ValidationIssue> + Send + Sync + 'static,

Add a context-free rule closure with a stable identifier.

See with_named_rule_fn for override semantics.

pub fn with_rule(self, rule: impl ProfileRule + 'static) -> Self

Add a rule that implements ProfileRule.

pub fn with_named_rule( self, id: impl Into<Arc<str>>, rule: impl ProfileRule + 'static, ) -> Self

Add a named rule that implements ProfileRule.

See with_named_rule_fn for override semantics.

pub fn extend_from(self, base: &ProfileRulePack) -> Result<Self, EdifactError>

Prepend all rules from base to this pack.

Rules from base are shared (via Arc cloning) and run first. Message-type restrictions from base are also merged. The resulting release scope must be compatible with both packs: if one pack is scoped to a release and the other is not, the scope is preserved; if both are scoped, they must match.

Example

let base = ProfileRulePack::new("MIG-UTILMD-BASE")
    .with_stateless_rule_fn(/* mandatory segment rules */);

let ahb_11001 = ProfileRulePack::new("AHB-11001")
    .extend_from(&base)
    .with_stateless_rule_fn(/* 11001-specific rules */);

pub fn merge(self, other: Self) -> Result<Self, EdifactError>

Merge two packs into one combined pack.

Rules from self run before rules from other. If both packs contain named rules with the same id, both run — use merge_with_override to de-duplicate by id instead. Release scoping follows the same compatibility rule as extend_from.

pub fn merge_with_override(self, other: Self) -> Result<Self, EdifactError>

Merge other into self, with other taking precedence for any rule whose id already exists in self.

• Rules in other that have a stable id matching a rule in self replace the rule at the same position in self.
• Rules in other with no id, or with an id not present in self, are appended to self.
• Rules present only in self (no matching override in other) are retained unchanged.

Message-type restrictions from other are merged into self. Release scoping follows the same compatibility rule as extend_from.

Example

let base = ProfileRulePack::new("UTILMD-5.4")
    .with_named_stateless_rule_fn("AHB-11001-BGM-M", |segs| { /* old rule */ None });

let delta = ProfileRulePack::new("UTILMD-5.5-delta")
    .with_named_stateless_rule_fn("AHB-11001-BGM-M", |segs| { /* updated rule */ None });

// `result` runs the updated BGM-M rule only once:
let result = base.merge_with_override(delta);
assert_eq!(result.rule_count(), 1);

Trait Implementations

impl Debug for ProfileRulePack

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

Formats the value using the given formatter.

impl Validator for ProfileRulePack

fn validate_batch( &self, segments: &[Segment<'_>], report: &mut ValidationReport, context: &ValidationRuleContext<'_>, )

Validate a full segment set and append issues to report.

fn set_message_type(&mut self, _message_type: Option<&str>)

Configure message-type metadata for validators that support explicit scoping.