Struct SegmentDefinition 

#[non_exhaustive]
pub struct SegmentDefinition {
    pub tag: &'static str,
    pub name: &'static str,
    pub elements: &'static [ElementRef],
}

Definition of an EDIFACT segment (tag + element structure).

Construct with SegmentDefinition::new rather than a struct literal, so that future fields (max repeat, description, …) are not a breaking change.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

tag: &'static str

Segment tag.

name: &'static str

Human-readable segment name.

elements: &'static [ElementRef]

Ordered element definitions.

Implementations

impl SegmentDefinition

pub const fn new( tag: &'static str, name: &'static str, elements: &'static [ElementRef], ) -> Self

Create a segment definition.

const so directory tables can still be built at compile time despite the #[non_exhaustive] attribute blocking external struct literals.

pub const fn code_positions(&self, data_element: &str) -> usize

Number of positions in this definition that carry data_element.

0 means unknown, 1 means unambiguously addressable, and anything larger means the identifier is repeated and cannot be code-addressed. const, so a derive macro can assert on it at compile time.

Example

static NAD: SegmentDefinition = SegmentDefinition::new("NAD", "Name and address", E);
const _: () = assert!(NAD.code_positions("3035") == 1);

pub const fn element_slot(&self, data_element: &str) -> usize

Zero-based element index for data_element, resolved at compile time.

Panics

Panics when the identifier is unknown or appears at more than one position. In a const context — which is how the derive macro uses it — that panic is a compile error, so a mistyped identifier can never reach runtime. Guard with code_positions for a message that names the offending field.

pub const fn component_slot(&self, data_element: &str) -> usize

Zero-based component index for data_element, resolved at compile time.

Returns 0 when the identifier names a data element rather than a component inside a composite — component 0 is the first (and for a simple element, only) component, so the same accessor works for both shapes.

Panics

Panics when the identifier is unknown or appears at more than one position; see element_slot.

pub const fn code_is_component(&self, data_element: &str) -> bool

true when data_element names a component inside a composite rather than a data element of the segment.

Lets a caller — the derive macro, in practice — pick the right “missing required” error variant without a second lookup: EdifactError::MissingRequiredComponent rather than EdifactError::MissingRequiredElement. component_slot alone cannot answer this, because a code naming the first component of a composite also resolves to component index 0.

Returns false for an unknown identifier; pair with code_positions when that case matters.

Trait Implementations

impl Debug for SegmentDefinition

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

Formats the value using the given formatter.

impl SegmentLayout for SegmentDefinition

fn layout_tag(&self) -> &str

The segment tag this layout describes (e.g. "NAD").

fn resolve_code(&self, data_element: &str) -> Result<ElementPath, EdifactError>

Resolve a UN/EDIFACT data element identifier to a position.