Enum 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

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

Fields

id: &'a str

Local ID of the resource.

Relative

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

Fields

resource_type: &'a str

Resource type.

id: &'a str

Resource ID.

version_id: Option<&'a str>

Targeted version ID if set.

Absolute

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:....

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.

Implementations

impl<'a> ParsedReference<'a>

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

Parse the reference from a reference string.

pub const 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 const 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 duplicate 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<(), Error>

Formats the value using the given formatter.

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

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

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

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