• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 use serde::{Deserialize, Serialize};
2 pub struct GenericStruct<T> {
3     x: T,
4 }
5 #[doc(hidden)]
6 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
7 const _: () = {
8     #[allow(unused_extern_crates, clippy::useless_attribute)]
9     extern crate serde as _serde;
10     #[automatically_derived]
11     impl<T> _serde::Serialize for GenericStruct<T>
12     where
13         T: _serde::Serialize,
14     {
serialize<__S>( &self, __serializer: __S, ) -> _serde::__private::Result<__S::Ok, __S::Error> where __S: _serde::Serializer,15         fn serialize<__S>(
16             &self,
17             __serializer: __S,
18         ) -> _serde::__private::Result<__S::Ok, __S::Error>
19         where
20             __S: _serde::Serializer,
21         {
22             let mut __serde_state = match _serde::Serializer::serialize_struct(
23                 __serializer,
24                 "GenericStruct",
25                 false as usize + 1,
26             ) {
27                 _serde::__private::Ok(__val) => __val,
28                 _serde::__private::Err(__err) => {
29                     return _serde::__private::Err(__err);
30                 }
31             };
32             match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, "x", &self.x) {
33                 _serde::__private::Ok(__val) => __val,
34                 _serde::__private::Err(__err) => {
35                     return _serde::__private::Err(__err);
36                 }
37             };
38             _serde::ser::SerializeStruct::end(__serde_state)
39         }
40     }
41 };
42 #[doc(hidden)]
43 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
44 const _: () = {
45     #[allow(unused_extern_crates, clippy::useless_attribute)]
46     extern crate serde as _serde;
47     #[automatically_derived]
48     impl<'de, T> _serde::Deserialize<'de> for GenericStruct<T>
49     where
50         T: _serde::Deserialize<'de>,
51     {
deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error> where __D: _serde::Deserializer<'de>,52         fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
53         where
54             __D: _serde::Deserializer<'de>,
55         {
56             #[allow(non_camel_case_types)]
57             enum __Field {
58                 __field0,
59                 __ignore,
60             }
61             struct __FieldVisitor;
62             impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
63                 type Value = __Field;
64                 fn expecting(
65                     &self,
66                     __formatter: &mut _serde::__private::Formatter,
67                 ) -> _serde::__private::fmt::Result {
68                     _serde::__private::Formatter::write_str(__formatter, "field identifier")
69                 }
70                 fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
71                 where
72                     __E: _serde::de::Error,
73                 {
74                     match __value {
75                         0u64 => _serde::__private::Ok(__Field::__field0),
76                         _ => _serde::__private::Ok(__Field::__ignore),
77                     }
78                 }
79                 fn visit_str<__E>(
80                     self,
81                     __value: &str,
82                 ) -> _serde::__private::Result<Self::Value, __E>
83                 where
84                     __E: _serde::de::Error,
85                 {
86                     match __value {
87                         "x" => _serde::__private::Ok(__Field::__field0),
88                         _ => _serde::__private::Ok(__Field::__ignore),
89                     }
90                 }
91                 fn visit_bytes<__E>(
92                     self,
93                     __value: &[u8],
94                 ) -> _serde::__private::Result<Self::Value, __E>
95                 where
96                     __E: _serde::de::Error,
97                 {
98                     match __value {
99                         b"x" => _serde::__private::Ok(__Field::__field0),
100                         _ => _serde::__private::Ok(__Field::__ignore),
101                     }
102                 }
103             }
104             impl<'de> _serde::Deserialize<'de> for __Field {
105                 #[inline]
106                 fn deserialize<__D>(
107                     __deserializer: __D,
108                 ) -> _serde::__private::Result<Self, __D::Error>
109                 where
110                     __D: _serde::Deserializer<'de>,
111                 {
112                     _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
113                 }
114             }
115             struct __Visitor<'de, T>
116             where
117                 T: _serde::Deserialize<'de>,
118             {
119                 marker: _serde::__private::PhantomData<GenericStruct<T>>,
120                 lifetime: _serde::__private::PhantomData<&'de ()>,
121             }
122             impl<'de, T> _serde::de::Visitor<'de> for __Visitor<'de, T>
123             where
124                 T: _serde::Deserialize<'de>,
125             {
126                 type Value = GenericStruct<T>;
127                 fn expecting(
128                     &self,
129                     __formatter: &mut _serde::__private::Formatter,
130                 ) -> _serde::__private::fmt::Result {
131                     _serde::__private::Formatter::write_str(__formatter, "struct GenericStruct")
132                 }
133                 #[inline]
134                 fn visit_seq<__A>(
135                     self,
136                     mut __seq: __A,
137                 ) -> _serde::__private::Result<Self::Value, __A::Error>
138                 where
139                     __A: _serde::de::SeqAccess<'de>,
140                 {
141                     let __field0 = match match _serde::de::SeqAccess::next_element::<T>(&mut __seq)
142                     {
143                         _serde::__private::Ok(__val) => __val,
144                         _serde::__private::Err(__err) => {
145                             return _serde::__private::Err(__err);
146                         }
147                     } {
148                         _serde::__private::Some(__value) => __value,
149                         _serde::__private::None => {
150                             return _serde::__private::Err(_serde::de::Error::invalid_length(
151                                 0usize,
152                                 &"struct GenericStruct with 1 element",
153                             ));
154                         }
155                     };
156                     _serde::__private::Ok(GenericStruct { x: __field0 })
157                 }
158                 #[inline]
159                 fn visit_map<__A>(
160                     self,
161                     mut __map: __A,
162                 ) -> _serde::__private::Result<Self::Value, __A::Error>
163                 where
164                     __A: _serde::de::MapAccess<'de>,
165                 {
166                     let mut __field0: _serde::__private::Option<T> = _serde::__private::None;
167                     while let _serde::__private::Some(__key) =
168                         match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
169                             _serde::__private::Ok(__val) => __val,
170                             _serde::__private::Err(__err) => {
171                                 return _serde::__private::Err(__err);
172                             }
173                         }
174                     {
175                         match __key {
176                             __Field::__field0 => {
177                                 if _serde::__private::Option::is_some(&__field0) {
178                                     return _serde::__private::Err(
179                                         <__A::Error as _serde::de::Error>::duplicate_field("x"),
180                                     );
181                                 }
182                                 __field0 = _serde::__private::Some(
183                                     match _serde::de::MapAccess::next_value::<T>(&mut __map) {
184                                         _serde::__private::Ok(__val) => __val,
185                                         _serde::__private::Err(__err) => {
186                                             return _serde::__private::Err(__err);
187                                         }
188                                     },
189                                 );
190                             }
191                             _ => {
192                                 let _ = match _serde::de::MapAccess::next_value::<
193                                     _serde::de::IgnoredAny,
194                                 >(&mut __map)
195                                 {
196                                     _serde::__private::Ok(__val) => __val,
197                                     _serde::__private::Err(__err) => {
198                                         return _serde::__private::Err(__err);
199                                     }
200                                 };
201                             }
202                         }
203                     }
204                     let __field0 = match __field0 {
205                         _serde::__private::Some(__field0) => __field0,
206                         _serde::__private::None => {
207                             match _serde::__private::de::missing_field("x") {
208                                 _serde::__private::Ok(__val) => __val,
209                                 _serde::__private::Err(__err) => {
210                                     return _serde::__private::Err(__err);
211                                 }
212                             }
213                         }
214                     };
215                     _serde::__private::Ok(GenericStruct { x: __field0 })
216                 }
217             }
218             const FIELDS: &'static [&'static str] = &["x"];
219             _serde::Deserializer::deserialize_struct(
220                 __deserializer,
221                 "GenericStruct",
222                 FIELDS,
223                 __Visitor {
224                     marker: _serde::__private::PhantomData::<GenericStruct<T>>,
225                     lifetime: _serde::__private::PhantomData,
226                 },
227             )
228         }
deserialize_in_place<__D>( __deserializer: __D, __place: &mut Self, ) -> _serde::__private::Result<(), __D::Error> where __D: _serde::Deserializer<'de>,229         fn deserialize_in_place<__D>(
230             __deserializer: __D,
231             __place: &mut Self,
232         ) -> _serde::__private::Result<(), __D::Error>
233         where
234             __D: _serde::Deserializer<'de>,
235         {
236             #[allow(non_camel_case_types)]
237             enum __Field {
238                 __field0,
239                 __ignore,
240             }
241             struct __FieldVisitor;
242             impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
243                 type Value = __Field;
244                 fn expecting(
245                     &self,
246                     __formatter: &mut _serde::__private::Formatter,
247                 ) -> _serde::__private::fmt::Result {
248                     _serde::__private::Formatter::write_str(__formatter, "field identifier")
249                 }
250                 fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
251                 where
252                     __E: _serde::de::Error,
253                 {
254                     match __value {
255                         0u64 => _serde::__private::Ok(__Field::__field0),
256                         _ => _serde::__private::Ok(__Field::__ignore),
257                     }
258                 }
259                 fn visit_str<__E>(
260                     self,
261                     __value: &str,
262                 ) -> _serde::__private::Result<Self::Value, __E>
263                 where
264                     __E: _serde::de::Error,
265                 {
266                     match __value {
267                         "x" => _serde::__private::Ok(__Field::__field0),
268                         _ => _serde::__private::Ok(__Field::__ignore),
269                     }
270                 }
271                 fn visit_bytes<__E>(
272                     self,
273                     __value: &[u8],
274                 ) -> _serde::__private::Result<Self::Value, __E>
275                 where
276                     __E: _serde::de::Error,
277                 {
278                     match __value {
279                         b"x" => _serde::__private::Ok(__Field::__field0),
280                         _ => _serde::__private::Ok(__Field::__ignore),
281                     }
282                 }
283             }
284             impl<'de> _serde::Deserialize<'de> for __Field {
285                 #[inline]
286                 fn deserialize<__D>(
287                     __deserializer: __D,
288                 ) -> _serde::__private::Result<Self, __D::Error>
289                 where
290                     __D: _serde::Deserializer<'de>,
291                 {
292                     _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
293                 }
294             }
295             struct __Visitor<'de, 'place, T: 'place>
296             where
297                 T: _serde::Deserialize<'de>,
298             {
299                 place: &'place mut GenericStruct<T>,
300                 lifetime: _serde::__private::PhantomData<&'de ()>,
301             }
302             impl<'de, 'place, T: 'place> _serde::de::Visitor<'de> for __Visitor<'de, 'place, T>
303             where
304                 T: _serde::Deserialize<'de>,
305             {
306                 type Value = ();
307                 fn expecting(
308                     &self,
309                     __formatter: &mut _serde::__private::Formatter,
310                 ) -> _serde::__private::fmt::Result {
311                     _serde::__private::Formatter::write_str(__formatter, "struct GenericStruct")
312                 }
313                 #[inline]
314                 fn visit_seq<__A>(
315                     self,
316                     mut __seq: __A,
317                 ) -> _serde::__private::Result<Self::Value, __A::Error>
318                 where
319                     __A: _serde::de::SeqAccess<'de>,
320                 {
321                     if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
322                         &mut __seq,
323                         _serde::__private::de::InPlaceSeed(&mut self.place.x),
324                     ) {
325                         _serde::__private::Ok(__val) => __val,
326                         _serde::__private::Err(__err) => {
327                             return _serde::__private::Err(__err);
328                         }
329                     } {
330                         return _serde::__private::Err(_serde::de::Error::invalid_length(
331                             0usize,
332                             &"struct GenericStruct with 1 element",
333                         ));
334                     }
335                     _serde::__private::Ok(())
336                 }
337                 #[inline]
338                 fn visit_map<__A>(
339                     self,
340                     mut __map: __A,
341                 ) -> _serde::__private::Result<Self::Value, __A::Error>
342                 where
343                     __A: _serde::de::MapAccess<'de>,
344                 {
345                     let mut __field0: bool = false;
346                     while let _serde::__private::Some(__key) =
347                         match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
348                             _serde::__private::Ok(__val) => __val,
349                             _serde::__private::Err(__err) => {
350                                 return _serde::__private::Err(__err);
351                             }
352                         }
353                     {
354                         match __key {
355                             __Field::__field0 => {
356                                 if __field0 {
357                                     return _serde::__private::Err(
358                                         <__A::Error as _serde::de::Error>::duplicate_field("x"),
359                                     );
360                                 }
361                                 match _serde::de::MapAccess::next_value_seed(
362                                     &mut __map,
363                                     _serde::__private::de::InPlaceSeed(&mut self.place.x),
364                                 ) {
365                                     _serde::__private::Ok(__val) => __val,
366                                     _serde::__private::Err(__err) => {
367                                         return _serde::__private::Err(__err);
368                                     }
369                                 };
370                                 __field0 = true;
371                             }
372                             _ => {
373                                 let _ = match _serde::de::MapAccess::next_value::<
374                                     _serde::de::IgnoredAny,
375                                 >(&mut __map)
376                                 {
377                                     _serde::__private::Ok(__val) => __val,
378                                     _serde::__private::Err(__err) => {
379                                         return _serde::__private::Err(__err);
380                                     }
381                                 };
382                             }
383                         }
384                     }
385                     if !__field0 {
386                         self.place.x = match _serde::__private::de::missing_field("x") {
387                             _serde::__private::Ok(__val) => __val,
388                             _serde::__private::Err(__err) => {
389                                 return _serde::__private::Err(__err);
390                             }
391                         };
392                     };
393                     _serde::__private::Ok(())
394                 }
395             }
396             const FIELDS: &'static [&'static str] = &["x"];
397             _serde::Deserializer::deserialize_struct(
398                 __deserializer,
399                 "GenericStruct",
400                 FIELDS,
401                 __Visitor {
402                     place: __place,
403                     lifetime: _serde::__private::PhantomData,
404                 },
405             )
406         }
407     }
408 };
409 pub struct GenericNewTypeStruct<T>(T);
410 #[doc(hidden)]
411 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
412 const _: () = {
413     #[allow(unused_extern_crates, clippy::useless_attribute)]
414     extern crate serde as _serde;
415     #[automatically_derived]
416     impl<T> _serde::Serialize for GenericNewTypeStruct<T>
417     where
418         T: _serde::Serialize,
419     {
serialize<__S>( &self, __serializer: __S, ) -> _serde::__private::Result<__S::Ok, __S::Error> where __S: _serde::Serializer,420         fn serialize<__S>(
421             &self,
422             __serializer: __S,
423         ) -> _serde::__private::Result<__S::Ok, __S::Error>
424         where
425             __S: _serde::Serializer,
426         {
427             _serde::Serializer::serialize_newtype_struct(
428                 __serializer,
429                 "GenericNewTypeStruct",
430                 &self.0,
431             )
432         }
433     }
434 };
435 #[doc(hidden)]
436 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
437 const _: () = {
438     #[allow(unused_extern_crates, clippy::useless_attribute)]
439     extern crate serde as _serde;
440     #[automatically_derived]
441     impl<'de, T> _serde::Deserialize<'de> for GenericNewTypeStruct<T>
442     where
443         T: _serde::Deserialize<'de>,
444     {
deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error> where __D: _serde::Deserializer<'de>,445         fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
446         where
447             __D: _serde::Deserializer<'de>,
448         {
449             struct __Visitor<'de, T>
450             where
451                 T: _serde::Deserialize<'de>,
452             {
453                 marker: _serde::__private::PhantomData<GenericNewTypeStruct<T>>,
454                 lifetime: _serde::__private::PhantomData<&'de ()>,
455             }
456             impl<'de, T> _serde::de::Visitor<'de> for __Visitor<'de, T>
457             where
458                 T: _serde::Deserialize<'de>,
459             {
460                 type Value = GenericNewTypeStruct<T>;
461                 fn expecting(
462                     &self,
463                     __formatter: &mut _serde::__private::Formatter,
464                 ) -> _serde::__private::fmt::Result {
465                     _serde::__private::Formatter::write_str(
466                         __formatter,
467                         "tuple struct GenericNewTypeStruct",
468                     )
469                 }
470                 #[inline]
471                 fn visit_newtype_struct<__E>(
472                     self,
473                     __e: __E,
474                 ) -> _serde::__private::Result<Self::Value, __E::Error>
475                 where
476                     __E: _serde::Deserializer<'de>,
477                 {
478                     let __field0: T = match <T as _serde::Deserialize>::deserialize(__e) {
479                         _serde::__private::Ok(__val) => __val,
480                         _serde::__private::Err(__err) => {
481                             return _serde::__private::Err(__err);
482                         }
483                     };
484                     _serde::__private::Ok(GenericNewTypeStruct(__field0))
485                 }
486                 #[inline]
487                 fn visit_seq<__A>(
488                     self,
489                     mut __seq: __A,
490                 ) -> _serde::__private::Result<Self::Value, __A::Error>
491                 where
492                     __A: _serde::de::SeqAccess<'de>,
493                 {
494                     let __field0 = match match _serde::de::SeqAccess::next_element::<T>(&mut __seq)
495                     {
496                         _serde::__private::Ok(__val) => __val,
497                         _serde::__private::Err(__err) => {
498                             return _serde::__private::Err(__err);
499                         }
500                     } {
501                         _serde::__private::Some(__value) => __value,
502                         _serde::__private::None => {
503                             return _serde::__private::Err(_serde::de::Error::invalid_length(
504                                 0usize,
505                                 &"tuple struct GenericNewTypeStruct with 1 element",
506                             ));
507                         }
508                     };
509                     _serde::__private::Ok(GenericNewTypeStruct(__field0))
510                 }
511             }
512             _serde::Deserializer::deserialize_newtype_struct(
513                 __deserializer,
514                 "GenericNewTypeStruct",
515                 __Visitor {
516                     marker: _serde::__private::PhantomData::<GenericNewTypeStruct<T>>,
517                     lifetime: _serde::__private::PhantomData,
518                 },
519             )
520         }
deserialize_in_place<__D>( __deserializer: __D, __place: &mut Self, ) -> _serde::__private::Result<(), __D::Error> where __D: _serde::Deserializer<'de>,521         fn deserialize_in_place<__D>(
522             __deserializer: __D,
523             __place: &mut Self,
524         ) -> _serde::__private::Result<(), __D::Error>
525         where
526             __D: _serde::Deserializer<'de>,
527         {
528             struct __Visitor<'de, 'place, T: 'place>
529             where
530                 T: _serde::Deserialize<'de>,
531             {
532                 place: &'place mut GenericNewTypeStruct<T>,
533                 lifetime: _serde::__private::PhantomData<&'de ()>,
534             }
535             impl<'de, 'place, T: 'place> _serde::de::Visitor<'de> for __Visitor<'de, 'place, T>
536             where
537                 T: _serde::Deserialize<'de>,
538             {
539                 type Value = ();
540                 fn expecting(
541                     &self,
542                     __formatter: &mut _serde::__private::Formatter,
543                 ) -> _serde::__private::fmt::Result {
544                     _serde::__private::Formatter::write_str(
545                         __formatter,
546                         "tuple struct GenericNewTypeStruct",
547                     )
548                 }
549                 #[inline]
550                 fn visit_newtype_struct<__E>(
551                     self,
552                     __e: __E,
553                 ) -> _serde::__private::Result<Self::Value, __E::Error>
554                 where
555                     __E: _serde::Deserializer<'de>,
556                 {
557                     _serde::Deserialize::deserialize_in_place(__e, &mut self.place.0)
558                 }
559                 #[inline]
560                 fn visit_seq<__A>(
561                     self,
562                     mut __seq: __A,
563                 ) -> _serde::__private::Result<Self::Value, __A::Error>
564                 where
565                     __A: _serde::de::SeqAccess<'de>,
566                 {
567                     if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
568                         &mut __seq,
569                         _serde::__private::de::InPlaceSeed(&mut self.place.0),
570                     ) {
571                         _serde::__private::Ok(__val) => __val,
572                         _serde::__private::Err(__err) => {
573                             return _serde::__private::Err(__err);
574                         }
575                     } {
576                         return _serde::__private::Err(_serde::de::Error::invalid_length(
577                             0usize,
578                             &"tuple struct GenericNewTypeStruct with 1 element",
579                         ));
580                     }
581                     _serde::__private::Ok(())
582                 }
583             }
584             _serde::Deserializer::deserialize_newtype_struct(
585                 __deserializer,
586                 "GenericNewTypeStruct",
587                 __Visitor {
588                     place: __place,
589                     lifetime: _serde::__private::PhantomData,
590                 },
591             )
592         }
593     }
594 };
595