openehr 0.7.3

openEHR® Reference Model types, validation, paths, AQL parsing, and change-control security primitives. openEHR® is the registered trademark of the openEHR Foundation. Use of the trademark does not constitute endorsement of this product by openEHR International or openEHR Foundation. This project is an independent work.
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

//! The openEHR Reference Model.
//!
//! Four packages, in dependency order: [`data_types`] are the leaf values,
//! [`data_structures`] arrange them, [`common`] adds archetyping and change
//! control, and [`ehr`] and [`demographic`] are the two information models
//! built on all three.

pub mod common;
pub mod data_structures;
pub mod data_types;
pub mod demographic;
pub mod ehr;

/// Generates a zero-sized marker that serializes as a fixed `_type` string.
///
/// # Why a marker rather than nothing
///
/// openEHR requires `_type` wherever the declared type is abstract, and this
/// crate gets that for free on the classes modelled as Rust enums — serde's
/// internal tagging writes it. The classes modelled as plain structs
/// (`COMPOSITION`, `HISTORY`, `EVENT_CONTEXT`, …) have no enum above them and
/// so would emit nothing, yet real openEHR payloads and the published JSON
/// Schemas carry `_type` on them: a `COMPOSITION` is the resource a REST
/// client `POST`s, and it is identified by its `_type`.
///
/// The marker is ignored on input. On a concrete declared type the attribute is
/// redundant, and rejecting a payload whose `_type` disagrees would fail on
/// documents every other implementation accepts.
macro_rules! rm_type_tag {
    ($ty:ident, $name:literal) => {
        #[doc = concat!("Serializes as `\"_type\": \"", $name, "\"`; ignored on input.")]
        #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
        pub struct $ty;

        impl ::serde::Serialize for $ty {
            fn serialize<S: ::serde::Serializer>(
                &self,
                s: S,
            ) -> ::core::result::Result<S::Ok, S::Error> {
                s.serialize_str($name)
            }
        }

        impl<'de> ::serde::Deserialize<'de> for $ty {
            fn deserialize<D: ::serde::Deserializer<'de>>(
                d: D,
            ) -> ::core::result::Result<Self, D::Error> {
                let _ignored = <::std::string::String as ::serde::Deserialize>::deserialize(d)?;
                Ok(Self)
            }
        }
    };
}

pub(crate) use rm_type_tag;