Struct OwnedElement 

#[non_exhaustive]
pub struct OwnedElement {
    pub span: Span,
    pub components: OwnedComponents,
    pub repeats: Vec<OwnedComponents>,
}

Owned data element used by reader-based parsing APIs.

Each entry in components is a (value, span) pair, keeping the string and its byte span structurally in sync.

#[non_exhaustive]: build one with OwnedElement::of.

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

components: OwnedComponents

Components of the first repetition, in positional order.

repeats: Vec<OwnedComponents>

Second and subsequent repetitions (ISO 9735-4 §3.1); usually empty.

Implementations

impl OwnedElement

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

Build an owned data element from its component values.

The owned counterpart of Element::of. Spans default to Span::default; set the element span with with_span when synthesising input for diagnostics.

Example

use edifact_rs::{OwnedElement, OwnedSegment};

let segment = OwnedSegment::new(
    "NAD",
    vec![
        OwnedElement::of(&["BY"]),
        OwnedElement::of(&["4000001000002", "", "9"]),
    ],
);
assert_eq!(segment.component_str(1, 2), Some("9"));

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

Set the span covering this element.

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

Append a further repetition of this data element (ISO 9735-4 §3.1).

The owned counterpart of Element::and_repeat.

pub fn offset(self, delta: usize) -> Self

Shift all stored spans by delta bytes.

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

Shift all stored spans by delta bytes, in place.

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

pub fn repeat_count(&self) -> usize

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

pub fn repetition(&self, n: usize) -> Option<&[(String, Span)]>

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

pub fn repetitions(&self) -> impl Iterator<Item = &[(String, Span)]>

Iterate over every repetition of this element, first one included.

Trait Implementations

impl Clone for OwnedElement

fn clone(&self) -> OwnedElement

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OwnedElement

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

Formats the value using the given formatter.

impl Eq for OwnedElement

impl<'a> From<&'a OwnedElement> for BorrowedElement<'a>

fn from(elem: &'a OwnedElement) -> Self

Converts to this type from the input type.

impl<'a> From<Element<'a>> for OwnedElement

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

Converts to this type from the input type.

impl PartialEq for OwnedElement

fn eq(&self, other: &OwnedElement) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for OwnedElement