litl_val/from_other/
mod.rs

1use std::fmt::Display;
2
3use ordered_float::NotNan;
4use serde::{de::Visitor, Deserialize, Serialize, Serializer};
5use thiserror::Error;
6
7use super::{key::Key, key_e::KeyE, slim_boxed_slice::SlimBoxedSlice, Map, Val, ValE};
8
9pub fn to_val<T: Serialize>(value: T) -> Result<Val, <ToValSerializer as Serializer>::Error> {
10    value.serialize(ToValSerializer {})
11}
12
13pub struct ToValSerializer;
14
15impl Serializer for ToValSerializer {
16    type Ok = Val;
17
18    type Error = ToValError;
19
20    type SerializeSeq = SerializeVec;
21    type SerializeTuple = SerializeVec;
22    type SerializeTupleStruct = SerializeVec;
23    type SerializeTupleVariant = SerializeTupleVariant;
24    type SerializeMap = SerializeMap;
25    type SerializeStruct = SerializeMap;
26    type SerializeStructVariant = SerializeStructVariant;
27
28    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
29        Ok(ValE::Bool(v).into())
30    }
31
32    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
33        self.serialize_i64(v as i64)
34    }
35
36    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
37        self.serialize_i64(v as i64)
38    }
39
40    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
41        self.serialize_i64(v as i64)
42    }
43
44    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
45        self.serialize_f64(v as f64)
46    }
47
48    #[cfg(feature = "arbitrary_precision")]
49    fn serialize_i128(self, value: i128) -> Result<Value> {
50        Ok(ValE::Number(v.into()).into())
51    }
52
53    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
54        self.serialize_u64(v as u64)
55    }
56
57    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
58        self.serialize_u64(v as u64)
59    }
60
61    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
62        self.serialize_u64(v as u64)
63    }
64
65    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
66        self.serialize_f64(v as f64)
67    }
68
69    #[cfg(feature = "arbitrary_precision")]
70    fn serialize_u128(self, value: u128) -> Result<Value> {
71        Ok(ValE::Number(value.into()).into())
72    }
73
74    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
75        self.serialize_f64(v as f64)
76    }
77
78    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
79        // TODO: replace Nan and Infinity with null
80        Ok(ValE::Number(NotNan::new(v).unwrap()).into())
81    }
82
83    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
84        let mut buf = [0; 4];
85
86        Ok(ValE::str(v.encode_utf8(&mut buf)).into())
87    }
88
89    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
90        Ok(ValE::str(v).into())
91    }
92
93    // TODO: special holder for bytes that is semantically equivalent to array?
94    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
95        let vec = v
96            .iter()
97            .map(|&b| ValE::Number(NotNan::new(b as f64).unwrap()).into())
98            .collect();
99        Ok(ValE::Array(SlimBoxedSlice::from_vec(vec)).into())
100    }
101
102    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
103        self.serialize_unit()
104    }
105
106    fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
107    where
108        T: Serialize,
109    {
110        value.serialize(self)
111    }
112
113    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
114        Ok(ValE::Null.into())
115    }
116
117    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
118        self.serialize_unit()
119    }
120
121    fn serialize_unit_variant(
122        self,
123        _name: &'static str,
124        _variant_index: u32,
125        variant: &'static str,
126    ) -> Result<Self::Ok, Self::Error> {
127        self.serialize_str(variant)
128    }
129
130    fn serialize_newtype_struct<T: ?Sized>(
131        self,
132        _name: &'static str,
133        value: &T,
134    ) -> Result<Self::Ok, Self::Error>
135    where
136        T: Serialize,
137    {
138        value.serialize(self)
139    }
140
141    fn serialize_newtype_variant<T: ?Sized>(
142        self,
143        _name: &'static str,
144        _variant_index: u32,
145        variant: &'static str,
146        inner: &T,
147    ) -> Result<Self::Ok, Self::Error>
148    where
149        T: Serialize,
150    {
151        let pair = vec![(KeyE::str(variant).into(), to_val(inner)?)];
152        Ok(ValE::Object(Map::new(pair)).into())
153    }
154
155    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
156        Ok(SerializeVec {
157            // TODO: proper capacity from SlimBoxedSlice
158            vec: Vec::with_capacity(len.unwrap_or(0)),
159        })
160    }
161
162    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
163        self.serialize_seq(Some(len))
164    }
165
166    fn serialize_tuple_struct(
167        self,
168        _name: &'static str,
169        len: usize,
170    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
171        self.serialize_seq(Some(len))
172    }
173
174    fn serialize_tuple_variant(
175        self,
176        _name: &'static str,
177        _variant_index: u32,
178        variant: &'static str,
179        len: usize,
180    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
181        Ok(SerializeTupleVariant {
182            name: String::from(variant),
183            // TODO: proper capacity from SlimBoxedSlice
184            vec: Vec::with_capacity(len),
185        })
186    }
187
188    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
189        Ok(SerializeMap {
190            // TODO: proper capacity from SlimBoxedSlice
191            map: Vec::with_capacity(len.unwrap_or(5)),
192            next_key: None,
193        })
194    }
195
196    fn serialize_struct(
197        self,
198        _name: &'static str,
199        len: usize,
200    ) -> Result<Self::SerializeStruct, Self::Error> {
201        self.serialize_map(Some(len))
202    }
203
204    fn serialize_struct_variant(
205        self,
206        _name: &'static str,
207        _variant_index: u32,
208        _variant: &'static str,
209        _len: usize,
210    ) -> Result<Self::SerializeStructVariant, Self::Error> {
211        todo!()
212    }
213
214    fn collect_str<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
215    where
216        T: ?Sized + Display,
217    {
218        Ok(ValE::string(value.to_string()).into())
219    }
220}
221
222#[derive(Error, Debug)]
223pub enum ToValError {
224    #[error("Key must be a string")]
225    KeyMustBeAString,
226    #[error("Other: {0}")]
227    Other(String),
228}
229
230impl serde::ser::Error for ToValError {
231    fn custom<T>(msg: T) -> Self
232    where
233        T: Display,
234    {
235        ToValError::Other(msg.to_string())
236    }
237}
238
239pub struct SerializeVec {
240    vec: Vec<Val>,
241}
242
243pub struct SerializeTupleVariant {
244    name: String,
245    vec: Vec<Val>,
246}
247
248pub struct SerializeMap {
249    map: Vec<(Key, Val)>,
250    next_key: Option<String>,
251}
252
253pub struct SerializeStructVariant {
254    name: String,
255    map: Vec<(Key, Val)>,
256}
257
258impl serde::ser::SerializeSeq for SerializeVec {
259    type Ok = Val;
260    type Error = ToValError;
261
262    fn serialize_element<T>(&mut self, value: &T) -> Result<(), ToValError>
263    where
264        T: ?Sized + Serialize,
265    {
266        self.vec.push(to_val(value)?);
267        Ok(())
268    }
269
270    fn end(self) -> Result<Val, ToValError> {
271        Ok(ValE::Array(SlimBoxedSlice::from_vec(self.vec)).into())
272    }
273}
274
275impl serde::ser::SerializeTuple for SerializeVec {
276    type Ok = Val;
277    type Error = ToValError;
278
279    fn serialize_element<T>(&mut self, value: &T) -> Result<(), ToValError>
280    where
281        T: ?Sized + Serialize,
282    {
283        serde::ser::SerializeSeq::serialize_element(self, value)
284    }
285
286    fn end(self) -> Result<Val, ToValError> {
287        serde::ser::SerializeSeq::end(self)
288    }
289}
290
291impl serde::ser::SerializeTupleStruct for SerializeVec {
292    type Ok = Val;
293    type Error = ToValError;
294
295    fn serialize_field<T>(&mut self, value: &T) -> Result<(), ToValError>
296    where
297        T: ?Sized + Serialize,
298    {
299        serde::ser::SerializeSeq::serialize_element(self, value)
300    }
301
302    fn end(self) -> Result<Val, ToValError> {
303        serde::ser::SerializeSeq::end(self)
304    }
305}
306
307impl serde::ser::SerializeTupleVariant for SerializeTupleVariant {
308    type Ok = Val;
309    type Error = ToValError;
310
311    fn serialize_field<T>(&mut self, value: &T) -> Result<(), ToValError>
312    where
313        T: ?Sized + Serialize,
314    {
315        self.vec.push(to_val(value)?);
316        Ok(())
317    }
318
319    fn end(self) -> Result<Val, ToValError> {
320        Ok(ValE::Object(Map::new(vec![(
321            KeyE::string(self.name).into(),
322            ValE::Array(SlimBoxedSlice::from_vec(self.vec)).into(),
323        )]))
324        .into())
325    }
326}
327
328impl serde::ser::SerializeMap for SerializeMap {
329    type Ok = Val;
330    type Error = ToValError;
331
332    fn serialize_key<T>(&mut self, key: &T) -> Result<(), ToValError>
333    where
334        T: ?Sized + Serialize,
335    {
336        self.next_key = Some(key.serialize(map_key_serializer::MapKeySerializer)?);
337        Ok(())
338    }
339
340    fn serialize_value<T>(&mut self, value: &T) -> Result<(), ToValError>
341    where
342        T: ?Sized + Serialize,
343    {
344        let key = self.next_key.take();
345        // Panic because this indicates a bug in the program rather than an
346        // expected failure.
347        let key = key.expect("serialize_value called before serialize_key");
348        self.map.push((KeyE::string(key).into(), to_val(value)?));
349        Ok(())
350    }
351
352    fn end(self) -> Result<Val, ToValError> {
353        Ok(ValE::Object(Map::new(self.map)).into())
354    }
355}
356
357mod map_key_serializer;
358
359impl serde::ser::SerializeStruct for SerializeMap {
360    type Ok = Val;
361    type Error = ToValError;
362
363    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), ToValError>
364    where
365        T: ?Sized + Serialize,
366    {
367        serde::ser::SerializeMap::serialize_entry(self, key, value)
368    }
369
370    fn end(self) -> Result<Val, ToValError> {
371        serde::ser::SerializeMap::end(self)
372    }
373}
374
375impl serde::ser::SerializeStructVariant for SerializeStructVariant {
376    type Ok = Val;
377    type Error = ToValError;
378
379    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), ToValError>
380    where
381        T: ?Sized + Serialize,
382    {
383        self.map.push((KeyE::str(key).into(), to_val(value)?));
384        Ok(())
385    }
386
387    fn end(self) -> Result<Val, ToValError> {
388        Ok(ValE::Object(Map::new(vec![(
389            KeyE::string(self.name).into(),
390            ValE::Object(Map::new(self.map)).into(),
391        )]))
392        .into())
393    }
394}
395
396impl<'de> Deserialize<'de> for Val {
397    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
398    where
399        D: serde::Deserializer<'de>,
400    {
401        deserializer.deserialize_any(ValVisitor)
402    }
403}
404
405struct ValVisitor;
406
407impl<'de> Visitor<'de> for ValVisitor {
408    type Value = Val;
409
410    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
411        write!(formatter, "Any valid JSON")
412    }
413
414    #[inline]
415    fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
416    where
417        E: serde::de::Error,
418    {
419        Ok(ValE::Bool(v).into())
420    }
421
422    #[inline]
423    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
424    where
425        E: serde::de::Error,
426    {
427        Ok(ValE::Number(NotNan::new(v as f64).unwrap()).into())
428    }
429
430    #[inline]
431    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
432    where
433        E: serde::de::Error,
434    {
435        Ok(ValE::Number(NotNan::new(v as f64).unwrap()).into())
436    }
437
438    #[inline]
439    fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
440    where
441        E: serde::de::Error,
442    {
443        Ok(ValE::Number(NotNan::new(v).unwrap()).into())
444    }
445
446    #[inline]
447    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
448    where
449        E: serde::de::Error,
450    {
451        Ok(ValE::str(v).into())
452    }
453
454    #[inline]
455    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
456    where
457        E: serde::de::Error,
458    {
459        Ok(ValE::string(v).into())
460    }
461
462    #[inline]
463    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
464    where
465        E: serde::de::Error,
466    {
467        let vec = v
468            .iter()
469            .map(|&b| ValE::Number(NotNan::new(b as f64).unwrap()).into())
470            .collect();
471        Ok(ValE::Array(SlimBoxedSlice::from_vec(vec)).into())
472    }
473
474    #[inline]
475    fn visit_none<E>(self) -> Result<Self::Value, E>
476    where
477        E: serde::de::Error,
478    {
479        Ok(ValE::Null.into())
480    }
481
482    #[inline]
483    fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
484    where
485        D: serde::Deserializer<'de>,
486    {
487        Deserialize::deserialize(deserializer)
488    }
489
490    #[inline]
491    fn visit_unit<E>(self) -> Result<Self::Value, E>
492    where
493        E: serde::de::Error,
494    {
495        Ok(ValE::Null.into())
496    }
497
498    #[inline]
499    fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
500    where
501        D: serde::Deserializer<'de>,
502    {
503        Deserialize::deserialize(deserializer)
504    }
505
506    #[inline]
507    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
508    where
509        A: serde::de::SeqAccess<'de>,
510    {
511        // TODO: proper capacity for SlimBoxedSlice
512        let mut vec = Vec::new();
513
514        while let Some(value) = seq.next_element()? {
515            vec.push(value);
516        }
517
518        Ok(ValE::Array(SlimBoxedSlice::from_vec(vec)).into())
519    }
520
521    #[inline]
522    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
523    where
524        A: serde::de::MapAccess<'de>,
525    {
526        let mut vec = Vec::new();
527
528        while let Some((key, value)) = map.next_entry()? {
529            vec.push((key, value));
530        }
531
532        Ok(ValE::Object(Map::new(vec)).into())
533    }
534}
535
536impl<'de> Deserialize<'de> for Key {
537    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
538    where
539        D: serde::Deserializer<'de>,
540    {
541        let val = deserializer.deserialize_any(ValVisitor)?;
542        Key::try_from(val).map_err(|e| serde::de::Error::custom(e.to_string()))
543    }
544}
545
546impl From<serde_json::Value> for ValE {
547    #[inline]
548    fn from(val: serde_json::Value) -> Self {
549        match val {
550            serde_json::Value::Null => ValE::Null,
551            serde_json::Value::Bool(b) => ValE::Bool(b),
552            serde_json::Value::Number(n) => ValE::Number(NotNan::new(n.as_f64().unwrap()).unwrap()),
553            serde_json::Value::String(s) => ValE::string(s),
554            serde_json::Value::Array(a) => ValE::Array(SlimBoxedSlice::from_vec(
555                a.into_iter().map(Val::from).collect(),
556            )),
557            serde_json::Value::Object(o) => ValE::Object(Map::new(
558                o.into_iter()
559                    .map(|(k, v)| (KeyE::string(k).into(), Val::from(v)))
560                    .collect(),
561            )),
562        }
563    }
564}
565
566impl From<serde_json::Value> for Val {
567    #[inline]
568    fn from(val: serde_json::Value) -> Self {
569        ValE::from(val).into()
570    }
571}
litl_val/from_other/mod.rs

litl_val/from_other/
mod.rs
