Enum EdifactError 

#[non_exhaustive]
pub enum EdifactError {
    UnexpectedEof {
        offset: usize,
    },
    InvalidDelimiter {
        byte: u8,
        offset: usize,
    },
    InvalidText {
        offset: usize,
    },
    InvalidReleaseSequence {
        offset: usize,
    },
    MessageCountMismatch {
        expected: u32,
        actual: u32,
    },
    SegmentCountMismatch {
        expected: u32,
        actual: u32,
        message_ref: String,
    },
    InvalidSegmentTag(String),
    InvalidUna,
    MissingRequiredElement {
        tag: String,
        element_index: usize,
    },
    MissingRequiredComponent {
        tag: String,
        element_index: usize,
        component_index: usize,
    },
    InvalidUtf8,
    Io(IoError),
    InvalidSegmentForMessage {
        tag: String,
        message_type: String,
        span: Span,
    },
    InvalidElementCount {
        tag: String,
        min: usize,
        max: usize,
        actual: usize,
        span: Span,
    },
    InvalidComponentCount {
        tag: String,
        element_index: usize,
        expected: u8,
        actual: u8,
        span: Span,
    },
    InvalidCodeValue {
        tag: String,
        element_index: usize,
        value: String,
        code_list: String,
        span: Span,
        suggestion: Option<&'static str>,
    },
    MissingSegment {
        tag: String,
        expected_position: String,
    },
    QualifierMismatch {
        tag: String,
        actual: String,
        expected: String,
        span: Span,
    },
    ConditionalRequirementNotMet {
        tag: String,
        element_index: usize,
        condition: String,
        span: Span,
    },
    ValidationErrors {
        error_count: usize,
        report: Box<ValidationReport>,
    },
    SegmentTooLong {
        offset: usize,
        limit: usize,
    },
    UnexpectedMessageType {
        message_type: String,
    },
    InterchangeTooLarge {
        count: u64,
    },
    InvalidEventSequence {
        message: &'static str,
    },
    InvalidElementPosition,
    IncompatibleReleaseScopes {
        current: String,
        incoming: String,
    },
    InvalidFieldValue {
        tag: String,
        element_index: usize,
        value: String,
    },
    UnexpectedDataToken {
        offset: usize,
    },
    UnrecognisedSyntaxIdentifier(String),
    DuplicateReference {
        tag: String,
        reference: String,
        span: Span,
    },
    UnknownDataElement {
        tag: String,
        data_element: String,
    },
    AmbiguousDataElement {
        tag: String,
        data_element: String,
    },
    SegmentLayoutMismatch {
        expected: String,
        actual: String,
    },
}

All errors produced by edifact-rs.

Positional data

Two kinds of position information appear in this enum, and the distinction is deliberate:

• offset: usize — a single byte position in the input stream. Used by the lexical variants (UnexpectedEof, InvalidDelimiter, InvalidText, InvalidReleaseSequence, SegmentTooLong, UnexpectedDataToken), where the fault is a point in the byte stream and no meaningful end position exists.
• span: Span — a half-open byte range. Used by every variant produced while validating an already-parsed Segment, where the exact source range is known. A ValidationIssue built from such an error carries the full range, so miette and LSP tooling can underline the offending segment rather than place a zero-width caret.

Use span.start when only the start position is needed.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

UnexpectedEof

Unexpected end of input while parsing.

This typically occurs when a segment terminator or expected delimiter is not found before the end of the input stream.

Fields

offset: usize

Byte offset where the parser exhausted input.

InvalidDelimiter

Invalid byte encountered in a delimiter context.

Delimiters must be precisely ASCII characters from the UNA service string advice. Any other byte is invalid in delimiter position.

Fields

byte: u8

Unexpected delimiter byte.

offset: usize

Byte offset where the delimiter was observed.

InvalidText

Invalid UTF-8 sequence in parsed text.

While EDIFACT operates on bytes, segments and elements are expected to contain valid UTF-8 text. Non-UTF-8 sequences are rejected at parse time.

