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 named_rule_count(&self) -> usize

Return the number of named rules (those with a stable identifier).

pub fn anonymous_rule_count(&self) -> usize

Return the number of anonymous rules (those without a stable identifier).

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

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

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

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

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.

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

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

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

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

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

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

Add a context-aware rule closure.

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

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

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

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

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

Add a context-free rule closure.

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

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

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

pub fn require_segment( self, tag: &'static str, rule_id: impl Into<Arc<str>>, ) -> Self

Add a rule that asserts segment tag is present at least once.

Emits an Error-severity issue when no segment with tag is found.

Example

let pack = ProfileRulePack::new("MY-AHB")
    .require_segment("BGM", "MY-BGM-M")
    .require_segment("DTM", "MY-DTM-M");

pub fn forbid_segment( self, tag: &'static str, rule_id: impl Into<Arc<str>>, ) -> Self

Add a rule that asserts segment tag does not appear.

Emits an Error-severity issue for each occurrence found.

pub fn require_qualifier( self, tag: &'static str, element: u8, component: u8, qualifier: &'static str, rule_id: impl Into<Arc<str>>, ) -> Self

Add a rule that asserts data element de_qualifier at (element, component) equals qualifier for every occurrence of tag.

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

where F: Fn(&SegmentGroupIndexed, &[Segment<'_>], &ValidationRuleContext<'_>, &mut Vec<ValidationIssue>) + Send + Sync + 'static,

Add a group-aware rule closure that fires for every group node in the DFS traversal of the segment-group tree.

The closure receives:

• group: &SegmentGroupIndexed — the current tree node (with definition, total_span, children).
• group_segments: &[Segment<'_>] — all segments in this group’s subtree (all_segments[group.total_span.clone()]).
• context: &ValidationRuleContext<'_> — per-call metadata and message info.
• issues: &mut Vec<ValidationIssue> — push violations here.

Group-name scoping

Use with_scoped_group_rule_fn when you only want the rule to fire for a specific group definition (e.g. "SG5").

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

where F: Fn(&SegmentGroupIndexed, &[Segment<'_>], &ValidationRuleContext<'_>, &mut Vec<ValidationIssue>) + Send + Sync + 'static,

Add a named group-aware rule closure that fires for every group node.

pub fn with_scoped_group_rule_fn<F>( self, group_scope: &'static str, id: impl Into<Arc<str>>, rule: F, ) -> Self

where F: Fn(&SegmentGroupIndexed, &[Segment<'_>], &ValidationRuleContext<'_>, &mut Vec<ValidationIssue>) + Send + Sync + 'static,

Add a named group-aware rule closure scoped to a specific group definition.

The closure is called only when the DFS traversal enters a group whose SegmentGroupIndexed::definition equals group_scope (e.g. "SG5").

Example

let pack = ProfileRulePack::new("AHB-MSCONS")
    .with_scoped_group_rule_fn("SG5", "SG5-CAV-M", |_group, segs, _ctx, issues| {
        if !segs.iter().any(|s| s.tag == "CAV") {
            issues.push(
                ValidationIssue::new(ValidationSeverity::Error, "CAV missing in SG5")
                    .with_segment("CAV")
                    .with_rule_id("SG5-CAV-M"),
            );
        }
    });

pub fn require_segment_in_group( self, group_scope: &'static str, tag: &'static str, rule_id: impl Into<Arc<str>>, ) -> Self

Assert segment tag is present in every occurrence of group group_scope.

For example, require_segment_in_group("SG5", "LOC", "SG5-LOC-M") fires once per SG5 instance that contains no LOC segment.

Issues are automatically annotated with the group name.

pub fn forbid_segment_in_group( self, group_scope: &'static str, tag: &'static str, rule_id: impl Into<Arc<str>>, ) -> Self

Assert segment tag does not appear in any occurrence of group group_scope.

Emits an Error-severity issue for each occurrence found.

pub fn require_qualifier_in_group( self, group_scope: &'static str, tag: &'static str, element: u8, component: u8, qualifier: &'static str, rule_id: impl Into<Arc<str>>, ) -> Self

Assert qualifier qualifier at (element, component) in segment tag is present in every occurrence of group group_scope.

pub fn group_rule_count(&self) -> usize

Return the number of group-scoped rules in this pack.

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.

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.

Errors

Returns EdifactError::IncompatibleReleaseScopes if both packs specify different release scopes.

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_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.

Errors

Returns EdifactError::IncompatibleReleaseScopes if both packs specify different release scopes.

Example

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

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

// `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 Clone for ProfileRulePack

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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 validate_group_batch( &self, root: &SegmentGroupIndexed, all_segments: &[Segment<'_>], report: &mut ValidationReport, context: &ValidationRuleContext<'_>, )

Validate a segment-group tree and append issues to report.

fn fork(&self) -> Box<dyn Validator + Send + Sync>

Create a Box<dyn Validator> clone of this validator for context forking.

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

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