Enum fhir_model::ParsedReference

pub enum ParsedReference<'a> {
    Local {
        id: &'a str,
    },
    Relative {
        resource_type: &'a str,
        id: &'a str,
        version_id: Option<&'a str>,
    },
    Absolute {
        url: &'a str,
        resource_type: Option<&'a str>,
        id: Option<&'a str>,
    },
}

Parsed parts of a FHIR reference. Can be one of local reference, relative reference or absolute reference. The absolute reference is unchecked and can be anything, it is used as fallback.

Variants

Local

Fields

id: &'a str

Local ID of the resource.

Local reference, the resource is to be found in the contained field.

Relative

Fields

resource_type: &'a str

Resource type.

id: &'a str

Resource ID.

version_id: Option<&'a str>

Targeted version ID if set.

Relative reference, the resource is on the same FHIR server.

Absolute

Fields

url: &'a str

Raw URL string.

resource_type: Option<&'a str>

Assumed resource type part if exists. Is just the positional URL segment, could be wrong.

id: Option<&'a str>

Assumed resource ID part if exists. Is just the positional URL segment, could be wrong.

Absolute reference, the resource can be anywhere, might not even be FHIR server. Might not be a URL, but a URI like a urn:uuid:....

Implementations

impl<'a> ParsedReference<'a>

pub fn new(reference: &'a str) -> Self

Parse the reference from a reference string.

pub fn resource_type(&self) -> Option<&'a str>

Get the resource type that this reference points to as string reference. Might not be present/visible in absolute URLs or local references. In absolute URLs, it might also return garbage, as the URL might have enough segments, but the segment was not an actual resource type. Take care when parsing to ResourceType.

pub fn id(&self) -> Option<&'a str>

Get the resource ID that this reference points to. Might not be present/visible in absolute URLs. In absolute URLs, it might also return garbage, as the URL might have enough segments, but the segment was not an actual id. Take care when using it.

Trait Implementations

impl<'a> Clone for ParsedReference<'a>

fn clone(&self) -> ParsedReference<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for ParsedReference<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for ParsedReference<'a>

fn eq(&self, other: &ParsedReference<'a>) -> 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<'a> Copy for ParsedReference<'a>

impl<'a> Eq for ParsedReference<'a>

impl<'a> StructuralEq for ParsedReference<'a>

impl<'a> StructuralPartialEq for ParsedReference<'a>