Fields

offset: usize

Byte offset where invalid UTF-8 text starts.

InvalidReleaseSequence

Invalid release-character escape sequence in parsed text.

The release character (? by default) must be followed by one escaped byte. A trailing release character without a following byte is malformed.

Fields

offset: usize

Byte offset of the dangling release character.

MessageCountMismatch

UNZ interchange message count does not match the number of UNH/UNT pairs found.

The UNZ segment declares the number of messages in the interchange, but the actual number of UNH/UNT pairs observed differs.

Fields

expected: u32

Message count declared in the UNZ segment.

actual: u32

Actual number of UNH/UNT pairs observed.

SegmentCountMismatch

UNT segment count does not match the actual number of segments in the message.

The UNT segment declares the number of segments in the message (including UNH/UNT), but the actual count differs.

Fields

expected: u32

Segment count declared in the UNT segment.

actual: u32

Actual number of segments observed.

message_ref: String

Message reference from the UNH segment.

InvalidSegmentTag(String)

Invalid or malformed segment tag.

Segment tags must be exactly 3 ASCII uppercase letters.

InvalidUna

Invalid UNA service string advice.

If present, the UNA segment must be exactly 9 bytes: "UNA" followed by 6 service characters. The five active characters (element_sep, component_sep, decimal_mark, release_char, and segment_term) must all be mutually distinct and printable, non-alphanumeric ASCII. The repetition separator (UNA byte 7) is validated on the same terms unless it is a space, the conventional “not used” sentinel.

MissingRequiredElement

Missing required element in a segment.

Certain segments require specific elements to be present. This error indicates a mandatory element was not found.

Fields

tag: String

Segment tag containing the missing element.

element_index: usize

Zero-based required element index.

MissingRequiredComponent

Missing required component in a composite element.

The element is present, but the required component at the given index is absent or empty.

Fields

tag: String

Segment tag containing the composite element.

element_index: usize

Zero-based element index of the composite.

component_index: usize

Zero-based component index that was absent.

InvalidUtf8

Output serialization produced invalid UTF-8.

This is an internal consistency error; the writer should never produce non-UTF-8 output. If this occurs, it indicates a bug in the serialization logic.

Io(IoError)

I/O error from reading or writing.

InvalidSegmentForMessage

Segment is not valid for the current message type.

Structural validation found a segment that should not appear in this message.

Fields

tag: String

Segment tag that is not allowed for the message type.

message_type: String

Message type used for structural validation.

span: Span

Byte range of the offending segment tag.

InvalidElementCount

Element count in segment exceeds or falls short of directory definition.

Validation against directory metadata found an element count mismatch.

Fields

tag: String

Segment tag with wrong arity.

min: usize

Minimum allowed element count.

max: usize

Maximum allowed element count.

actual: usize

Actual element count found.

span: Span

Byte range of the offending segment.

InvalidComponentCount

Component count in a composite element is invalid.

A composite data element does not have the expected number of components.

Fields

tag: String

Segment tag containing the composite.

element_index: usize

Zero-based element index of the composite.

expected: u8

Expected component count.

actual: u8

Actual component count found.

span: Span

Byte range of the offending composite element.

InvalidCodeValue

Code-list value is not valid.

The value appears in a field that should contain a code from a specific code list, but the value is not in that code list.

Fields

tag: String

Segment tag containing the invalid value.

element_index: usize

Zero-based element index containing the invalid code.

value: String

Invalid code value observed.

code_list: String

Data element code list identifier.

span: Span

Byte range of the offending value.

suggestion: Option<&'static str>

Optional remediation suggestion from the code-list lookup function.

MissingSegment

A required segment is missing from the message.

Structural validation found that a mandatory segment is absent.

Fields

tag: String

Missing segment tag.

expected_position: String

Human-readable position hint.

QualifierMismatch

Qualifier does not match expected value for segment.

A qualified segment (e.g., NAD+MS) has a qualifier that does not match expected.

Fields

tag: String

Segment tag whose qualifier mismatched.

