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

haste_fhir_model/r4/datetime/
serialize.rs
