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,
        span: Span,
    },
    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,
    },
    LimitExceeded {
        limit: &'static str,
        max: u64,
    },
    RepetitionSeparatorNotDeclared,
    NonFiniteNumber {
        value: String,
    },
    CharacterNotInRepertoire {
        charset: &'static str,
        character: char,
        offset: usize,
    },
    CharacterRepertoireMismatch {
        declared: String,
        writer: &'static str,
    },
    UnsupportedCharset {
        syntax_identifier: String,
    },
    EmptyInterchange {
        control_ref: String,
    },
    EmptyMessage {
        message_ref: String,
        span: Span,
    },
    PackageNotSupported {
        tag: String,
        span: Span,
    },
    BlankDataElementValue {
        tag: String,
        element_index: usize,
        component_index: usize,
        span: Span,
    },
    SegmentWithoutDataElements {
        tag: String,
        span: Span,
    },
    TooManyRepetitions {
        tag: String,
        element_index: usize,
        max: u8,
        actual: usize,
        span: Span,
    },
    InvalidCharacterType {
        tag: String,
        element_index: usize,
        component_index: usize,
        repr: String,
        value: String,
        span: Span,
    },
    DataElementTooLong {
        tag: String,
        element_index: usize,
        component_index: usize,
        repr: String,
        actual: usize,
        span: Span,
    },
    DataElementTooShort {
        tag: String,
        element_index: usize,
        component_index: usize,
        repr: String,
        actual: usize,
        span: Span,
    },
    TrailingSeparator {
        tag: String,
        element_index: Option<usize>,
        span: Span,
    },
    GroupsAndMessagesMixed {
        span: Span,
    },
    InsignificantCharacters {
        tag: String,
        element_index: usize,
        component_index: usize,
        kind: Insignificant,
        span: Span,
    },
    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.

span: Span

Byte range of the offending UNT.

This is what places the finding on the message rather than on the interchange — a CONTRL built from the report reports it on that message’s UCM, and a rendered diagnostic underlines the trailer that got the count wrong.

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 active ones — component separator, element separator, release character, segment terminator, and the repetition separator when it is not the “not used” space — must all be mutually distinct and printable, non-alphanumeric ASCII.

The decimal mark is not checked: ISO 9735-1 Annex B says the character in that position “shall be ignored by the recipient”, and it is the one position where the standard permits a space.

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 S001 DE 0001) names no defined character repertoire.

DE 0001 is UN followed by a two-character repertoire code, so the defined values are UNOA through UNOK, UNOX, UNOY, and KECA (Korean EDI Centre A). Anything else is a non-standard generator or a corrupted UNB.

A value that is defined but that this crate cannot decode is UnsupportedCharset instead — the two say different things about whose problem it is.

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.

LimitExceeded

A configured ReaderConfig resource limit was exceeded.

Raised by the parsing iterators when the input carries more segments, messages, or bytes than the caller allowed. The limit is reported rather than silently applied: a budget that ends the iterator without an error is indistinguishable from a clean end of input, so the caller would accept a truncated interchange as complete.

SegmentTooLong covers the per-segment size guard; this variant covers the whole-input budgets.

Fields

limit: &'static str

Name of the limit that tripped: "max_segments", "max_messages", or "max_input_bytes".

max: u64

The configured ceiling.

RepetitionSeparatorNotDeclared

A repeating data element was written under a service string advice that declares no repetition separator.

ISO 9735-1 §8.6 repetitions can only be expressed when UNA position 7 carries a real separator. With the space “not used” sentinel there is no byte to write between occurrences, and joining them anyway would emit output that reads back as a single occurrence — silent data corruption. Construct the writer with Writer::with_una and a service string advice whose repetition_sep is set.

NonFiniteNumber

A non-finite float was handed to a numeric serializer.

ISO 9735-1 §10 admits the ISO 6093 numeric representations — digits, an optional minus sign, a decimal mark, an exponent — and nothing else. There is no representation for NaN or infinity, and Display would emit NaN / inf, text no receiver can parse and that the crate’s own reader would hand back as a string.

