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