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::Deserialize;
8use serde_json::Value;
9
10fn get_value<'a>(value: &'a Value, context: &Context) -> Option<&'a Value> {
11    match context {
12        Context::AsValue => Some(value),
13        Context::AsField(field_context) => value.get(field_context.field),
14    }
15}
16
17impl<'de> Deserialize<'de> for DateTime {
18    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
19    where
20        D: serde::Deserializer<'de>,
21    {
22        let value = String::deserialize(deserializer)?;
23        parse_datetime(&value).map_err(|_| serde::de::Error::custom("invalid FHIR dateTime"))
24    }
25}
26
27impl serde::Serialize for DateTime {
28    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
29    where
30        S: serde::Serializer,
31    {
32        self.to_string().serialize(serializer)
33    }
34}
35
36impl FHIRJSONDeserializer for DateTime {
37    fn from_json_str(
38        s: &str,
39    ) -> Result<Self, haste_fhir_serialization_json::errors::DeserializeError> {
40        let mut json_value: Value = serde_json::from_str(s)?;
41        DateTime::from_serde_value(&mut json_value, Context::AsValue)
42    }
43
44    fn from_serde_value(
45        value: *mut Value,
46        context: haste_fhir_serialization_json::Context,
47    ) -> Result<Self, haste_fhir_serialization_json::errors::DeserializeError> {
48        let value = unsafe { &mut *(value as *mut Value) };
49        let k = get_value(&value, &context)
50            .and_then(|v| v.as_str().and_then(|v| parse_datetime(v).ok()));
51        k.ok_or_else(|| DeserializeError::FailedToConvertType("DateTime".to_string()))
52    }
53}
54
55impl FHIRJSONSerializer for DateTime {
56    fn serialize_value(&self, writer: &mut dyn std::io::Write) -> Result<bool, SerializeError> {
57        writer.write_all(&[b'"'])?;
58        writer.write_all(self.to_string().as_bytes())?;
59        writer.write_all(&[b'"'])?;
60
61        Ok(true)
62    }
63
64    fn serialize_extension(
65        &self,
66        _writer: &mut dyn std::io::Write,
67    ) -> Result<bool, SerializeError> {
68        Ok(false)
69    }
70
71    fn serialize_field(
72        &self,
73        field: &str,
74        writer: &mut dyn std::io::Write,
75    ) -> Result<bool, SerializeError> {
76        writer.write_all("\"".as_bytes())?;
77        writer.write_all(field.as_bytes())?;
78        writer.write_all("\":".as_bytes())?;
79        self.serialize_value(writer)?;
80
81        Ok(true)
82    }
83
84    fn is_fp_primitive(&self) -> bool {
85        false
86    }
87}
88
89impl<'de> Deserialize<'de> for Date {
90    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
91    where
92        D: serde::Deserializer<'de>,
93    {
94        let value = String::deserialize(deserializer)?;
95        parse_date(&value).map_err(|_| serde::de::Error::custom("invalid FHIR date"))
96    }
97}
98
99impl serde::Serialize for Date {
100    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
101    where
102        S: serde::Serializer,
103    {
104        self.to_string().serialize(serializer)
105    }
106}
107
108impl FHIRJSONDeserializer for Date {
109    fn from_json_str(
110        s: &str,
111    ) -> Result<Self, haste_fhir_serialization_json::errors::DeserializeError> {
112        let mut json_value: Value = serde_json::from_str(s)?;
113        Date::from_serde_value(&mut json_value, Context::AsValue)
114    }
115
116    fn from_serde_value(
117        value: *mut Value,
118        context: haste_fhir_serialization_json::Context,
119    ) -> Result<Self, haste_fhir_serialization_json::errors::DeserializeError> {
120        let value = unsafe { &mut *(value as *mut Value) };
121        let k =
122            get_value(&value, &context).and_then(|v| v.as_str().and_then(|v| parse_date(v).ok()));
123        k.ok_or_else(|| DeserializeError::FailedToConvertType("Date".to_string()))
124    }
125}
126
127impl FHIRJSONSerializer for Date {
128    fn serialize_value(&self, writer: &mut dyn std::io::Write) -> Result<bool, SerializeError> {
129        writer.write_all(&[b'"'])?;
130        writer.write_all(self.to_string().as_bytes())?;
131        writer.write_all(&[b'"'])?;
132
133        Ok(true)
134    }
135
136    fn serialize_extension(
137        &self,
138        _writer: &mut dyn std::io::Write,
139    ) -> Result<bool, SerializeError> {
140        Ok(false)
141    }
142
143    fn serialize_field(
144        &self,
145        field: &str,
146        writer: &mut dyn std::io::Write,
147    ) -> Result<bool, SerializeError> {
148        writer.write_all("\"".as_bytes())?;
149        writer.write_all(field.as_bytes())?;
150        writer.write_all("\":".as_bytes())?;
151        self.serialize_value(writer)?;
152
153        Ok(true)
154    }
155
156    fn is_fp_primitive(&self) -> bool {
157        false
158    }
159}
160
161impl serde::Serialize for Time {
162    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
163    where
164        S: serde::Serializer,
165    {
166        self.to_string().serialize(serializer)
167    }
168}
169
170impl<'de> Deserialize<'de> for Time {
171    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
172    where
173        D: serde::Deserializer<'de>,
174    {
175        let value = String::deserialize(deserializer)?;
176        parse_time(&value).map_err(|_| serde::de::Error::custom("invalid FHIR time"))
177    }
178}
179
180impl FHIRJSONDeserializer for Time {
181    fn from_json_str(
182        s: &str,
183    ) -> Result<Self, haste_fhir_serialization_json::errors::DeserializeError> {
184        let mut json_value: Value = serde_json::from_str(s)?;
185        Time::from_serde_value(&mut json_value, Context::AsValue)
186    }
187
188    fn from_serde_value(
189        value: *mut Value,
190        context: haste_fhir_serialization_json::Context,
191    ) -> Result<Self, haste_fhir_serialization_json::errors::DeserializeError> {
192        let value = unsafe { &mut *(value as *mut Value) };
193        let k =
194            get_value(&value, &context).and_then(|v| v.as_str().and_then(|v| parse_time(v).ok()));
195        k.ok_or_else(|| DeserializeError::FailedToConvertType("Time".to_string()))
196    }
197}
198
199impl FHIRJSONSerializer for Time {
200    fn serialize_value(&self, writer: &mut dyn std::io::Write) -> Result<bool, SerializeError> {
201        writer.write_all(&[b'"'])?;
202        writer.write_all(self.to_string().as_bytes())?;
203        writer.write_all(&[b'"'])?;
204
205        Ok(true)
206    }
207
208    fn serialize_extension(
209        &self,
210        _writer: &mut dyn std::io::Write,
211    ) -> Result<bool, SerializeError> {
212        Ok(false)
213    }
214
215    fn serialize_field(
216        &self,
217        field: &str,
218        writer: &mut dyn std::io::Write,
219    ) -> Result<bool, SerializeError> {
220        writer.write_all("\"".as_bytes())?;
221        writer.write_all(field.as_bytes())?;
222        writer.write_all("\":".as_bytes())?;
223        self.serialize_value(writer)?;
224
225        Ok(true)
226    }
227
228    fn is_fp_primitive(&self) -> bool {
229        false
230    }
231}
232
233impl serde::Serialize for Instant {
234    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
235    where
236        S: serde::Serializer,
237    {
238        self.to_string().serialize(serializer)
239    }
240}
241
242impl<'de> Deserialize<'de> for Instant {
243    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
244    where
245        D: serde::Deserializer<'de>,
246    {
247        let value = String::deserialize(deserializer)?;
248        parse_instant(&value).map_err(|_| serde::de::Error::custom("invalid FHIR instant"))
249    }
250}
251
252impl FHIRJSONDeserializer for Instant {
253    fn from_json_str(
254        s: &str,
255    ) -> Result<Self, haste_fhir_serialization_json::errors::DeserializeError> {
256        let mut json_value: Value = serde_json::from_str(s)?;
257        Instant::from_serde_value(&mut json_value, Context::AsValue)
258    }
259
260    fn from_serde_value(
261        value: *mut Value,
262        context: haste_fhir_serialization_json::Context,
263    ) -> Result<Self, haste_fhir_serialization_json::errors::DeserializeError> {
264        let value = unsafe { &mut *(value as *mut Value) };
265        let k = get_value(&value, &context)
266            .and_then(|v| v.as_str().and_then(|v| parse_instant(v).ok()));
267        k.ok_or_else(|| DeserializeError::FailedToConvertType("Instant".to_string()))
268    }
269}
270
271impl FHIRJSONSerializer for Instant {
272    fn serialize_value(&self, writer: &mut dyn std::io::Write) -> Result<bool, SerializeError> {
273        writer.write_all(&[b'"'])?;
274        writer.write_all(self.to_string().as_bytes())?;
275        writer.write_all(&[b'"'])?;
276
277        Ok(true)
278    }
279
280    fn serialize_extension(
281        &self,
282        _writer: &mut dyn std::io::Write,
283    ) -> Result<bool, SerializeError> {
284        Ok(false)
285    }
286
287    fn serialize_field(
288        &self,
289        field: &str,
290        writer: &mut dyn std::io::Write,
291    ) -> Result<bool, SerializeError> {
292        writer.write_all("\"".as_bytes())?;
293        writer.write_all(field.as_bytes())?;
294        writer.write_all("\":".as_bytes())?;
295        self.serialize_value(writer)?;
296
297        Ok(true)
298    }
299
300    fn is_fp_primitive(&self) -> bool {
301        false
302    }
303}
haste_fhir_model/r4/datetime/serialize.rs

haste_fhir_model/r4/datetime/
serialize.rs