Fields

value: String

The offending value, formatted for the message.

CharacterNotInRepertoire

A character cannot be represented in the interchange’s declared repertoire.

The UNB S001 DE 0001 syntax identifier names the character repertoire the payload is written in (UNOA, UNOC, …). Writing a character outside it produces bytes the receiver decodes as something else — or as nothing at all — so the writer refuses instead.

Also raised by Charset::encode.

Fields

charset: &'static str

The syntax identifier of the repertoire that rejected the character.

character: char

The offending character.

offset: usize

Byte offset of the character within the value it appeared in.

CharacterRepertoireMismatch

A UNB was written declaring a repertoire other than the writer’s own.

A header that names UNOA while the body goes out as ISO 8859-1 is unreadable at the far end in exactly the way that is hardest to diagnose, so Writer::begin_interchange refuses the combination rather than emitting it.

Fields

declared: String

Syntax identifier passed to begin_interchange.

writer: &'static str

Repertoire the writer was bound to with Writer::with_charset.

UnsupportedCharset

The interchange declares a character repertoire this crate cannot decode.

UNOX (ISO 2022 code extension) and KECA (Korean) are stateful or multi-byte in ways that break the byte-level delimiter scanning every other repertoire allows. They are reported rather than silently mis-decoded.

Fields

syntax_identifier: String

The UNB S001 DE 0001 value that could not be handled.

EmptyInterchange

An interchange carries neither a message nor a group.

ISO 9735-1 §7.1: an interchange “shall contain at least one group, or one message or one package”. A bare UNB/UNZ pair is a delivery that says nothing, and because UNZ+0 makes the control count agree with the (absent) content, no count check can catch it.

Fields

control_ref: String

Interchange control reference (UNB DE 0020) of the empty interchange.

EmptyMessage

A message carries no segment between its header and trailer.

ISO 9735-1 §7.3: a message “shall be started and identified by a message header, shall be terminated by a message trailer, and shall contain at least one additional segment”.

Fields

message_ref: String

Message reference number (UNH DE 0062) of the empty message.

span: Span

Byte range of the offending UNH.

PackageNotSupported

The interchange carries a package (UNO…UNP), which this crate does not tokenize.

A package wraps an arbitrary object — ISO 9735-1 §7.9, elaborated by ISO 9735-8 — whose bytes are not EDIFACT-encoded and whose length is declared in UNO S022 DE 0810. Feeding those bytes to a tokenizer that scans for delimiters produces nonsense, so the package is reported instead. Split the object out of the byte stream using the declared length before parsing the remainder.

Fields

tag: String

The package segment encountered: UNO or UNP.

span: Span

Byte range of the offending segment.

BlankDataElementValue

A data element value consists only of spaces.

ISO 9735-1 §9.3: “A data element value containing only space(s) shall not be allowed.” Trailing spaces are insignificant and must be suppressed (§9.1), so a value that is nothing but spaces is an element that should have been omitted — and a receiver comparing it against a code list, a reference, or a previous message will not treat it as absent.

Fields

tag: String

Segment tag containing the blank value.

element_index: usize

Zero-based element index.

component_index: usize

Zero-based component index.

span: Span

Byte range of the offending value.

SegmentWithoutDataElements

A segment carries nothing but its tag.

ISO 9735-1 §7.5: “A segment shall contain at least one data element in addition to the segment tag.” §8.5 adds that a conditional segment whose only content is the tag “shall be omitted in its entirety” — so ABC' is either a mandatory segment that lost its data or a conditional one that should not have been sent.

Fields

tag: String

The offending segment tag.

span: Span

Byte range of the offending segment.

TooManyRepetitions

A data element occurred more times than its definition allows.

ISO 9735-1 §7.5: “Each stand-alone or composite data element’s position, status and maximum number of occurrences within the segment structure shall be stated in the segment specification.” Exceeding the stated maximum is a structural violation, reported by CONTRL as code 35.

