Struct Writer 

pub struct Writer<W: Write> { /* private fields */ }

Streaming EDIFACT writer.

Wraps any Write implementation and serializes segments one at a time. Call Writer::finish to flush and get the underlying writer back.

Implementations

impl<W: Write> Writer<W>

pub fn new(inner: W) -> Self

Create a new writer with default EDIFACT delimiters.

pub fn with_una( inner: W, ssa: ServiceStringAdvice, ) -> Result<Self, EdifactError>

Create a writer with custom delimiters and write a UNA segment first.

pub fn write_segment(&mut self, seg: &Segment<'_>) -> Result<(), EdifactError>

Write a single segment.

pub fn write_raw( &mut self, tag: &str, elements: &[&str], ) -> Result<(), EdifactError>

Write a raw segment from tag + element string slices.

Each element string is split on the active component-separator byte from the configured ServiceStringAdvice to identify component boundaries. The default component separator is : (0x3A), but this can differ when a non-default UNA string was used to construct the writer.

Delimiter dependency

Callers that embed the literal : character in element strings rely on : being the component separator. When the writer uses a non-default delimiter set, : will not be treated as a component boundary and the segment will be written incorrectly.

UTF-8 safety: EDIFACT syntax requires all delimiter bytes to be single-byte ASCII characters (values 0x00–0x7F). Non-ASCII delimiter bytes would bisect multi-byte UTF-8 sequences in data values and produce malformed output. All fields of ServiceStringAdvice must therefore hold ASCII byte values.

To produce correct output regardless of the active delimiter, prefer Self::write_segment_parts which accepts pre-split component slices.

pub fn write_segment_parts<E>( &mut self, tag: &str, elements: &[E], ) -> Result<(), EdifactError>

where E: AsRef<[String]>,

Write a segment from a tag and pre-split element/component data.

elements is a slice of elements; each element is a sequence of component strings. This avoids the lifetime constraints of Self::write_segment when building segments from runtime-owned data (e.g. inside crate::WriterEmitter).

pub fn finish(self) -> Result<W, EdifactError>

Flush and return the underlying writer.

pub fn finish_unt(self, message_ref: &str) -> Result<W, EdifactError>

Write the UNT segment and return the inner writer.

The segment count written into UNT element 1 (DE 0074) is the number of segments already written plus one for the UNT segment itself, which EDIFACT requires to be included in the count alongside UNH.

Errors

Returns an error if writing fails. Do not call write_raw or write_segment after finish_unt — the writer is consumed.

pub fn segment_count(&self) -> u64

Returns the total number of segments written so far.

pub fn service_string_advice(&self) -> ServiceStringAdvice

Returns the active ServiceStringAdvice (delimiter configuration).

pub fn escape_value<'v>(&self, value: &'v str) -> Cow<'v, str>

Escape a value string for inclusion in an EDIFACT segment.

Any character in value that matches the active element separator, component separator, release character, or segment terminator is escaped by prefixing it with the release character (default ?).

Returns a borrowed Cow::Borrowed(value) when no escaping is needed, avoiding an allocation on the fast path.

Example

let writer = Writer::new(std::io::sink());
// '+' must be escaped since it is the default element separator.
assert_eq!(writer.escape_value("price+tax"), "price?+tax");