Struct ValidatedInterchange 

#[non_exhaustive]
pub struct ValidatedInterchange {
    pub interchange: InterchangeEnvelope,
    pub functional_groups: Vec<FunctionalGroupEnvelope>,
    pub messages: Vec<MessageEnvelope>,
}

Fully validated interchange structure returned by validate_envelope.

Provides both hierarchical (group → message) and flat (all messages) access so that callers who do not care about group boundaries can use messages directly.

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.

interchange: InterchangeEnvelope

Interchange-level envelope data (from UNB/UNZ).

functional_groups: Vec<FunctionalGroupEnvelope>

Functional groups, when the interchange uses UNG/UNE wrappers.

Empty when messages appear directly under the interchange (the common case for BDEW MaKo and most modern EDIFACT implementations).

messages: Vec<MessageEnvelope>

Flat list of all messages in the interchange.

When functional groups are present this contains the same messages as the nested messages fields inside each FunctionalGroupEnvelope.

Implementations

impl ValidatedInterchange

pub fn has_functional_groups(&self) -> bool

Returns true if this interchange uses UNG/UNE functional group wrappers.

pub fn message_count(&self) -> usize

Total number of UNH/UNT message pairs across all groups.

Equivalent to self.messages.len() but communicates intent clearly.

pub fn iter_messages(&self) -> impl Iterator<Item = &MessageEnvelope>

Iterate over all messages in the interchange.

Equivalent to self.messages.iter() but communicates intent clearly and is stable regardless of future internal layout changes.

pub fn find_message(&self, reference: &str) -> Option<&MessageEnvelope>

Find the first message whose message_ref equals reference.

Useful for locating a specific message in an interchange with multiple messages after calling validate_envelope.

Returns None if no message with that reference exists.

pub fn messages_by_type(&self, message_type: &str) -> Vec<&MessageEnvelope>

Collect all messages of a given type (e.g. "ORDERS", "INVOIC").

Returns a Vec of references to matching messages in document order. Returns an empty Vec when the interchange contains no messages of the requested type.

Prefer iter_messages_by_type in tight loops to avoid the allocation.

pub fn iter_messages_by_type<'s, 'q: 's>( &'s self, message_type: &'q str, ) -> impl Iterator<Item = &'s MessageEnvelope> + 's

Iterate over all messages of a given type without allocating.

Zero-allocation alternative to messages_by_type.

The bound 'q: 's means the message_type string reference must outlive the borrow of self. In practice this is always satisfied when passing a string literal (&'static str) or any string whose lifetime is at least as long as the ValidatedInterchange reference. For short-lived computed strings, use messages_by_type which collects eagerly and releases the string reference immediately.

Trait Implementations

impl Clone for ValidatedInterchange

fn clone(&self) -> ValidatedInterchange

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ValidatedInterchange

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ValidatedInterchange

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ValidatedInterchange

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

Formats the value using the given formatter.

impl Eq for ValidatedInterchange

impl Hash for ValidatedInterchange

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ValidatedInterchange

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for ValidatedInterchange

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ValidatedInterchange