typed_json/
lib.rs

1#![doc = include_str!("../README.md")]
2#![cfg_attr(not(feature = "std"), no_std)]
3#![cfg_attr(docsrs, feature(doc_auto_cfg))]
4
5use expr_de::Expr;
6
7#[macro_use]
8mod macros;
9mod expr_de;
10
11#[cfg(feature = "std")]
12mod fmt;
13
14mod array;
15mod map;
16
17#[doc(hidden)]
18pub mod __private {
19    pub use crate::array::Array;
20    pub use crate::expr_de::Expr;
21    pub use crate::map::{Map, KV};
22    pub use crate::Null;
23}
24
25/// A clone of [`serde::de::Deserializer`] to get around the orphan rule
26pub trait Deserializer<'de>: Sized {
27    /// Require the `Deserializer` to figure out how to drive the visitor based
28    /// on what data type is in the input.
29    fn deserialize_any2<V>(self, visitor: V) -> Result<V::Value, serde::de::value::Error>
30    where
31        V: serde::de::Visitor<'de>;
32}
33
34impl<S1: serde::ser::Serialize> serde::ser::Serialize for Expr<S1> {
35    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
36    where
37        S: serde::Serializer,
38    {
39        self.0.serialize(serializer)
40    }
41}
42
43#[derive(Clone, Copy)]
44#[doc(hidden)]
45pub struct Null;
46
47impl<'de> crate::Deserializer<'de> for Null {
48    fn deserialize_any2<V>(self, visitor: V) -> Result<V::Value, serde::de::value::Error>
49    where
50        V: serde::de::Visitor<'de>,
51    {
52        visitor.visit_none()
53    }
54}
55
56impl<'de> serde::de::Deserializer<'de> for Null {
57    type Error = serde::de::value::Error;
58
59    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
60    where
61        V: serde::de::Visitor<'de>,
62    {
63        visitor.visit_none()
64    }
65
66    serde::forward_to_deserialize_any! {
67        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
68        bytes byte_buf option unit unit_struct newtype_struct seq tuple
69        tuple_struct map struct enum identifier ignored_any
70    }
71}
72
73impl serde::ser::Serialize for Null {
74    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
75    where
76        S: serde::Serializer,
77    {
78        serializer.serialize_none()
79    }
80}
81
82trait DeShared {
83    fn is_done(&self) -> bool;
84}
85
86impl<T> DeShared for Option<T> {
87    fn is_done(&self) -> bool {
88        self.is_none()
89    }
90}
91
92impl<T, U> DeShared for (T, U)
93where
94    T: DeShared,
95    U: DeShared,
96{
97    fn is_done(&self) -> bool {
98        self.0.is_done() && self.1.is_done()
99    }
100}
101
102impl DeShared for () {
103    fn is_done(&self) -> bool {
104        true
105    }
106}
107
108#[cfg(test)]
109mod tests {
110    use std::collections::BTreeMap;
111
112    use serde::Deserialize;
113    use serde_test::Token;
114
115    #[derive(Debug, Deserialize)]
116    struct Something {
117        foo: i32,
118    }
119
120    #[test]
121    fn object() {
122        let data = json!({"foo": 123});
123        let x = Something::deserialize(data).unwrap();
124        let y = <BTreeMap<String, i32>>::deserialize(data).unwrap();
125        assert_eq!(x.foo, 123);
126        assert_eq!(y["foo"], 123);
127    }
128
129    #[test]
130    fn object_ser() {
131        serde_test::assert_ser_tokens(
132            &json!({"foo": 123}),
133            &[
134                Token::Map { len: Some(1) },
135                Token::Str("foo"),
136                Token::I32(123),
137                Token::MapEnd,
138            ],
139        );
140    }
141
142    #[test]
143    fn array() {
144        let data = json!([123, 456]);
145        let x = <[i32; 2]>::deserialize(data).unwrap();
146        let y = <Vec<i32>>::deserialize(data).unwrap();
147        assert_eq!(x, [123, 456]);
148        assert_eq!(y, [123, 456]);
149    }
150
151    #[test]
152    fn array_ser() {
153        serde_test::assert_ser_tokens(
154            &json!([123, 456]),
155            &[
156                Token::Seq { len: Some(2) },
157                Token::I32(123),
158                Token::I32(456),
159                Token::SeqEnd,
160            ],
161        );
162    }
163
164    #[test]
165    fn complex_ser() {
166        let value1 = 123;
167        let value2 = 456;
168        let value3 = format!("hello {}", "world");
169
170        let data = json!({
171            "codes": [400u64, value1, value2, 1, 2, 3, 4, 5],
172            "message": value3,
173            "contact": "contact support at support@example.com",
174        });
175
176        serde_test::assert_ser_tokens(
177            &data,
178            &[
179                Token::Map { len: Some(3) },
180                Token::Str("codes"),
181                Token::Seq { len: Some(8) },
182                Token::U64(400),
183                Token::I32(123),
184                Token::I32(456),
185                Token::I32(1),
186                Token::I32(2),
187                Token::I32(3),
188                Token::I32(4),
189                Token::I32(5),
190                Token::SeqEnd,
191                Token::Str("message"),
192                Token::Str("hello world"),
193                Token::Str("contact"),
194                Token::Str("contact support at support@example.com"),
195                Token::MapEnd,
196            ],
197        );
198    }
199}
typed_json/lib.rs

typed_json/
lib.rs
