Struct Segment 

pub struct Segment<'a> {
    pub tag: &'a str,
    pub span: Span,
    pub tag_span: Span,
    pub elements: Vec<Element<'a>>,
}

A single EDIFACT segment, borrowing its data from the source input.

Fields

tag: &'a str

Segment tag, usually three uppercase letters.

span: Span

Span covering the whole segment payload.

tag_span: Span

Span covering only the segment tag.

elements: Vec<Element<'a>>

Segment elements in positional order.

Implementations

impl<'a> Segment<'a>

pub fn new(tag: &'a str, elements: Vec<Element<'a>>) -> Self

Construct a segment with default spans.

pub fn get_element(&self, n: usize) -> Option<&Element<'a>>

Return the element at position n (0-indexed), if it exists.

pub fn element_str(&self, n: usize) -> Option<&str>

Shorthand: get component 0 of element n — the most common access pattern.

pub fn component_str(&self, elem: usize, comp: usize) -> Option<&str>

Get component comp of element elem (both 0-based), or None if absent.

Mirrors OwnedSegment::component_str, eliminating the need to chain get_element(elem)?.get_component(comp) in rule closures.

pub fn element_span(&self, n: usize) -> Option<Span>

Return the byte span of the element at position n, if it exists.

pub fn value_at(&self, path: ElementPath) -> Option<&str>

Read the value at an already-resolved ElementPath.

Use this when the same path is reused across many segments — resolve once with SegmentLayout::resolve_code, then read without repeating the lookup.

pub fn span_at(&self, path: ElementPath) -> Option<Span>

Byte span of the value at an already-resolved ElementPath.

pub fn value_by_code<L: SegmentLayout + ?Sized>( &self, layout: &L, data_element: &str, ) -> Result<Option<&str>, EdifactError>

Read a value by its UN/EDIFACT data element identifier.

Positional access (seg.element_str(4)) fails silently when the index is wrong: it reads a different, usually still-plausible value. Code-addressed access cannot — a stale or mistyped identifier is a EdifactError::UnknownDataElement, checked against the directory.

Ok(None) means the identifier is valid for this segment but the value is absent from this instance, which is the normal state for a conditional element.

Performance

Each call scans the layout for the identifier. That is a handful of short string comparisons and fine for one-off reads, but when pulling the same identifier out of many segments, resolve once with SegmentLayout::resolve_code and read with value_at.

Example

use edifact_rs::{ComponentRef, ElementRef, SegmentDefinition, Status};

static C507: &[ComponentRef] = &[
    ComponentRef::new(1, "2005", Status::Mandatory),
    ComponentRef::new(2, "2380", Status::Conditional),
    ComponentRef::new(3, "2379", Status::Conditional),
];
static DTM_ELEMENTS: &[ElementRef] =
    &[ElementRef::composite(1, "C507", Status::Mandatory, 1, C507)];
static DTM: SegmentDefinition =
    SegmentDefinition::new("DTM", "Date/time/period", DTM_ELEMENTS);

let segments: Vec<_> = edifact_rs::from_bytes(b"DTM+137:20260101:102'")
    .collect::<Result<Vec<_>, _>>()?;
let dtm = &segments[0];

assert_eq!(dtm.value_by_code(&DTM, "2380")?, Some("20260101"));
// A data element that this segment does not define is a hard error,
// not a wrong-but-quiet read.
assert!(dtm.value_by_code(&DTM, "3055").is_err());

Errors

Returns EdifactError::SegmentLayoutMismatch when layout describes a different segment tag, EdifactError::UnknownDataElement when the identifier is not in the definition, and EdifactError::AmbiguousDataElement when it appears more than once.

pub fn span_by_code<L: SegmentLayout + ?Sized>( &self, layout: &L, data_element: &str, ) -> Result<Option<Span>, EdifactError>

Byte span of a value addressed by its UN/EDIFACT data element identifier.

Use this to attach a precise Span to a ValidationIssue without hand-counting indices.

Errors

As value_by_code.

pub fn element_by_code<L: SegmentLayout + ?Sized>( &self, layout: &L, data_element: &str, ) -> Result<Option<&Element<'a>>, EdifactError>

Return the whole Element addressed by a data element identifier.

When the identifier names a component inside a composite, the enclosing composite element is returned.

Errors

As value_by_code.

Trait Implementations

impl<'a> Clone for Segment<'a>

fn clone(&self) -> Segment<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Segment<'a>

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

Formats the value using the given formatter.

impl<'a> Eq for Segment<'a>

impl<'a> From<Segment<'a>> for OwnedSegment

fn from(value: Segment<'a>) -> Self

Converts to this type from the input type.

impl<'a> PartialEq for Segment<'a>

fn eq(&self, other: &Segment<'a>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<'s, 'd> SegmentAccessor<'s> for Segment<'d>

where 'd: 's,

fn get_element(&'s self, idx: usize) -> Option<&'s str>

Get non-empty element text at index idx.

fn get_component(&'s self, elem: usize, comp: usize) -> Option<&'s str>

Get non-empty component text at element/component indexes.

fn get_composite(&'s self, idx: usize) -> Option<CompositeElement<'s>>

Get a composite wrapper for element idx.

fn text_element(&'s self, idx: usize) -> Result<&'s str, EdifactError>

Get required non-empty element text.

fn optional_element(&'s self, idx: usize) -> Option<&'s str>

Get optional non-empty element text.

fn code_element<T: FromStr>(&'s self, idx: usize) -> Result<T, EdifactError>

Parse a typed code value from a required element.

fn required_composite( &'s self, elem: usize, comp: usize, ) -> Result<&'s str, EdifactError>

Get required non-empty composite component.

fn repeating_components_iter( &'s self, elem: usize, start_idx: usize, count: usize, ) -> impl Iterator<Item = Result<&'s str, EdifactError>> + 's

Iterate over count required components starting at start_idx from element elem.

fn repeating_components( &'a self, elem: usize, start_idx: usize, count: usize, ) -> Result<Vec<&'a str>, EdifactError>

Get count required components starting at start_idx from element elem.

impl<'a> StructuralPartialEq for Segment<'a>