Struct Subcomponent

pub struct Subcomponent<'m> {
    pub value: &'m str,
    pub range: Range<usize>,
}

A subcomponent is the smallest unit of data in an HL7 message. It is a string that may contain escape sequences to encode the separators. It is the only type that does not have a separator character. It is always contained within a component.

For parsing performance reasons, the subcomponent does not decode the escape sequences when it is parsed. Instead, the escape sequences are decoded when the subcomponent is displayed. This allows the subcomponent to be parsed without allocating a new string for the decoded value.

Fields

value: &'m str

The raw value of the subcomponent, including escape sequences

range: Range<usize>

The range of the subcomponent in the original message

Implementations

impl<'m> Subcomponent<'m>

pub fn display(&'m self, separators: &'m Separators) -> SubcomponentDisplay<'m>

Display the subcomponent value, using the separators to decode escape sequences by default. Note: if you want to display the raw value without decoding escape sequences, use the # flag, e.g. format!("{:#}", subcomponent.display(separators))

Examples

use hl7_parser::message::{Separators, Subcomponent};
let separators = Separators::default();

let subcomponent = Subcomponent {
    value: r"foo\F\bar",
    range: 0..1, // ignore
};

assert_eq!(format!("{}", subcomponent.display(&separators)), "foo|bar");
assert_eq!(format!("{:#}", subcomponent.display(&separators)), r"foo\F\bar");

pub fn raw_value(&self) -> &'m str

Get the raw value of the subcomponent. This is the value as it appears in the message, without any decoding of escape sequences.

Trait Implementations

impl<'m> Clone for Subcomponent<'m>

fn clone(&self) -> Subcomponent<'m>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'m> Debug for Subcomponent<'m>

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

Formats the value using the given formatter.

impl<'m> PartialEq for Subcomponent<'m>

fn eq(&self, other: &Subcomponent<'m>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<'m> Serialize for Subcomponent<'m>

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'m> Eq for Subcomponent<'m>

impl<'m> StructuralPartialEq for Subcomponent<'m>