Struct LocationQuery

pub struct LocationQuery {
    pub segment: String,
    pub field: Option<NonZeroUsize>,
    pub repeat: Option<NonZeroUsize>,
    pub component: Option<NonZeroUsize>,
    pub sub_component: Option<NonZeroUsize>,
}

A query for a particular piece of a message, to be used in ParsedMessage::query (or ParsedMessageOwned::query)

Fields

segment: String

The segment identifier to query

field: Option<NonZeroUsize>

The 1-based field ID to optionally query

repeat: Option<NonZeroUsize>

The 1-based repeat ID to optionally query

component: Option<NonZeroUsize>

The 1-based component ID to optionally query

sub_component: Option<NonZeroUsize>

The 1-based sub-component ID to optionally query

Implementations

impl LocationQuery

pub fn new<S: AsRef<str>>(source: S) -> Result<LocationQuery, String>

Create a new location query by attempting to parse a string query

Query is expected to be in the form of: <SEGMENT ID>[<SEP><FIELD>][\[<REPEAT>\]][<SEP><COMPONENT>][<SEP><SUB-COMPONENT>] where:

• <SEGMENT ID> is 3 alpha-numeric characters which will be normalized to uppercase
• <SEP> is one of ., -, or (space)
• <FIELD> is a non-zero integer specifying the field number
• <REPEAT> is a non-zero integer specifying the repeat number
• <COMPONENT> is a non-zero integer specifying the component number
• <SUB-COMPONENT> is a non-zero integer specifying the sub-component number

Examples

let query = LocationQuery::new("MSH.9").expect("can parse query");
assert_eq!(query.segment.as_str(), "MSH");
assert_eq!(query.field.unwrap().get(), 9);
assert!(query.component.is_none());

let query = LocationQuery::new("AL1.5[3]").expect("can parse query");
assert_eq!(query.segment.as_str(), "AL1");
assert_eq!(query.field.unwrap().get(), 5);
assert_eq!(query.repeat.unwrap().get(), 3);
assert!(query.component.is_none());

let query = LocationQuery::new("PID-3-4-2").expect("can parse query");
assert_eq!(query.segment.as_str(), "PID");
assert_eq!(query.field.unwrap().get(), 3);
assert_eq!(query.component.unwrap().get(), 4);
assert_eq!(query.sub_component.unwrap().get(), 2);

pub fn new_segment<S: ToString>(segment: S) -> LocationQuery

Create a location query solely for a segment

pub fn new_field<S, U, UErr>( segment: S, field: U, ) -> Result<LocationQuery, UErr>

where S: ToString, U: TryInto<NonZeroUsize, Error = UErr>,

Create a location query for a segment and a field

pub fn new_field_repeat<S, U, UErr>( segment: S, field: U, repeat: U, ) -> Result<LocationQuery, UErr>

where S: ToString, U: TryInto<NonZeroUsize, Error = UErr>,

Create a location query for a segment, a field, and a repeat

pub fn new_component<S, U, UErr>( segment: S, field: U, component: U, ) -> Result<LocationQuery, UErr>

where S: ToString, U: TryInto<NonZeroUsize, Error = UErr>,

Create a location query for a segment, a field, and a component

pub fn new_repeat_component<S, U, UErr>( segment: S, field: U, repeat: U, component: U, ) -> Result<LocationQuery, UErr>

where S: ToString, U: TryInto<NonZeroUsize, Error = UErr>,

Create a location query for a segment, a field, a repeat, and a component

pub fn new_sub_component<S, U, UErr>( segment: S, field: U, component: U, sub_component: U, ) -> Result<LocationQuery, UErr>

where S: ToString, U: TryInto<NonZeroUsize, Error = UErr>,

Create a location query for a segment, a field, a component, and a sub-component

pub fn new_repeat_sub_component<S, U, UErr>( segment: S, field: U, repeat: U, component: U, sub_component: U, ) -> Result<LocationQuery, UErr>

where S: ToString, U: TryInto<NonZeroUsize, Error = UErr>,

Create a location query for a segment, a field, a component, and a sub-component

Trait Implementations

impl Clone for LocationQuery

fn clone(&self) -> LocationQuery

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LocationQuery

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

Formats the value using the given formatter.

impl Display for LocationQuery

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

Formats the value using the given formatter.

impl<'l> From<&LocatedData<'l>> for LocationQuery

fn from(value: &LocatedData<'_>) -> Self

Converts to this type from the input type.

impl From<&LocationQuery> for LocationQuery

fn from(value: &LocationQuery) -> Self

Converts to this type from the input type.

impl<'l> From<LocatedData<'l>> for LocationQuery

fn from(value: LocatedData<'_>) -> Self

Converts to this type from the input type.

impl FromStr for LocationQuery

type Err = String

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl PartialEq for LocationQuery

fn eq(&self, other: &LocationQuery) -> 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<'s> TryFrom<&'s str> for LocationQuery

type Error = String

The type returned in the event of a conversion error.

fn try_from(value: &'s str) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<String> for LocationQuery

type Error = String

The type returned in the event of a conversion error.

fn try_from(value: String) -> Result<Self, Self::Error>

Performs the conversion.

impl Eq for LocationQuery

impl StructuralPartialEq for LocationQuery