Struct hl7_parser::ParsedMessage

pub struct ParsedMessage<'s> {
    pub source: &'s str,
    pub separators: Separators,
    pub segments: IndexMap<&'s str, Segments>,
}

A parsed message. The message structure is valid, but the contents may or may not be.

Fields

source: &'s str

The original source message, generally used to extract items using ranges

separators: Separators

The separators & encoding characters defined at the beginning of the MSH segment

segments: IndexMap<&'s str, Segments>

All the segments stored within the message

Implementations

impl<'s> ParsedMessage<'s>

pub fn parse( source: &'s str, lenient_segment_separators: bool ) -> Result<ParsedMessage<'s>, ParseError>

Parse a string to obtain the underlying message

pub fn has_segment<S: AsRef<str>>(&'s self, segment: S) -> bool

Whether the message contains any of the given segment identifier (MSH, PID, PV1, etc)

pub fn segment<S: AsRef<str>>(&'s self, segment: S) -> Option<&'s Segment>

Access the first segment identified by segment

pub fn segment_count<S: AsRef<str>>(&'s self, segment: S) -> usize

Return the number of times segments identified by segment are present in the message

pub fn segment_n<S: AsRef<str>>( &'s self, segment: S, n: usize ) -> Option<&'s Segment>

Get the 0-based nth segment identified by segment (i.e., if there were two OBX segments and you wanted the second one, call message.segment_n("OBX", 1))

pub fn segment_n_mut<S: AsRef<str>>( &mut self, segment: S, n: usize ) -> Option<&mut Segment>

Mutable access to the 0-based nth segment identified by segment (i.e., if there were two OBX Segments and you wanted the second one, call message.segment_n_mut("OBX", 1))

pub fn get_field_source<S: AsRef<str>>( &'s self, segment: (S, usize), field: NonZeroUsize ) -> Option<&'s str>

Directly get the source (not yet decoded) for a given field, if it exists in the message. The field is identified by the segment identifier, segment repeat identifier, and 1-based field identifier.

Examples

let message = include_str!("../test_assets/sample_adt_a01.hl7");
let message = ParsedMessage::parse(&message, true).expect("can parse message");

let message_type = message.get_field_source(("MSH", 0), NonZeroUsize::new(9).unwrap());
assert_eq!(message_type.unwrap(), "ADT^A01");

pub fn get_field<S: AsRef<str>>( &'s self, segment: (S, usize), field: NonZeroUsize ) -> Option<&'s Field>

Get the field for a given field, if it exists in the message. The field is identified by the segment identifier, segment repeat identifier, and 1-based field identifier.

pub fn get_repeat_source<S: AsRef<str>>( &'s self, segment: (S, usize), field: NonZeroUsize, repeat: NonZeroUsize ) -> Option<&'s str>

Directly get the source (not yet decoded) for a given field and repeat, if it exists in the message. The field is identified by the segment identifier, segment repeat identifier, 1-based field identifier, and the repeat identifier

Examples

let message = include_str!("../test_assets/sample_adt_a04.hl7");
let message = ParsedMessage::parse(&message, true).expect("can parse message");

let allergy_reaction_2 = message.get_repeat_source(
    ("AL1", 0),
    NonZeroUsize::new(5).unwrap(),
    NonZeroUsize::new(2).unwrap());
assert_eq!(allergy_reaction_2.unwrap(), "RASH");

pub fn get_repeat<S: AsRef<str>>( &'s self, segment: (S, usize), field: NonZeroUsize, repeat: NonZeroUsize ) -> Option<&'s Repeat>

Directly get the repeat for a given field and repeat, if it exists in the message. The field is identified by the segment identifier, segment repeat identifier, 1-based field identifier, and the repeat identifier

pub fn get_component_source<S: AsRef<str>>( &'s self, segment: (S, usize), field: NonZeroUsize, repeat: NonZeroUsize, component: NonZeroUsize ) -> Option<&'s str>

Directly get the source (not yet decoded) for a given component, if it exists in the message. The component is identified by the segment identifier, segment repeat identifier, 1-based field identifier, and 1-based component identifier

Examples

let message = include_str!("../test_assets/sample_adt_a01.hl7");
let message = ParsedMessage::parse(&message, true).expect("can parse message");

let trigger_event = message.get_component_source(
    ("MSH", 0),
    NonZeroUsize::new(9).unwrap(),
    NonZeroUsize::new(1).unwrap(),
    NonZeroUsize::new(2).unwrap());
assert_eq!(trigger_event.unwrap(), "A01");

pub fn get_component<S: AsRef<str>>( &'s self, segment: (S, usize), field: NonZeroUsize, repeat: NonZeroUsize, component: NonZeroUsize ) -> Option<&'s Component>

Directly get the component for a given component, if it exists in the message. The component is identified by the segment identifier, segment repeat identifier, 1-based field identifier, and 1-based component identifier

pub fn get_sub_component_source<S: AsRef<str>>( &'s self, segment: (S, usize), field: NonZeroUsize, repeat: NonZeroUsize, component: NonZeroUsize, sub_component: NonZeroUsize ) -> Option<&'s str>

Directly get the source (not yet decoded) for a given sub-component, if it exists in the message. The component is identified by the segment identifier, segment repeat identifier, 1-based field identifier, 1-based component identifier, and 1-based sub-component identifier

Examples

let message = include_str!("../test_assets/sample_oru_r01_generic.hl7");
let message = ParsedMessage::parse(&message, true).expect("can parse message");

let universal_id = message.get_sub_component_source(
    ("PID", 0),
    NonZeroUsize::new(3).unwrap(),
    NonZeroUsize::new(1).unwrap(),
    NonZeroUsize::new(4).unwrap(),
    NonZeroUsize::new(2).unwrap());
assert_eq!(universal_id.unwrap(), "1.2.840.114398.1.100");

pub fn get_sub_component<S: AsRef<str>>( &'s self, segment: (S, usize), field: NonZeroUsize, repeat: NonZeroUsize, component: NonZeroUsize, sub_component: NonZeroUsize ) -> Option<&'s SubComponent>

Directly get the sub-component for a given sub-component, if it exists in the message. The component is identified by the segment identifier, segment repeat identifier, 1-based field identifier, 1-based component identifier, and 1-based sub-component identifier

pub fn segment_at_cursor( &'s self, cursor: usize ) -> Option<(&'s str, usize, &'s Segment)>

Locate a segment at the cursor position

Arguments

• cursor - The cursor location (0-based character index of the original message)

Returns

A tuple containing the HL7 segment identifier, 0-based segment repeat number and a reference to the field. If the segment doesn’t contain the cursor, returns None

pub fn locate_cursor(&'s self, cursor: usize) -> LocatedData<'s>

Deeply locate the cursor by returning the sub-component, component, field, and segment that the cursor is located in (if any)

pub fn query_value<Q, QErr>(&'s self, query: Q) -> Result<Option<&'s str>, QErr>

where Q: TryInto<LocationQuery, Error = QErr>,

Query the message for a given segment, field, component, or sub-comonent.

Arguments

• query - a LocationQuery targeting you want to access

Returns

• Result::Err if the location query couldn’t be parsed
• Result::Ok if the item location query could be parsed message
  • Option::Some containing the item source if the queried item was found in the message
  • Option::None if the queried item was not found in the message message

Examples

let message = include_str!("../test_assets/sample_adt_a01.hl7");
let message = ParsedMessage::parse(&message, true).expect("can parse message");

let trigger_event = message.query_value("MSH.9.2").expect("can parse location query");
assert_eq!(trigger_event, Some("A01"));

pub fn query<Q, QErr>(&self, query: Q) -> Result<Option<Range<usize>>, QErr>

where Q: TryInto<LocationQuery, Error = QErr>,

Query the message for a given segment, field, component, or sub-comonent, returning the range in the source string that the item occupies.

Arguments

• query - a LocationQuery targeting you want to access

Returns

• Result::Err if the location query couldn’t be parsed
• Result::Ok if the item location query could be parsed message
  • Option::Some containing the range in the source if the queried item was found in the message
  • Option::None if the queried item was not found in the message message

Examples

let message = include_str!("../test_assets/sample_adt_a01.hl7");
let message = ParsedMessage::parse(&message, true).expect("can parse message");

let trigger_event = message.query("MSH.9.2").expect("can parse location query");
assert_eq!(trigger_event, Some(40..43));

Trait Implementations

impl<'s> Clone for ParsedMessage<'s>

fn clone(&self) -> ParsedMessage<'s>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'s> Debug for ParsedMessage<'s>

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

Formats the value using the given formatter.

impl<'s> From<ParsedMessage<'s>> for ParsedMessageOwned

fn from(value: ParsedMessage<'s>) -> Self

Converts to this type from the input type.

impl<'s> PartialEq for ParsedMessage<'s>

fn eq(&self, other: &ParsedMessage<'s>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'s> Serialize for ParsedMessage<'s>

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'s> Eq for ParsedMessage<'s>

impl<'s> StructuralEq for ParsedMessage<'s>

impl<'s> StructuralPartialEq for ParsedMessage<'s>