actual: String

Actual qualifier found.

expected: String

Expected qualifier value.

span: Span

Byte range of the offending segment.

ConditionalRequirementNotMet

Conditional requirement not met.

A segment or element is conditionally required based on another element’s value, but the condition was not satisfied.

Fields

tag: String

Segment tag that violated a conditional rule.

element_index: usize

Zero-based element index governed by the condition.

condition: String

Condition text describing the rule.

span: Span

Byte range of the offending segment.

ValidationErrors

Validation failed and the full ValidationReport is preserved.

Returned by validation helpers when errors are found. Provides programmatic access to all issues, warnings, and infos.

Example

match my_fn() {
    Err(EdifactError::ValidationErrors { report, .. }) => {
        for issue in report.errors() {
            eprintln!("{}", issue);
        }
    }
    other => { /* ... */ }
}

Fields

error_count: usize

Number of error-severity issues in the report.

report: Box<ValidationReport>

Full report with all errors, warnings, and infos.

SegmentTooLong

Segment exceeded the configured maximum byte length.

Returned by reader-based parsers when an unterminated segment accumulates more bytes than the configured max_segment_bytes limit in ReaderConfig. This prevents resource exhaustion on adversarially crafted or truncated input that never emits a segment terminator.

Fields

offset: usize

Byte offset where the overlong segment started.

limit: usize

Configured maximum segment byte length.

UnexpectedMessageType

No handler was registered in crate::MessageDispatch for this message type.

Returned by crate::MessageDispatch::dispatch when the message-type extracted from the UNH segment does not match any registered handler and no fallback was configured.

Fields

message_type: String

The unhandled message type string from the UNH segment.

InterchangeTooLarge

An interchange or message contains more segments or messages than can be represented in a u32 counter (> 4 294 967 295).

This is effectively unreachable in practice — no real-world EDIFACT interchange has billions of segments — but the parser returns this error rather than silently saturating or wrapping the counter.

Fields

count: u64

The count that could not be represented as u32.

InvalidEventSequence

An crate::EventEmitter received events in an invalid sequence.

This indicates a programming error in the caller’s serialization code: for example, emitting an crate::EdifactEvent::Element without a prior crate::EdifactEvent::StartSegment, or emitting crate::EdifactEvent::ComponentElement without a preceding crate::EdifactEvent::Element.

Fields

message: &'static str

Description of the protocol violation.

InvalidElementPosition

An crate::OwnedElementRef has position = 0, which is never valid.

Element positions are one-based: position 1 refers to the first element slot. Position 0 is reserved and invalid. Use crate::OwnedElementRef::try_new to get a Result instead of a panic.

IncompatibleReleaseScopes

Two crate::ProfileRulePack values with incompatible release scopes were composed.

When composing packs via crate::ProfileRulePack::extend_from or crate::ProfileRulePack::merge_with_override, both packs must either share the same release scope or at most one may carry a scope.

Fields

current: String

Release scope of the pack being composed into.

incoming: String

Release scope of the pack being composed in.

InvalidFieldValue

A field value failed semantic validation (e.g. wrong format, out-of-range).

Distinct from InvalidCodeValue which is for code-list membership checks. Use this variant when a free-text or numeric field contains a value that is structurally invalid for its purpose.

Fields

tag: String

Segment tag that contains the invalid field.

element_index: usize

Zero-based element index of the invalid field.

value: String

The invalid value that was observed.

UnexpectedDataToken

A data or component element token appeared before the first segment tag.

EDIFACT syntax requires that every data element follows a segment tag. A data element token encountered before any tag (e.g. after a stray separator at the start of the stream) is a protocol violation.

Unlike stray segment terminators (which are tolerated as blank lines), stray data tokens indicate encoding corruption or a partial write.

Fields

offset: usize

Byte offset of the stray token.

UnrecognisedSyntaxIdentifier(String)

The interchange syntax identifier (UNB DE 0001) is not a recognised ISO 9735-1 value.

