serde/private/
macros.rs

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/// Used only by Serde doc tests. Not public API.
26#[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}