Struct Element 

#[non_exhaustive]
pub struct Element<'a> {
    pub span: Span,
    pub components: Components<'a>,
    pub repeats: Vec<Components<'a>>,
}

A data element, which may have one or more component values.

#[non_exhaustive]: build one with Element::of (plus and_repeat / with_span) rather than a struct literal.

Uses SmallVec with an inline capacity of 4 to avoid heap allocation for the common case (≤ 4 components). Each entry is a (value, span) pair, guaranteeing that the component string and its byte span stay in sync. A value that contained a release-character sequence is stored as Cow::Owned; everything else borrows from the input.

Repetition (ISO 9735-1 §8.6)

components holds the first occurrence, which is the only one for every interchange that does not declare a repetition separator — that is, virtually all of them. Further occurrences land in repeats; read them together with repetitions.

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.

span: Span

Span covering the whole element, including every occurrence.

components: Components<'a>

Components of the first occurrence, in positional order.

repeats: Vec<Components<'a>>

Second and subsequent occurrences of this data element.

Empty — and therefore unallocated — unless the interchange declares a repetition separator and the element actually repeats.

Implementations

impl<'a> Element<'a>

pub fn of<S>(components: &[S]) -> Self

where S: Into<Cow<'a, str>> + Clone,

Build a data element from its component values.

Accepts anything that converts to Cow<'a, str>, so both string literals and owned Strings work:

use edifact_rs::{Element, OwnedElement};

let borrowed = Element::of(&["4000001000002", "", "9"]);
let owned: OwnedElement = Element::of(&[String::from("BY")]);

assert_eq!(borrowed.get_component(2), Some("9"));
assert_eq!(owned.get_component(0), Some("BY"));

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

Return the component at position n (0-indexed) of the first occurrence.

pub fn component_or_empty(&self, n: usize) -> &str

Return the component at position n, or "" if absent.

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

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

pub fn components(&self) -> impl Iterator<Item = &str>

Iterate over the component values of the first occurrence.

pub fn repeat_count(&self) -> usize

Number of occurrences of this data element — always at least 1.

pub fn repetition(&self, n: usize) -> Option<&[(Cow<'a, str>, Span)]>

Components of occurrence n (0-indexed), if it exists.

pub fn repetitions(&self) -> impl Iterator<Item = &[(Cow<'a, str>, Span)]>

Iterate over every occurrence of this element, the first one included.

Example

// `UNA` byte 7 declares `*` as the repetition separator.
let segments: Vec<_> = edifact_rs::from_bytes(b"UNA:+.?*'RFF+ON:1*ON:2'")
    .collect::<Result<Vec<_>, _>>()?;
let rff = segments[0].get_element(0).unwrap();

let refs: Vec<&str> = rff
    .repetitions()
    .map(|components| components[1].0.as_ref())
    .collect();
assert_eq!(refs, ["1", "2"]);

pub fn repeated_component(&self, n: usize) -> impl Iterator<Item = &str>

Read component n from every occurrence of this element (ISO 9735-1 §8.6).

One item per occurrence, using "" where an occurrence omits the component: §8.7.3 makes occurrence position significant, so dropping the empty ones would shift every later value into the wrong slot.

pub fn with_span(self, span: Span) -> Self

Set the span covering this element.

Parsed elements carry real spans; hand-built ones default to Span::default and only need this when the caller is synthesising input for diagnostics.

pub fn and_repeat<S>(self, components: &[S]) -> Self

where S: Into<Cow<'a, str>> + Clone,

Append a further occurrence of this data element (ISO 9735-1 §8.6).

Useful when building segments for Writer::write_segment; the writer joins occurrences with the active repetition separator.

pub fn offset_in_place(&mut self, delta: usize)

Shift every stored span by delta bytes, in place.

Every occurrence is shifted, not just the first: the reader parses each segment from a zero-based slice and then rebases it onto the stream, so an occurrence left unshifted points into a different segment entirely.

pub fn into_owned(self) -> OwnedElement

Detach this element from the input buffer, cloning any borrowed text.

Trait Implementations

impl<'a> Clone for Element<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Element<'a>

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

Formats the value using the given formatter.

impl<'a> Eq for Element<'a>

impl<'a> PartialEq for Element<'a>

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

Equality operator ==.

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

Inequality operator !=.

impl<'a> StructuralPartialEq for Element<'a>