Fields

tag: String

Segment tag carrying the over-repeated element.

element_index: usize

Zero-based element index.

max: u8

Maximum occurrences the definition allows.

actual: usize

Occurrences actually present.

span: Span

Byte range of the offending element.

InvalidCharacterType

A value’s characters do not match its declared representation class.

A directory types every data element a (alphabetic), n (numeric), or an (alphanumeric). ISO 9735-1 §10 fixes what “numeric” admits: digits, an optional minus, a decimal mark, and an exponent — and explicitly not the space character or a plus sign. Reported by CONTRL as code 37.

Fields

tag: String

Segment tag containing the value.

element_index: usize

Zero-based element index.

component_index: usize

Zero-based component index.

repr: String

The declared representation, e.g. n..6.

value: String

The offending value.

span: Span

Byte range of the offending value.

DataElementTooLong

A value is longer than its declared representation allows.

Length is counted in characters, not bytes (ISO 9735-1 §6), and for a numeric value excludes the sign, the decimal mark, and the exponent (§10). Reported by CONTRL as code 39.

Fields

tag: String

Segment tag containing the value.

element_index: usize

Zero-based element index.

component_index: usize

Zero-based component index.

repr: String

The declared representation, e.g. an..35.

actual: usize

The measured character count.

span: Span

Byte range of the offending value.

DataElementTooShort

A value is shorter than its declared fixed-length representation.

Only a fixed-length representation (n8, a1) has a minimum above one; a variable one (an..35) is satisfied by any non-empty value. Reported by CONTRL as code 40.

Fields

tag: String

Segment tag containing the value.

element_index: usize

Zero-based element index.

component_index: usize

Zero-based component index.

repr: String

The declared representation, e.g. n8.

actual: usize

The measured character count.

span: Span

Byte range of the offending value.

TrailingSeparator

A segment or composite ends in separators that carry no value.

ISO 9735-1 §8.7.1: “If one or more non-repeating composite data elements or stand-alone data elements at the end of a segment are omitted, the data element separators which would normally follow them shall also be omitted.” §8.7.2 says the same for components at the end of a composite.

BGM+220+' and DTM+137:20260101:' are therefore both malformed, and a receiver that trims them is being generous rather than correct. Reported by CONTRL as code 45.

Fields

tag: String

Segment tag carrying the trailing separator.

element_index: Option<usize>

Some(index) when the trailing separators close that element’s composite; None when they close the segment itself.

span: Span

Byte range of the offending segment or element.

GroupsAndMessagesMixed

An interchange mixes groups with ungrouped messages.

ISO 9735-1 §7.1 lists what an interchange may contain, and every entry is exclusive: messages, or packages, or groups containing them — never a group alongside a bare message. A message outside every group has no group to be counted in, so UNZ DE 0036 cannot describe the interchange at all. Reported by CONTRL as code 30.

Fields

span: Span

Byte range of the segment that revealed the mix.

InsignificantCharacters

A value carries characters ISO 9735-1 §9.1 requires to be suppressed.

§9.1: “In variable length numeric data elements, leading zeroes shall be suppressed… In variable length alphabetic and alphanumeric data elements, trailing spaces shall be suppressed.”

Both are artefacts of a fixed-width source record copied into a variable-length field. The value is still readable, so this is a warning — but a receiver comparing 007 against the code 7, or "ACME " against "ACME", will not match them.

Fields

tag: String

Segment tag containing the value.

element_index: usize

Zero-based element index.

component_index: usize

Zero-based component index.

kind: Insignificant

Which rule of §9.1 was violated.

span: Span

Byte range of the offending value.

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 severity(&self) -> Option<Severity>

Mirrors the severity the validation pipeline assigns.

The two must agree: a miette render that calls a control-reference mismatch a warning while ValidationReport files it as an error tells the operator and the program two different things about the same interchange. crate::ValidationReport is the source of truth, and this delegates to it.

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