1use serde::de;
2use serde_json::{Error, Value};
3
4pub struct Deserializer<'de> {
5 input: &'de Value,
6}
7
8impl<'de> Deserializer<'de> {
9 pub fn from_value(input: &'de Value) -> Self {
10 Deserializer { input }
11 }
12}
13
14impl<'de> de::Deserializer<'de> for &mut Deserializer<'de> {
15 type Error = Error;
16
17 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
18 where
19 V: de::Visitor<'de>,
20 {
21 self.input.deserialize_any(visitor)
22 }
23
24 fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
25 where
26 V: de::Visitor<'de>,
27 {
28 self.input.deserialize_bool(visitor)
29 }
30
31 fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
32 where
33 V: de::Visitor<'de>,
34 {
35 self.input.deserialize_i8(visitor)
36 }
37
38 fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
39 where
40 V: de::Visitor<'de>,
41 {
42 self.input.deserialize_i16(visitor)
43 }
44
45 fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
46 where
47 V: de::Visitor<'de>,
48 {
49 self.input.deserialize_i32(visitor)
50 }
51
52 fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
53 where
54 V: de::Visitor<'de>,
55 {
56 self.input.deserialize_i64(visitor)
57 }
58
59 fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
60 where
61 V: de::Visitor<'de>,
62 {
63 self.input.deserialize_u8(visitor)
64 }
65
66 fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
67 where
68 V: de::Visitor<'de>,
69 {
70 self.input.deserialize_u16(visitor)
71 }
72
73 fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
74 where
75 V: de::Visitor<'de>,
76 {
77 self.input.deserialize_u32(visitor)
78 }
79
80 fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
81 where
82 V: de::Visitor<'de>,
83 {
84 self.input.deserialize_u64(visitor)
85 }
86
87 fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
88 where
89 V: de::Visitor<'de>,
90 {
91 self.input.deserialize_f32(visitor)
92 }
93
94 fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
95 where
96 V: de::Visitor<'de>,
97 {
98 self.input.deserialize_f64(visitor)
99 }
100
101 fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
102 where
103 V: de::Visitor<'de>,
104 {
105 self.input.deserialize_char(visitor)
106 }
107
108 fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
109 where
110 V: de::Visitor<'de>,
111 {
112 self.input.deserialize_str(visitor)
113 }
114
115 fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
116 where
117 V: de::Visitor<'de>,
118 {
119 self.input.deserialize_string(visitor)
120 }
121
122 fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
123 where
124 V: de::Visitor<'de>,
125 {
126 self.input.deserialize_bytes(visitor)
127 }
128
129 fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
130 where
131 V: de::Visitor<'de>,
132 {
133 self.input.deserialize_byte_buf(visitor)
134 }
135
136 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
137 where
138 V: de::Visitor<'de>,
139 {
140 self.input.deserialize_option(visitor)
141 }
142
143 fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
144 where
145 V: de::Visitor<'de>,
146 {
147 self.input.deserialize_unit(visitor)
148 }
149
150 fn deserialize_unit_struct<V>(
151 self,
152 name: &'static str,
153 visitor: V,
154 ) -> Result<V::Value, Self::Error>
155 where
156 V: de::Visitor<'de>,
157 {
158 self.input.deserialize_unit_struct(name, visitor)
159 }
160
161 fn deserialize_newtype_struct<V>(
162 self,
163 name: &'static str,
164 visitor: V,
165 ) -> Result<V::Value, Self::Error>
166 where
167 V: de::Visitor<'de>,
168 {
169 self.input.deserialize_newtype_struct(name, visitor)
170 }
171
172 fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
173 where
174 V: de::Visitor<'de>,
175 {
176 self.input.deserialize_seq(visitor)
177 }
178
179 fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
180 where
181 V: de::Visitor<'de>,
182 {
183 self.input.deserialize_tuple(len, visitor)
184 }
185
186 fn deserialize_tuple_struct<V>(
187 self,
188 name: &'static str,
189 len: usize,
190 visitor: V,
191 ) -> Result<V::Value, Self::Error>
192 where
193 V: de::Visitor<'de>,
194 {
195 self.input.deserialize_tuple_struct(name, len, visitor)
196 }
197
198 fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
199 where
200 V: de::Visitor<'de>,
201 {
202 self.input.deserialize_map(visitor)
203 }
204
205 fn deserialize_struct<V>(
206 self,
207 name: &'static str,
208 fields: &'static [&'static str],
209 visitor: V,
210 ) -> Result<V::Value, Self::Error>
211 where
212 V: de::Visitor<'de>,
213 {
214 self.input.deserialize_struct(name, fields, visitor)
215 }
216
217 fn deserialize_enum<V>(
218 self,
219 name: &'static str,
220 variants: &'static [&'static str],
221 visitor: V,
222 ) -> Result<V::Value, Self::Error>
223 where
224 V: de::Visitor<'de>,
225 {
226 self.input.deserialize_enum(name, variants, visitor)
227 }
228
229 fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
230 where
231 V: de::Visitor<'de>,
232 {
233 self.input.deserialize_identifier(visitor)
234 }
235
236 fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
237 where
238 V: de::Visitor<'de>,
239 {
240 self.input.deserialize_ignored_any(visitor)
241 }
242}
243
244#[cfg(test)]
245mod tests {
246 #[allow(deprecated)]
247 use super::*;
248 use serde::{Deserialize, Serialize};
249
250 #[derive(Serialize, Deserialize, Debug)]
251 struct Test {
252 name: String,
253 }
254
255 #[test]
256 fn test_wrapper() {
257 let data = r#"
258 {
259 "name": "123"
260 }"#;
261
262 let v: Value = serde_json::from_str(data).unwrap();
263
264 let jd = &mut Deserializer::from_value(&v);
265
266 let r: Result<Test, _> = serde_path_to_error::deserialize(jd);
267
268 println!("{r:?}");
269 }
270}