fhir 4.0.0

Fast Healthcare Interoperability Resources (FHIR) data model for Rust: the complete FHIR R2-R6 resources, datatypes, and code systems as serde-serializable types, plus cross-release conversion and a spec-driven code generator.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

//! Typed references: what the compiler knows about where a reference points.
//!
//! Run with:
//!
//! ```sh
//! cargo run --example typed_references
//! ```
//!
//! Where the FHIR specification says a reference targets exactly one resource
//! type, the generated field says so too: `AllergyIntolerance.patient` is
//! `Reference<Patient>`, not a stringly-typed link. Where the specification
//! allows several targets — `Observation.subject` may be a Patient, Group,
//! Device, or Location — the field stays `Reference<Any>`, because a type
//! claiming one target would be wrong four ways. The wire form is identical
//! either way: the target is a zero-sized compile-time marker.
//!
//! `resolve` uses the marker: resolving a `Reference<Patient>` inside a
//! `Bundle` refuses a matching entry whose `resourceType` is not `Patient`.

use fhir::r5::resources::{AllergyIntolerance, Bundle, Patient};
use fhir::r5::types;
use fhir::r5::types::reference::Reference;

fn main() {
    // An AllergyIntolerance whose `patient` field is typed: the specification
    // gives that element exactly one targetProfile, so the generator did too.
    let allergy: AllergyIntolerance = serde_json::from_value(serde_json::json!({
        "resourceType": "AllergyIntolerance",
        "id": "al-1",
        "patient": { "reference": "Patient/pat-1" }
    }))
    .expect("valid AllergyIntolerance");

    // The field's type carries the target. This line only compiles because
    // `patient` is `Reference<Patient>`:
    let patient_ref: &types::Reference<Patient> = &allergy.patient;
    println!(
        "AllergyIntolerance.patient -> {}",
        patient_ref.reference.as_ref().map_or("?", |r| &r.0)
    );

    // Resolving inside a Bundle checks the marker against the entry.
    let bundle: Bundle = serde_json::from_value(serde_json::json!({
        "resourceType": "Bundle",
        "type": "collection",
        "entry": [
            { "resource": { "resourceType": "Patient", "id": "pat-1",
                            "name": [{ "family": "Chalmers" }] } }
        ]
    }))
    .expect("valid Bundle");

    let resolved = patient_ref.resolve(&bundle).expect("resolves");
    println!(
        "resolved to a {} named {}",
        resolved["resourceType"].as_str().unwrap_or("?"),
        resolved["name"][0]["family"].as_str().unwrap_or("?")
    );

    // A wrong-type entry is refused even when the reference string matches:
    // the same id under resourceType Observation resolves to nothing.
    let wrong: Bundle = serde_json::from_value(serde_json::json!({
        "resourceType": "Bundle",
        "type": "collection",
        "entry": [
            { "resource": { "resourceType": "Observation", "id": "pat-1", "status": "final",
                            "code": { "text": "not a patient" } } }
        ]
    }))
    .expect("valid Bundle");
    assert!(patient_ref.resolve(&wrong).is_none());
    println!("a matching id under the wrong resourceType is refused");

    // The untyped form still exists where the spec allows many targets, and
    // `cast` moves between the two when the caller knows better than the type.
    let any: Reference = serde_json::from_value(serde_json::json!({
        "reference": "Patient/pat-1"
    }))
    .expect("valid Reference");
    let typed: Reference<Patient> = any.cast();
    assert!(typed.resolve(&bundle).is_some());
    println!("cast: Reference<Any> -> Reference<Patient> (wire form unchanged)");
}