Struct ReaderConfig 

pub struct ReaderConfig {
    pub max_segment_bytes: usize,
    pub max_segments: Option<usize>,
    pub max_input_bytes: Option<u64>,
    pub max_messages: Option<usize>,
    pub service_string_advice: Option<ServiceStringAdvice>,
}

Configuration for reader-based EDIFACT parsers.

Pass to from_reader_with_config or from_bufread_stream_with_config to override default limits.

Example

use edifact_rs::{ReaderConfig, from_reader_with_config};

let cfg = ReaderConfig::default().max_segment_bytes(4_096);
let segments: Vec<_> = from_reader_with_config(b"BGM+220+1+9'".as_ref(), cfg)
    .collect::<Result<_, _>>()
    .unwrap();
assert_eq!(segments[0].tag, "BGM");

Fields

max_segment_bytes: usize

Maximum allowed segment byte length (excluding the segment terminator).

If a segment accumulates more bytes than this limit without a terminator the parser returns EdifactError::SegmentTooLong. This prevents unbounded allocation when processing malformed or adversarially crafted input streams.

Default: 65 536 bytes (64 KiB). Real-world EDIFACT segments are almost always below 4 KiB; consider using a tighter limit for untrusted inputs.

max_segments: Option<usize>

Maximum number of segments the input may contain.

A segment beyond this budget yields EdifactError::LimitExceeded. Input that ends exactly at the limit is not a violation.

Default: None (unlimited).

max_input_bytes: Option<u64>

Maximum number of input bytes the interchange may occupy.

A segment whose end offset passes this budget yields EdifactError::LimitExceeded instead of the segment, so no data beyond the cap is ever handed to the caller. Combine with max_segment_bytes for defence in depth against oversized input.

Default: None (unlimited).

max_messages: Option<usize>

Maximum number of EDIFACT messages (UNH/UNT pairs) the input may contain.

A segment belonging to a message beyond this budget yields EdifactError::LimitExceeded.

Default: None (unlimited).

service_string_advice: Option<ServiceStringAdvice>

Service characters to use instead of reading them from the input.

None — the default — discovers them the way ISO 9735-1 says a receiver should: from a leading UNA if there is one, otherwise the §5.1 defaults with the repetition separator resolved from UNB S001 DE 0002.

Set this when the input is a fragment that carries neither: a single message lifted out of an interchange has no UNA and no UNB, so nothing in it records the delimiters its interchange declared, and parsing it with the defaults silently mis-splits every value.

Default: None.

Implementations

impl ReaderConfig

pub fn max_segment_bytes(self, limit: usize) -> Self

Set the maximum segment byte length and return self.

pub fn max_segments(self, limit: usize) -> Self

Set the maximum number of segments to yield and return self.

pub fn max_input_bytes(self, limit: u64) -> Self

Set the maximum total input bytes to consume and return self.

pub fn max_messages(self, limit: usize) -> Self

Set the maximum number of EDIFACT messages (UNH/UNT pairs) to yield and return self.

pub fn with_service_string_advice(self, ssa: ServiceStringAdvice) -> Self

Parse with these service characters instead of discovering them.

See service_string_advice.

Example

use edifact_rs::{ReaderConfig, ServiceStringAdvice, from_bytes_with_config};

// A message lifted out of an interchange whose UNA declared `;` and `~`.
let ssa = ServiceStringAdvice::from_bytes(b"UNA:;.? ~")?;
let config = ReaderConfig::default().with_service_string_advice(ssa);

let segments: Vec<_> = from_bytes_with_config(b"BGM;220;PO-4711~", config)
    .collect::<Result<Vec<_>, _>>()?;
assert_eq!(segments[0].element_str(1), Some("PO-4711"));

Trait Implementations

impl Clone for ReaderConfig

fn clone(&self) -> ReaderConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ReaderConfig

impl Debug for ReaderConfig

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

Formats the value using the given formatter.

impl Default for ReaderConfig

fn default() -> Self

Returns the “default value” for a type.