oca_bundle/state/oca/
overlay.rs

1pub mod attribute_mapping;
2pub mod cardinality;
3pub mod character_encoding;
4pub mod conditional;
5pub mod conformance;
6pub mod credential_layout;
7pub mod entry;
8pub mod entry_code;
9pub mod entry_code_mapping;
10pub mod form_layout;
11#[cfg(feature = "format_overlay")]
12pub mod format;
13pub mod information;
14pub mod label;
15pub mod meta;
16pub mod standard;
17pub mod subset;
18pub mod unit;
19
20pub use self::attribute_mapping::AttributeMappingOverlay as AttributeMapping;
21pub use self::cardinality::CardinalityOverlay as Cardinality;
22pub use self::character_encoding::CharacterEncodingOverlay as CharacterEncoding;
23pub use self::conditional::ConditionalOverlay as Conditional;
24pub use self::conformance::ConformanceOverlay as Conformance;
25pub use self::credential_layout::CredentialLayoutOverlay as CredentialLayout;
26pub use self::entry::EntryOverlay as Entry;
27pub use self::entry_code::EntryCodeOverlay as EntryCode;
28pub use self::entry_code_mapping::EntryCodeMappingOverlay as EntryCodeMapping;
29pub use self::form_layout::FormLayoutOverlay as FormLayout;
30#[cfg(feature = "format_overlay")]
31pub use self::format::FormatOverlay as Format;
32pub use self::information::InformationOverlay as Information;
33pub use self::label::LabelOverlay as Label;
34pub use self::meta::MetaOverlay as Meta;
35pub use self::standard::StandardOverlay as Standard;
36pub use self::subset::SubsetOverlay as Subset;
37pub use oca_ast::ast::OverlayType;
38
39pub use self::unit::UnitOverlay as Unit;
40use crate::state::attribute::Attribute;
41use isolang::Language;
42use said::sad::SAD;
43use std::any::Any;
44erased_serde::serialize_trait_object!(Overlay);
45
46use dyn_clonable::*;
47
48#[clonable]
49pub trait Overlay: erased_serde::Serialize + Clone + SAD {
50    fn as_any(&self) -> &dyn Any;
51    fn capture_base(&self) -> &Option<said::SelfAddressingIdentifier>;
52    fn set_capture_base(&mut self, said: &said::SelfAddressingIdentifier);
53    fn said(&self) -> &Option<said::SelfAddressingIdentifier>;
54    fn overlay_type(&self) -> &OverlayType;
55    fn language(&self) -> Option<&Language> {
56        None
57    }
58
59    fn attributes(&self) -> Vec<&String>;
60
61    fn add(&mut self, attribute: &Attribute);
62
63    fn fill_said(&mut self) {
64        self.compute_digest(); //HashFunctionCode::Blake3_256, SerializationFormats::JSON);
65    }
66
67    fn sign(&mut self, capture_base_sai: &said::SelfAddressingIdentifier) {
68        self.set_capture_base(capture_base_sai);
69        self.fill_said();
70    }
71}
72
73macro_rules! overlay {
74    ($name:ident, $field1:ident, $field2:ident: $field2_type:ty) => {
75        paste::paste! {
76            pub trait [<$name s>] {
77                fn [<set_ $field2>](&mut self, $field2: $field2_type);
78            }
79
80            impl [<$name s>] for crate::state::attribute::Attribute {
81                fn [<set_ $field2>](&mut self, $field2: $field2_type) {
82                    self.$field2 = Some($field2);
83                }
84            }
85
86            pub fn serialize_attributes<S>(attributes: &std::collections::HashMap<String, $field2_type>, s: S) -> Result<S::Ok, S::Error>
87            where
88                S: serde::Serializer,
89            {
90                use std::collections::BTreeMap;
91
92                let mut ser = s.serialize_map(Some(attributes.len()))?;
93                let sorted_attributes: BTreeMap<_, _> = attributes.iter().collect();
94                for (k, v) in sorted_attributes {
95                    ser.serialize_entry(k, v)?;
96                }
97                ser.end()
98            }
99
100            #[derive(serde::Deserialize, serde::Serialize, SAD, Debug, Clone)]
101            pub struct [<$name Overlay>] {
102                #[said]
103                #[serde(rename = "d")]
104                said: Option<said::SelfAddressingIdentifier>,
105                #[serde(rename = "type")]
106                overlay_type: oca_ast::ast::OverlayType,
107                capture_base: Option<said::SelfAddressingIdentifier>,
108                #[serde(serialize_with = "serialize_attributes")]
109                pub $field1: std::collections::HashMap<String, $field2_type>
110            }
111
112            impl crate::state::oca::overlay::Overlay for [<$name Overlay>] {
113                fn as_any(&self) -> &dyn std::any::Any {
114                    self
115                }
116                fn overlay_type(&self) -> &oca_ast::ast::OverlayType {
117                    &self.overlay_type
118                }
119                fn capture_base(&self) -> &Option<said::SelfAddressingIdentifier> {
120                    &self.capture_base
121                }
122                fn set_capture_base(&mut self, said: &said::SelfAddressingIdentifier) {
123                    self.capture_base = Some(said.clone());
124                }
125                fn said(&self) -> &Option<said::SelfAddressingIdentifier> {
126                    &self.said
127                }
128                fn attributes(&self) -> Vec<&String> {
129                    self.$field1.keys().collect::<Vec<&String>>()
130                }
131
132                fn add(&mut self, attribute: &crate::state::attribute::Attribute) {
133                    if attribute.$field2.is_some() {
134                        self.$field1.insert(attribute.name.clone(), attribute.$field2.clone().unwrap());
135                    }
136                }
137            }
138
139            impl Default for [<$name Overlay>] {
140                fn default() -> Self {
141                    Self::new()
142                }
143            }
144
145            impl [<$name Overlay>] {
146                pub fn new() -> Self {
147                    Self {
148                        capture_base: None,
149                        said: None,
150                        overlay_type: oca_ast::ast::OverlayType::$name,
151                        $field1: std::collections::HashMap::new(),
152
153                    }
154                }
155            }
156        }
157    }
158}
159pub(crate) use overlay;