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