Enum DataElement 

pub enum DataElement<'a> {
    Simple(&'a str),
    Composite(&'a [&'a str]),
}

One data element of a segment being written: simple or composite.

The everyday EDIFACT segment mixes both shapes — NAD+MS+id::agency, DTM+137:20260101:102 — and this enum lets a single call express that without pre-joining components into a string (which loses the distinction between a separator and a literal : in a value).

From impls cover the common literals, so "MS".into() and ["a", "", "b"].into() both work; the elements! macro wraps that up entirely.

Example

use edifact_rs::{DataElement, Writer};

let mut w = Writer::new(Vec::new());
w.write_elements(
    "NAD",
    &[
        DataElement::Simple("MS"),
        DataElement::Composite(&["9900112233445", "", "293"]),
    ],
)?;
assert_eq!(w.finish()?, b"NAD+MS+9900112233445::293'".to_vec());

Variants

Simple(&'a str)

A simple data element — one value, no component separators.

Composite(&'a [&'a str])

A composite data element — components written in order, separated by the active component separator. A separator byte inside a component value is escaped rather than promoted to a boundary.

Implementations

impl<'a> DataElement<'a>

pub fn components(&self) -> &[&'a str]

The components of this element, as a slice.

Trait Implementations

impl AsDataElement for DataElement<'_>

fn as_data_element(&self) -> DataElement<'_>

Borrow self as a DataElement.

impl<'a> Clone for DataElement<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for DataElement<'a>

impl<'a> Debug for DataElement<'a>

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

Formats the value using the given formatter.

impl<'a> Eq for DataElement<'a>

impl<'a, const N: usize> From<&'a [&'a str; N]> for DataElement<'a>

fn from(components: &'a [&'a str; N]) -> Self

Converts to this type from the input type.

impl<'a> From<&'a [&'a str]> for DataElement<'a>

fn from(components: &'a [&'a str]) -> Self

Converts to this type from the input type.

impl<'a> From<&'a str> for DataElement<'a>

fn from(value: &'a str) -> Self

Converts to this type from the input type.

impl<'a> PartialEq for DataElement<'a>

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

Equality operator ==.

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

Inequality operator !=.

impl<'a> StructuralPartialEq for DataElement<'a>