Struct DirectoryValidator 

pub struct DirectoryValidator { /* private fields */ }

Shared validator implementation that is configured per UN/EDIFACT directory release.

Scope and limitations

DirectoryValidator validates individual segment content (element counts, component counts, code-list values, and conditional rules) and checks that every mandatory segment type is present at least once. It does not validate segment sequence or repetition cardinality — i.e., it cannot tell you that a BGM segment appears more than once, or that a RFF group appears in the wrong position. Full sequence validation requires a state-machine per message type (UN/EDIFACT Segment Tables) which is outside the scope of this implementation.

Implementations

impl DirectoryValidator

pub fn new( directory_id: &'static str, segment_lookup: fn(&str) -> Option<&'static SegmentDefinition>, is_code_valid: fn(&str, &str) -> bool, suggest_code: fn(&str, &str) -> Option<&'static str>, expected_components: fn(&str, usize) -> Option<u8>, additional_structure_rule: Option<fn(&Segment<'_>) -> Result<(), EdifactError>>, ) -> Self

Create a validator for a specific directory release with injected lookup/check hooks.

pub fn from_definitions(definitions: &'static [SegmentDefinition]) -> Self

Create a validator from a static slice of SegmentDefinitions.

This is the preferred constructor when code-generating directory data as a static array: no manual fn-pointer boilerplate is required.

Code-list checks are disabled by default (the built-in is_code_valid always returns true). Call with_code_list_rules to register directory-specific rules that actually validate code values.

Example

static MY_SEGMENTS: &[SegmentDefinition] = &[ /* … */ ];

let validator = DirectoryValidator::from_definitions(MY_SEGMENTS)
    .with_code_list_rules(my_code_list_rules);

pub fn from_owned_definitions(definitions: Vec<OwnedSegmentDef>) -> Self

Create a validator from a runtime-owned collection of segment definitions.

Use this (or DirectoryValidatorBuilder) when segment definitions are loaded from an external source at startup (JSON, database, YAML, …) rather than being known at compile time.

Code-list checks are disabled by default; enable them by chaining with_code_list_rules and setting is_code_valid via a custom new call or by subclassing the builder.

Example

let defs = vec![
    OwnedSegmentDef::new(
        "BGM".to_owned(),
        "Beginning of message".to_owned(),
        vec![OwnedElementRef::new(1, "C002".to_owned(), Status::Mandatory, 1)],
    ),
];
let validator = DirectoryValidator::from_owned_definitions(defs)
    .with_directory_id("runtime-profile");

pub fn with_directory_id(self, id: impl Into<String>) -> Self

Set the directory identifier string (used in error messages).

pub fn with_code_list_rules( self, f: impl Fn(&str) -> &'static [(usize, usize, &'static str)] + Send + Sync + 'static, ) -> Self

Override the code-list rules function.

Directories can supply a directory-specific implementation that extends or replaces the base rules from base_code_list_rules.

pub fn structure_only(self) -> Self

Enable only structure checks and disable code-list checks.

pub fn code_list_only(self) -> Self

Enable only code-list checks and disable structure checks.

pub fn enforce_known_tags(self, enforce: bool) -> Self

Configure whether unknown segment tags should be rejected.

pub fn with_required_segments( self, f: impl Fn(&str) -> &'static [&'static str] + Send + Sync + 'static, ) -> Self

Override the required-segments mapping used for structural validation.

The supplied function receives an EDIFACT message type string (e.g. "ORDERS") and must return a 'static slice of segment tags that are mandatory for that type. The tags are checked both for presence and for canonical ordering within the message.

Example

fn my_required_segments(msg_type: &str) -> &'static [&'static str] {
    match msg_type {
        "DESADV" => &["UNH", "BGM", "SHP", "UNT"],
        "INVOIC" => &["UNH", "BGM", "MOA", "UNT"],
        _ => &["UNH", "UNT"],
    }
}

let validator = DirectoryValidator::from_definitions(DEFS)
    .with_required_segments(my_required_segments);

Trait Implementations

impl Clone for DirectoryValidator

fn clone(&self) -> DirectoryValidator

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DirectoryValidator

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

Formats the value using the given formatter.

impl Validator for DirectoryValidator

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

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

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

Validate a full segment set and append issues to report.