Struct ServiceStringAdvice 

pub struct ServiceStringAdvice {
    pub element_sep: u8,
    pub component_sep: u8,
    pub release_char: u8,
    pub decimal_mark: u8,
    pub repetition_sep: u8,
    pub segment_term: u8,
}

EDIFACT service string advice — the six characters of the UNA (ISO 9735-1 Annex B).

The five active service characters — component separator, element separator, release character, repetition separator, and segment terminator — are what is_valid enforces: printable non-alphanumeric ASCII, mutually distinct, so a collision between the repetition separator and any other delimiter, or a delimiter that would clash with segment-tag characters, is caught at UNA parse time.

The decimal mark is deliberately not in that set; see decimal_mark.

Defaults

ISO 9735-1 §5.1 fixes the defaults as : (component), + (element), ? (release), * (repetition), ' (terminator). Syntax version 4 is the version that defines the repetition separator at all: in versions 1–3 that UNA position is reserved and carries a space. Default is therefore the version-agnostic reading — everything per §5.1 except repetition, which stays inactive until something says the interchange is version 4. See for_syntax_version.

Fields

element_sep: u8

Data element separator (default +; UNA position 020)

component_sep: u8

Component data element separator (default :; UNA position 010)

release_char: u8

Release character (default ?; UNA position 040)

decimal_mark: u8

Decimal mark (UNA position 030), default ..

Ignored on receipt. ISO 9735-1 Annex B keeps this position only for upward compatibility with earlier syntax versions and states that the character transferred here “shall be ignored by the recipient”; §10 instead allows the full stop or the comma per individual numeric value. It is therefore neither validated nor used for splitting — it is preserved so a writer can round-trip the UNA it was given, and so DecimalFloat has a house style to format with.

repetition_sep: u8

Repetition separator (UNA position 050), introduced by syntax version 4.

A space (0x20) means not used: that is what versions 1–3 put in this reserved position, and version 4 forbids a space here precisely because the position now carries a real separator.

When the separator is active the tokenizer splits on it: a data element carrying ON:1*ON:2 becomes one element with two repetitions rather than one repetition whose second component is the literal text 1*ON. Use is_repetition_active to test for this.

segment_term: u8

Segment terminator (default '; UNA position 060)

Implementations

impl ServiceStringAdvice

pub fn from_bytes(input: &[u8]) -> Result<Self, EdifactError>

Read the service characters an interchange actually uses.

Two sources, in priority order:

1. A leading UNA, which states all six characters explicitly.
2. Otherwise the ISO 9735-1 §5.1 defaults, with the repetition separator resolved from the syntax version in UNB S001 DE 0002 — see for_syntax_version.

Errors

EdifactError::InvalidUna when a UNA is present but its active service characters are not mutually distinct printable non-alphanumeric ASCII. See is_valid for the exact rule.

This is the safe, default constructor — always use this for input from an external source. For trusted or internal use where delimiter uniqueness is already guaranteed, use from_bytes_unchecked.

pub fn from_bytes_unchecked(input: &[u8]) -> Self

Parse a UNA header from the beginning of an EDIFACT interchange without validating delimiter uniqueness or printability.

When no UNA is present the §5.1 defaults apply, with the repetition separator taken from the syntax version declared in UNB S001 DE 0002.

When to use

Use this only for trusted internal data (e.g. round-tripping data where the UNA invariant is already guaranteed) or in fuzz/property tests that intentionally explore degenerate delimiter combinations.

For any external or user-provided input, prefer from_bytes which validates delimiter uniqueness and rejects invalid bytes.

pub const fn for_syntax_version(version: Option<u8>) -> Self

The ISO 9735-1 §5.1 defaults for a given syntax version.

The repetition separator is the only character the version decides: version 4 introduced it as *, and versions 1–3 have no such service character at all — that UNA position is reserved and carries a space. Splitting on * in a version 3 interchange would corrupt every value containing one, since * is an ordinary level A character there.

None means the version could not be determined (no UNB, or an unreadable one) and is treated as “not version 4”.

Example

use edifact_rs::ServiceStringAdvice;

assert!(ServiceStringAdvice::for_syntax_version(Some(4)).is_repetition_active());
assert!(!ServiceStringAdvice::for_syntax_version(Some(3)).is_repetition_active());
assert!(!ServiceStringAdvice::for_syntax_version(None).is_repetition_active());

pub fn is_valid(&self) -> bool

Return true if all active service characters are mutually distinct and printable, non-alphanumeric ASCII.

The active set is the component separator, element separator, release character, segment terminator, and — when it is not the space “not used” sentinel — the repetition separator. Each must be in 0x21..=0x7E excluding 0-9A-Za-z, and all must differ pairwise.

Alphanumerics are excluded because segment tags are always three ASCII uppercase letters written verbatim (a tag cannot be escaped). A delimiter such as N would make NAD unrepresentable — the writer would emit a premature terminator and the result would not reparse. High bytes (>= 0x80) are rejected because they would bisect multi-byte UTF-8 sequences, and DEL (0x7F) is a control character.

The decimal mark is not checked at all: ISO 9735-1 Annex B states that the character in that position “shall be ignored by the recipient”, and is the one position where the standard permits a space. Rejecting a UNA over a character the standard tells receivers to ignore would fail conformant interchanges for nothing.

Example

use edifact_rs::ServiceStringAdvice;

// A duplicated *active* character is fatal …
assert!(ServiceStringAdvice::from_bytes(b"UNA::.? '").is_err());
// … but the ignored decimal-mark slot may hold anything, even a space.
assert!(ServiceStringAdvice::from_bytes(b"UNA:+ ? '")?.is_repetition_active() == false);

pub const fn is_repetition_active(&self) -> bool

Returns true when this interchange declares a usable repetition separator (UNA position 050, syntax version 4).

A space there means “not used” — the reserved value carried by syntax versions 1–3 — so it reports false and the tokenizer never splits on it.

Example

use edifact_rs::ServiceStringAdvice;

assert!(!ServiceStringAdvice::default().is_repetition_active());
assert!(ServiceStringAdvice::from_bytes(b"UNA:+.?*'")?.is_repetition_active());

Trait Implementations

impl Clone for ServiceStringAdvice

fn clone(&self) -> ServiceStringAdvice

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ServiceStringAdvice

impl Debug for ServiceStringAdvice

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

Formats the value using the given formatter.

impl Default for ServiceStringAdvice

fn default() -> Self

Returns the “default value” for a type.

impl Eq for ServiceStringAdvice

impl PartialEq for ServiceStringAdvice

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ServiceStringAdvice