Struct MessageDispatch 

pub struct MessageDispatch { /* private fields */ }

Type-based dispatcher for mixed-message EDIFACT streams.

Register one handler per message type with on, then call dispatch on each message window. If no handler matches and a fallback was registered it is invoked instead; otherwise an EdifactError::UnexpectedMessageType is returned.

Example

let dispatch = MessageDispatch::new()
    .on("ORDERS",  |segs| Orders::edifact_deserialize(segs))
    .on("INVOIC",  |segs| Invoice::edifact_deserialize(segs));

for window in message_windows_bytes(input) {
    let window = window?;
    let msg = dispatch.dispatch(&window)?;
    match msg.message_type.as_str() {
        "ORDERS"  => { let o = msg.downcast::<Orders>().unwrap(); /* … */ }
        "INVOIC"  => { let i = msg.downcast::<Invoice>().unwrap(); /* … */ }
        _         => unreachable!(),
    }
}

Implementations

impl MessageDispatch

pub fn new() -> Self

Create an empty dispatcher.

pub fn on<T, F>(self, message_type: &str, handler: F) -> Self

where T: Any + Send + Sync + 'static, F: for<'a> Fn(&[Segment<'a>]) -> Result<T, EdifactError> + Send + Sync + 'static,

Register a handler for message_type.

The closure receives the full message window and returns a typed value that is boxed and stored inside DispatchedMessage.

pub fn fallback<T, F>(self, handler: F) -> Self

where T: Any + Send + Sync + 'static, F: for<'a> Fn(&[Segment<'a>], &str) -> Result<T, EdifactError> + Send + Sync + 'static,

Register a fallback handler for unrecognised message types.

The closure receives the segment window and the unknown message-type string.

pub fn dispatch( &self, window: &[Segment<'_>], ) -> Result<DispatchedMessage, EdifactError>

Dispatch a single message window to the appropriate handler.

The message type is extracted from the UNH segment. If no UNH is present, EdifactError::MissingSegment is returned.

pub fn dispatch_all_from_bytes<'a>( &'a self, input: &'a [u8], ) -> impl Iterator<Item = Result<DispatchedMessage, EdifactError>> + 'a

Dispatch all messages from a byte reader.

Each message window is extracted and dispatched in order. The returned iterator is lazy — errors are yielded as Err items.

pub fn dispatch_all_from_reader<R: Read + 'static>( &self, reader: R, ) -> impl Iterator<Item = Result<DispatchedMessage, EdifactError>> + '_

Dispatch all messages from a reader.

Parses the stream into message windows and dispatches each. The returned iterator yields owned DispatchedMessage values lazily: each window is fully buffered in memory (as Vec<OwnedSegment>) before dispatch, but windows are processed one at a time rather than all at once.

Trait Implementations

impl Default for MessageDispatch

fn default() -> Self

Returns the “default value” for a type.