1 // Used only by Serde doc tests. Not public API.
2 
3 use lib::*;
4 
5 use ser;
6 
7 #[doc(hidden)]
8 #[derive(Debug)]
9 pub struct Error;
10 
11 impl ser::Error for Error {
custom<T>(_: T) -> Self where T: Display,12     fn custom<T>(_: T) -> Self
13     where
14         T: Display,
15     {
16         unimplemented!()
17     }
18 }
19 
20 #[cfg(feature = "std")]
21 impl error::Error for Error {
description(&self) -> &str22     fn description(&self) -> &str {
23         unimplemented!()
24     }
25 }
26 
27 impl Display for Error {
fmt(&self, _: &mut fmt::Formatter) -> fmt::Result28     fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {
29         unimplemented!()
30     }
31 }
32 
33 #[doc(hidden)]
34 #[macro_export]
35 macro_rules! __private_serialize {
36     () => {
37         trait Serialize {
38             fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
39             where
40                 S: $crate::Serializer;
41         }
42     };
43 }
44 
45 #[doc(hidden)]
46 #[macro_export(local_inner_macros)]
47 macro_rules! __serialize_unimplemented {
48     ($($func:ident)*) => {
49         $(
50             __serialize_unimplemented_helper!($func);
51         )*
52     };
53 }
54 
55 #[doc(hidden)]
56 #[macro_export]
57 macro_rules! __serialize_unimplemented_method {
58     ($func:ident $(<$t:ident>)* ($($arg:ty),*) -> $ret:ident) => {
59         fn $func $(<$t: ?Sized + $crate::Serialize>)* (self $(, _: $arg)*) -> $crate::__private::Result<Self::$ret, Self::Error> {
60             unimplemented!()
61         }
62     };
63 }
64 
65 #[doc(hidden)]
66 #[macro_export(local_inner_macros)]
67 macro_rules! __serialize_unimplemented_helper {
68     (bool) => {
69         __serialize_unimplemented_method!(serialize_bool(bool) -> Ok);
70     };
71     (i8) => {
72         __serialize_unimplemented_method!(serialize_i8(i8) -> Ok);
73     };
74     (i16) => {
75         __serialize_unimplemented_method!(serialize_i16(i16) -> Ok);
76     };
77     (i32) => {
78         __serialize_unimplemented_method!(serialize_i32(i32) -> Ok);
79     };
80     (i64) => {
81         __serialize_unimplemented_method!(serialize_i64(i64) -> Ok);
82     };
83     (u8) => {
84         __serialize_unimplemented_method!(serialize_u8(u8) -> Ok);
85     };
86     (u16) => {
87         __serialize_unimplemented_method!(serialize_u16(u16) -> Ok);
88     };
89     (u32) => {
90         __serialize_unimplemented_method!(serialize_u32(u32) -> Ok);
91     };
92     (u64) => {
93         __serialize_unimplemented_method!(serialize_u64(u64) -> Ok);
94     };
95     (f32) => {
96         __serialize_unimplemented_method!(serialize_f32(f32) -> Ok);
97     };
98     (f64) => {
99         __serialize_unimplemented_method!(serialize_f64(f64) -> Ok);
100     };
101     (char) => {
102         __serialize_unimplemented_method!(serialize_char(char) -> Ok);
103     };
104     (str) => {
105         __serialize_unimplemented_method!(serialize_str(&str) -> Ok);
106     };
107     (bytes) => {
108         __serialize_unimplemented_method!(serialize_bytes(&[u8]) -> Ok);
109     };
110     (none) => {
111         __serialize_unimplemented_method!(serialize_none() -> Ok);
112     };
113     (some) => {
114         __serialize_unimplemented_method!(serialize_some<T>(&T) -> Ok);
115     };
116     (unit) => {
117         __serialize_unimplemented_method!(serialize_unit() -> Ok);
118     };
119     (unit_struct) => {
120         __serialize_unimplemented_method!(serialize_unit_struct(&str) -> Ok);
121     };
122     (unit_variant) => {
123         __serialize_unimplemented_method!(serialize_unit_variant(&str, u32, &str) -> Ok);
124     };
125     (newtype_struct) => {
126         __serialize_unimplemented_method!(serialize_newtype_struct<T>(&str, &T) -> Ok);
127     };
128     (newtype_variant) => {
129         __serialize_unimplemented_method!(serialize_newtype_variant<T>(&str, u32, &str, &T) -> Ok);
130     };
131     (seq) => {
132         type SerializeSeq = $crate::ser::Impossible<Self::Ok, Self::Error>;
133         __serialize_unimplemented_method!(serialize_seq(Option<usize>) -> SerializeSeq);
134     };
135     (tuple) => {
136         type SerializeTuple = $crate::ser::Impossible<Self::Ok, Self::Error>;
137         __serialize_unimplemented_method!(serialize_tuple(usize) -> SerializeTuple);
138     };
139     (tuple_struct) => {
140         type SerializeTupleStruct = $crate::ser::Impossible<Self::Ok, Self::Error>;
141         __serialize_unimplemented_method!(serialize_tuple_struct(&str, usize) -> SerializeTupleStruct);
142     };
143     (tuple_variant) => {
144         type SerializeTupleVariant = $crate::ser::Impossible<Self::Ok, Self::Error>;
145         __serialize_unimplemented_method!(serialize_tuple_variant(&str, u32, &str, usize) -> SerializeTupleVariant);
146     };
147     (map) => {
148         type SerializeMap = $crate::ser::Impossible<Self::Ok, Self::Error>;
149         __serialize_unimplemented_method!(serialize_map(Option<usize>) -> SerializeMap);
150     };
151     (struct) => {
152         type SerializeStruct = $crate::ser::Impossible<Self::Ok, Self::Error>;
153         __serialize_unimplemented_method!(serialize_struct(&str, usize) -> SerializeStruct);
154     };
155     (struct_variant) => {
156         type SerializeStructVariant = $crate::ser::Impossible<Self::Ok, Self::Error>;
157         __serialize_unimplemented_method!(serialize_struct_variant(&str, u32, &str, usize) -> SerializeStructVariant);
158     };
159 }
160