fhir 0.1.0

Fast Healthcare Interoperability Resources (FHIR) API is a standardized, RESTful interface for exchanging electronic health records.
Documentation 
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

//! Read a FHIR R5 `Bundle` and dispatch on each entry's resource type.
//!
//! Run with:
//!
//! ```sh
//! cargo run --example read_bundle
//! ```
//!
//! A search or transaction `Bundle` carries a heterogeneous list of resources.
//! Each `Bundle.entry.resource` is held as raw `serde_json::Value` (its type is
//! only known at runtime), so we deserialize each one into the polymorphic
//! [`Resource`] enum, which serde selects by the `resourceType` tag.
//!
//! [`Resource`]: fhir::r5::resources::Resource

use fhir::r5::resources::{Bundle, Resource};

fn main() {
    // A minimal searchset bundle containing two different resource types.
    let bundle_json = serde_json::json!({
        "resourceType": "Bundle",
        "type": "searchset",
        "total": 2,
        "entry": [
            { "resource": { "resourceType": "Patient", "id": "pat-1", "active": true } },
            { "resource": { "resourceType": "Observation", "id": "obs-1",
                            "status": "final",
                            "code": { "text": "Body temperature" } } }
        ]
    });

    // Parse the envelope. `Bundle.type` is required (`1..1`).
    let bundle: Bundle = serde_json::from_value(bundle_json).expect("parse Bundle");
    println!("Bundle type: {}", bundle.r#type.0);

    // Walk the entries, deserializing each contained resource by its type tag.
    for entry in bundle.entry.into_iter().flatten() {
        let Some(value) = entry.resource else { continue };
        match serde_json::from_value(value).expect("parse entry resource") {
            Resource::Patient(patient) => {
                println!(
                    "- Patient {} (active: {:?})",
                    patient.id.as_ref().map_or("?", |id| &id.0),
                    patient.active.map(|b| b.0),
                );
            }
            Resource::Observation(observation) => {
                println!(
                    "- Observation {} (status: {})",
                    observation.id.as_ref().map_or("?", |id| &id.0),
                    observation.status.0,
                );
            }
            other => println!("- some other resource: {other:?}"),
        }
    }
}