haste_fhir_model/r4/datetime/
serialize.rs

1use crate::r4::datetime::{
2    Date, DateTime, Instant, Time, parse_date, parse_datetime, parse_instant, parse_time,
3};
4use haste_fhir_serialization_json::errors::DeserializeError;
5use haste_fhir_serialization_json::{Context, SerializeError};
6use haste_fhir_serialization_json::{FHIRJSONDeserializer, FHIRJSONSerializer};
7use serde_json::Value;
8
9fn get_value<'a>(value: &'a Value, context: &Context) -> Option<&'a Value> {
10    match context {
11        Context::AsValue => Some(value),
12        Context::AsField(field_context) => value.get(field_context.field),
13    }
14}
15
16impl FHIRJSONDeserializer for DateTime {
17    fn from_json_str(
18        s: &str,
19    ) -> Result<Self, haste_fhir_serialization_json::errors::DeserializeError> {
20        let json_value: Value = serde_json::from_str(s)?;
21        DateTime::from_serde_value(&json_value, Context::AsValue)
22    }
23
24    fn from_serde_value(
25        value: &Value,
26        context: haste_fhir_serialization_json::Context,
27    ) -> Result<Self, haste_fhir_serialization_json::errors::DeserializeError> {
28        let k = get_value(value, &context)
29            .and_then(|v| v.as_str().and_then(|v| parse_datetime(v).ok()));
30        k.ok_or_else(|| DeserializeError::FailedToConvertType("DateTime".to_string()))
31    }
32}
33
34impl FHIRJSONSerializer for DateTime {
35    fn serialize_value(&self, writer: &mut dyn std::io::Write) -> Result<bool, SerializeError> {
36        writer.write_all(&[b'"'])?;
37        writer.write_all(self.to_string().as_bytes())?;
38        writer.write_all(&[b'"'])?;
39
40        Ok(true)
41    }
42
43    fn serialize_extension(
44        &self,
45        _writer: &mut dyn std::io::Write,
46    ) -> Result<bool, SerializeError> {
47        Ok(false)
48    }
49
50    fn serialize_field(
51        &self,
52        field: &str,
53        writer: &mut dyn std::io::Write,
54    ) -> Result<bool, SerializeError> {
55        writer.write_all("\"".as_bytes())?;
56        writer.write_all(field.as_bytes())?;
57        writer.write_all("\":".as_bytes())?;
58        self.serialize_value(writer)?;
59
60        Ok(true)
61    }
62
63    fn is_fp_primitive(&self) -> bool {
64        false
65    }
66}
67
68impl FHIRJSONDeserializer for Date {
69    fn from_json_str(
70        s: &str,
71    ) -> Result<Self, haste_fhir_serialization_json::errors::DeserializeError> {
72        let json_value: Value = serde_json::from_str(s)?;
73        Date::from_serde_value(&json_value, Context::AsValue)
74    }
75
76    fn from_serde_value(
77        value: &Value,
78        context: haste_fhir_serialization_json::Context,
79    ) -> Result<Self, haste_fhir_serialization_json::errors::DeserializeError> {
80        let k =
81            get_value(value, &context).and_then(|v| v.as_str().and_then(|v| parse_date(v).ok()));
82        k.ok_or_else(|| DeserializeError::FailedToConvertType("Date".to_string()))
83    }
84}
85
86impl FHIRJSONSerializer for Date {
87    fn serialize_value(&self, writer: &mut dyn std::io::Write) -> Result<bool, SerializeError> {
88        writer.write_all(&[b'"'])?;
89        writer.write_all(self.to_string().as_bytes())?;
90        writer.write_all(&[b'"'])?;
91
92        Ok(true)
93    }
94
95    fn serialize_extension(
96        &self,
97        _writer: &mut dyn std::io::Write,
98    ) -> Result<bool, SerializeError> {
99        Ok(false)
100    }
101
102    fn serialize_field(
103        &self,
104        field: &str,
105        writer: &mut dyn std::io::Write,
106    ) -> Result<bool, SerializeError> {
107        writer.write_all("\"".as_bytes())?;
108        writer.write_all(field.as_bytes())?;
109        writer.write_all("\":".as_bytes())?;
110        self.serialize_value(writer)?;
111
112        Ok(true)
113    }
114
115    fn is_fp_primitive(&self) -> bool {
116        false
117    }
118}
119
120impl FHIRJSONDeserializer for Time {
121    fn from_json_str(
122        s: &str,
123    ) -> Result<Self, haste_fhir_serialization_json::errors::DeserializeError> {
124        let json_value: Value = serde_json::from_str(s)?;
125        Time::from_serde_value(&json_value, Context::AsValue)
126    }
127
128    fn from_serde_value(
129        value: &Value,
130        context: haste_fhir_serialization_json::Context,
131    ) -> Result<Self, haste_fhir_serialization_json::errors::DeserializeError> {
132        let k =
133            get_value(value, &context).and_then(|v| v.as_str().and_then(|v| parse_time(v).ok()));
134        k.ok_or_else(|| DeserializeError::FailedToConvertType("Time".to_string()))
135    }
136}
137
138impl FHIRJSONSerializer for Time {
139    fn serialize_value(&self, writer: &mut dyn std::io::Write) -> Result<bool, SerializeError> {
140        writer.write_all(&[b'"'])?;
141        writer.write_all(self.to_string().as_bytes())?;
142        writer.write_all(&[b'"'])?;
143
144        Ok(true)
145    }
146
147    fn serialize_extension(
148        &self,
149        _writer: &mut dyn std::io::Write,
150    ) -> Result<bool, SerializeError> {
151        Ok(false)
152    }
153
154    fn serialize_field(
155        &self,
156        field: &str,
157        writer: &mut dyn std::io::Write,
158    ) -> Result<bool, SerializeError> {
159        writer.write_all("\"".as_bytes())?;
160        writer.write_all(field.as_bytes())?;
161        writer.write_all("\":".as_bytes())?;
162        self.serialize_value(writer)?;
163
164        Ok(true)
165    }
166
167    fn is_fp_primitive(&self) -> bool {
168        false
169    }
170}
171
172impl FHIRJSONDeserializer for Instant {
173    fn from_json_str(
174        s: &str,
175    ) -> Result<Self, haste_fhir_serialization_json::errors::DeserializeError> {
176        let json_value: Value = serde_json::from_str(s)?;
177        Instant::from_serde_value(&json_value, Context::AsValue)
178    }
179
180    fn from_serde_value(
181        value: &Value,
182        context: haste_fhir_serialization_json::Context,
183    ) -> Result<Self, haste_fhir_serialization_json::errors::DeserializeError> {
184        let k =
185            get_value(value, &context).and_then(|v| v.as_str().and_then(|v| parse_instant(v).ok()));
186        k.ok_or_else(|| DeserializeError::FailedToConvertType("Instant".to_string()))
187    }
188}
189
190impl FHIRJSONSerializer for Instant {
191    fn serialize_value(&self, writer: &mut dyn std::io::Write) -> Result<bool, SerializeError> {
192        writer.write_all(&[b'"'])?;
193        writer.write_all(self.to_string().as_bytes())?;
194        writer.write_all(&[b'"'])?;
195
196        Ok(true)
197    }
198
199    fn serialize_extension(
200        &self,
201        _writer: &mut dyn std::io::Write,
202    ) -> Result<bool, SerializeError> {
203        Ok(false)
204    }
205
206    fn serialize_field(
207        &self,
208        field: &str,
209        writer: &mut dyn std::io::Write,
210    ) -> Result<bool, SerializeError> {
211        writer.write_all("\"".as_bytes())?;
212        writer.write_all(field.as_bytes())?;
213        writer.write_all("\":".as_bytes())?;
214        self.serialize_value(writer)?;
215
216        Ok(true)
217    }
218
219    fn is_fp_primitive(&self) -> bool {
220        false
221    }
222}
haste_fhir_model/r4/datetime/serialize.rs

haste_fhir_model/r4/datetime/
serialize.rs
