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,
        offset: usize,
    },
    InvalidElementCount {
        tag: String,
        min: usize,
        max: usize,
        actual: usize,
        offset: usize,
    },
    InvalidComponentCount {
        tag: String,
        element_index: usize,
        expected: u8,
        actual: u8,
        offset: usize,
    },
    InvalidCodeValue {
        tag: String,
        element_index: usize,
        value: String,
        code_list: String,
        offset: usize,
        suggestion: Option<&'static str>,
    },
    MissingSegment {
        tag: String,
        expected_position: String,
    },
    QualifierMismatch {
        tag: String,
        actual: String,
        expected: String,
        offset: usize,
    },
    ConditionalRequirementNotMet {
        tag: String,
        element_index: usize,
        condition: String,
        offset: usize,
    },
    ValidationFailed {
        error_count: usize,
        first_message: String,
    },
    SegmentTooLong {
        offset: usize,
        limit: usize,
    },
}

All errors produced by edifact-rs.

Error Variants

All variants that include an offset carry byte position information from the input stream. This data enables precise error location reporting in diagnostics.

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.

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.

offset: usize

Segment tag byte offset.

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.

offset: usize

Segment start byte offset.

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.

offset: usize

Segment start byte offset.

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.

offset: usize

Segment start byte offset.

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.

offset: usize

Segment start byte offset.

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.

offset: usize

Segment start byte offset.

ValidationFailed

Aggregate validation failure from strict validation mode.

Fields

error_count: usize

Number of collected validation issues.

first_message: String

First issue message for quick context.

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.

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for EdifactError