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 element_span(&self, n: usize) -> Option<Span>

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

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

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<'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> Eq for Segment<'a>

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