Valid syntax identifiers are: UNOA, UNOB, UNOC, UNOD, UNOE, UNOF, and KECA (Korean EDI Centre A). Any other value indicates a non-standard generator or a corrupted UNB header.

DuplicateReference

A control reference was reused within the scope that requires it to be unique.

ISO 9735-1 requires the message reference number (UNH DE 0062) to be unique within an interchange, and the group reference number (UNG DE 0048) to be unique within an interchange. Duplicates make a message unaddressable: a receiver keying on the reference silently processes one occurrence and drops the rest.

Fields

tag: String

Segment tag that carries the duplicated reference (UNH or UNG).

reference: String

The reference value that appeared more than once.

span: Span

Byte range of the duplicate occurrence.

UnknownDataElement

A UN/EDIFACT data element code was not found in the segment definition.

Produced by the code-addressed accessors (Segment::value_by_code and friends) when the requested data element identifier does not appear anywhere in the supplied SegmentLayout. This is the error that turns a mistyped or stale DE reference into a loud failure instead of a silent off-by-one read of the wrong element.

Fields

tag: String

Segment tag whose definition was searched.

data_element: String

The data element identifier that was not found.

AmbiguousDataElement

A UN/EDIFACT data element code appears more than once in a segment definition.

Code-addressed access requires an unambiguous target. When a directory genuinely repeats a code (e.g. the same DE used at two positions), address it positionally with Segment::element_str or split the definition.

Fields

tag: String

Segment tag whose definition was searched.

data_element: String

The data element identifier that resolved to multiple positions.

SegmentLayoutMismatch

A SegmentLayout was applied to a segment with a different tag.

Passing the NAD definition to a DTM segment would resolve codes against the wrong table, which is exactly the class of mistake that code-addressed access exists to prevent — so it is rejected up front.

Fields

expected: String

Tag the layout describes.

actual: String

Tag of the segment the layout was applied to.

Implementations

impl EdifactError

pub const fn stable_code(&self) -> &'static str

Stable diagnostic code for this error variant.

pub fn recovery_hint(&self) -> Option<&'static str>

Stable recovery hint for common malformed input and validation cases.

Trait Implementations

impl Debug for EdifactError

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

Formats the value using the given formatter.

impl Diagnostic for EdifactError

Available on crate feature diagnostics only.

fn code<'a>(&'a self) -> Option<Box<dyn Display + 'a>>

Unique diagnostic code that can be used to look up more information about this Diagnostic. Ideally also globally unique, and documented in the toplevel crate’s documentation for easy searching. Rust path format (foo::bar::baz) is recommended, but more classic codes like E0123 or enums will work just fine.

fn severity(&self) -> Option<Severity>

Diagnostic severity. This may be used by ReportHandlers to change the display format of this diagnostic.

fn help<'a>(&'a self) -> Option<Box<dyn Display + 'a>>

Additional help text related to this Diagnostic. Do you have any advice for the poor soul who’s just run into this issue?

fn url<'a>(&'a self) -> Option<Box<dyn Display + 'a>>

URL to visit for a more detailed explanation/help about this Diagnostic.

fn source_code(&self) -> Option<&dyn SourceCode>

Source code to apply this Diagnostic’s Diagnostic::labels to.

fn labels(&self) -> Option<Box<dyn Iterator<Item = LabeledSpan> + '_>>

Labels to apply to this Diagnostic’s Diagnostic::source_code

fn related<'a>( &'a self, ) -> Option<Box<dyn Iterator<Item = &'a dyn Diagnostic> + 'a>>

Additional related Diagnostics.

fn diagnostic_source(&self) -> Option<&dyn Diagnostic>

The cause of the error.

impl Display for EdifactError

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

Formats the value using the given formatter.

impl Error for EdifactError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<Error> for EdifactError

fn from(e: Error) -> Self

Converts to this type from the input type.

impl From<IoError> for EdifactError

fn from(source: IoError) -> Self

Converts to this type from the input type.

impl PartialEq for EdifactError

fn eq(&self, other: &EdifactError) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for EdifactError