1use std::{error::Error, io};
2
3use serde::{de::DeserializeOwned, ser::Serialize};
4use serde_json::{
5 de::{IoRead, SliceRead},
6 de::{Read, StrRead},
7 ser::Formatter,
8 Deserializer, Serializer, Value,
9};
10
11use crate::model;
12
13use self::model_conv::ModelConv;
14
15mod model_conv;
16
17pub trait JsonSerde
18where
19 Self: Sized,
20{
21 fn read_json<'de, R: Read<'de>>(deserializer: Deserializer<R>) -> Result<Self, Box<dyn Error>>;
22 fn write_json<W: io::Write, F: Formatter>(
23 &self,
24 serializer: &mut Serializer<W, F>,
25 ) -> Result<(), Box<dyn Error>>;
26
27 fn from_value(value: &Value) -> Result<Self, Box<dyn Error>>;
28 fn to_value(&self) -> Result<Value, Box<dyn Error>>;
29
30 fn from_json_reader<'de, R: Read<'de>>(reader: R) -> Result<Self, Box<dyn Error>> {
31 let de = Deserializer::new(reader);
32 Self::read_json(de)
33 }
34
35 fn io_read_json<R: io::Read>(reader: R) -> Result<Self, Box<dyn Error>> {
36 Self::from_json_reader(IoRead::new(reader))
37 }
38
39 fn io_write_json<W: io::Write>(&self, writer: W) -> Result<(), Box<dyn Error>> {
40 let mut ser = Serializer::new(writer);
41 self.write_json(&mut ser)
42 }
43
44 fn io_write_pretty_json<W: io::Write>(&self, writer: W) -> Result<(), Box<dyn Error>> {
45 let mut ser = Serializer::pretty(writer);
46 self.write_json(&mut ser)
47 }
48
49 fn from_json_bytes<'a>(bytes: &'a [u8]) -> Result<Self, Box<dyn Error>> {
50 Self::from_json_reader(SliceRead::new(bytes))
51 }
52
53 fn to_json_bytes(&self) -> Result<Vec<u8>, Box<dyn Error>> {
54 let mut writer = Vec::with_capacity(128);
55 self.io_write_json(&mut writer)?;
56 Ok(writer)
57 }
58
59 fn to_json_bytes_pretty(&self) -> Result<Vec<u8>, Box<dyn Error>> {
60 let mut writer = Vec::with_capacity(128);
61 self.io_write_pretty_json(&mut writer)?;
62 Ok(writer)
63 }
64
65 fn from_json_str<'a>(str: &'a str) -> Result<Self, Box<dyn Error>> {
66 Self::from_json_reader(StrRead::new(str))
67 }
68
69 fn to_json_string(&self) -> Result<String, Box<dyn Error>> {
70 let bytes = self.to_json_bytes()?;
71 Ok(unsafe { String::from_utf8_unchecked(bytes) })
72 }
73
74 fn to_string_pretty(&self) -> Result<String, Box<dyn Error>> {
75 let bytes = self.to_json_bytes_pretty()?;
76 Ok(unsafe { String::from_utf8_unchecked(bytes) })
77 }
78}
79
80pub struct SerdeJsonValue<T> {
81 pub value: T,
82}
83
84impl<T: Serialize + DeserializeOwned> SerdeJsonValue<T> {
85 pub fn new(value: T) -> Self {
86 Self { value }
87 }
88}
89
90impl<T: Serialize + DeserializeOwned> JsonSerde for SerdeJsonValue<T> {
91 fn read_json<'de, R: Read<'de>>(
92 mut deserializer: Deserializer<R>,
93 ) -> Result<Self, Box<dyn Error>> {
94 let value: T = serde::de::Deserialize::deserialize(&mut deserializer)?;
95 deserializer.end()?;
96 Ok(SerdeJsonValue { value })
97 }
98
99 fn write_json<W: io::Write, F: Formatter>(
100 &self,
101 serializer: &mut Serializer<W, F>,
102 ) -> Result<(), Box<dyn Error>> {
103 self.value.serialize(serializer)?;
104 Ok(())
105 }
106
107 fn from_value(value: &Value) -> Result<Self, Box<dyn Error>> {
108 let value: T = serde::de::Deserialize::deserialize(value)?;
109 Ok(SerdeJsonValue { value })
110 }
111
112 fn to_value(&self) -> Result<Value, Box<dyn Error>> {
113 Ok(serde_json::to_value(&self.value)?)
114 }
115}
116
117impl JsonSerde for model::Context {
118 fn read_json<'de, R: Read<'de>>(
119 mut deserializer: Deserializer<R>,
120 ) -> Result<Self, Box<dyn Error>> {
121 let value: <Self as ModelConv>::JsonSerdeValue =
122 serde::de::Deserialize::deserialize(&mut deserializer)?;
123 deserializer.end()?;
124 Ok(ModelConv::to_model(value)?)
125 }
126
127 fn write_json<W: io::Write, F: Formatter>(
128 &self,
129 serializer: &mut Serializer<W, F>,
130 ) -> Result<(), Box<dyn Error>> {
131 let value = self.from_model()?;
132 value.serialize(serializer)?;
133 Ok(())
134 }
135
136 fn from_value(value: &Value) -> Result<Self, Box<dyn Error>> {
137 let value: <Self as ModelConv>::JsonSerdeValue =
138 serde::de::Deserialize::deserialize(value)?;
139 Ok(ModelConv::to_model(value)?)
140 }
141
142 fn to_value(&self) -> Result<Value, Box<dyn Error>> {
143 Ok(serde_json::to_value(self.from_model()?)?)
144 }
145}
146
147impl JsonSerde for model::Object {
148 fn read_json<'de, R: Read<'de>>(
149 mut deserializer: Deserializer<R>,
150 ) -> Result<Self, Box<dyn Error>> {
151 let value: <Self as ModelConv>::JsonSerdeValue =
152 serde::de::Deserialize::deserialize(&mut deserializer)?;
153 deserializer.end()?;
154 Ok(ModelConv::to_model(value)?)
155 }
156
157 fn write_json<W: io::Write, F: Formatter>(
158 &self,
159 serializer: &mut Serializer<W, F>,
160 ) -> Result<(), Box<dyn Error>> {
161 let value = self.from_model()?;
162 value.serialize(serializer)?;
163 Ok(())
164 }
165
166 fn from_value(value: &Value) -> Result<Self, Box<dyn Error>> {
167 let value: <Self as ModelConv>::JsonSerdeValue =
168 serde::de::Deserialize::deserialize(value)?;
169 Ok(ModelConv::to_model(value)?)
170 }
171
172 fn to_value(&self) -> Result<Value, Box<dyn Error>> {
173 Ok(serde_json::to_value(self.from_model()?)?)
174 }
175}
176
177impl JsonSerde for model::Link {
178 fn read_json<'de, R: Read<'de>>(
179 mut deserializer: Deserializer<R>,
180 ) -> Result<Self, Box<dyn Error>> {
181 let value: <Self as ModelConv>::JsonSerdeValue =
182 serde::de::Deserialize::deserialize(&mut deserializer)?;
183 deserializer.end()?;
184 Ok(ModelConv::to_model(value)?)
185 }
186
187 fn write_json<W: io::Write, F: Formatter>(
188 &self,
189 serializer: &mut Serializer<W, F>,
190 ) -> Result<(), Box<dyn Error>> {
191 let value = self.from_model()?;
192 value.serialize(serializer)?;
193 Ok(())
194 }
195
196 fn from_value(value: &Value) -> Result<Self, Box<dyn Error>> {
197 let value: <Self as ModelConv>::JsonSerdeValue =
198 serde::de::Deserialize::deserialize(value)?;
199 Ok(ModelConv::to_model(value)?)
200 }
201
202 fn to_value(&self) -> Result<Value, Box<dyn Error>> {
203 Ok(serde_json::to_value(self.from_model()?)?)
204 }
205}
206
207impl JsonSerde for model::ObjectOrLink {
208 fn read_json<'de, R: Read<'de>>(
209 mut deserializer: Deserializer<R>,
210 ) -> Result<Self, Box<dyn Error>> {
211 let value: <Self as ModelConv>::JsonSerdeValue =
212 serde::de::Deserialize::deserialize(&mut deserializer)?;
213 deserializer.end()?;
214 Ok(ModelConv::to_model(value)?)
215 }
216
217 fn write_json<W: io::Write, F: Formatter>(
218 &self,
219 serializer: &mut Serializer<W, F>,
220 ) -> Result<(), Box<dyn Error>> {
221 let value = self.from_model()?;
222 value.serialize(serializer)?;
223 Ok(())
224 }
225
226 fn from_value(value: &Value) -> Result<Self, Box<dyn Error>> {
227 let value: <Self as ModelConv>::JsonSerdeValue =
228 serde::de::Deserialize::deserialize(value)?;
229 Ok(ModelConv::to_model(value)?)
230 }
231
232 fn to_value(&self) -> Result<Value, Box<dyn Error>> {
233 Ok(serde_json::to_value(self.from_model()?)?)
234 }
235}