| 1 |
// Super explicit first paragraph because this shows up at the top level and |
| 2 |
// trips up people who are just looking for basic Serialize / Deserialize |
| 3 |
// documentation. |
| 4 |
// |
| 5 |
/// Helper macro when implementing the `Deserializer` part of a new data format |
| 6 |
/// for Serde. |
| 7 |
/// |
| 8 |
/// Some [`Deserializer`] implementations for self-describing formats do not |
| 9 |
/// care what hint the [`Visitor`] gives them, they just want to blindly call |
| 10 |
/// the [`Visitor`] method corresponding to the data they can tell is in the |
| 11 |
/// input. This requires repetitive implementations of all the [`Deserializer`] |
| 12 |
/// trait methods. |
| 13 |
/// |
| 14 |
/// ```edition2021 |
| 15 |
/// # use serde::forward_to_deserialize_any; |
| 16 |
/// # use serde::de::{value, Deserializer, Visitor}; |
| 17 |
/// # |
| 18 |
/// # struct MyDeserializer; |
| 19 |
/// # |
| 20 |
/// # impl<'de> Deserializer<'de> for MyDeserializer { |
| 21 |
/// # type Error = value::Error; |
| 22 |
/// # |
| 23 |
/// # fn deserialize_any<V>(self, _: V) -> Result<V::Value, Self::Error> |
| 24 |
/// # where |
| 25 |
/// # V: Visitor<'de>, |
| 26 |
/// # { |
| 27 |
/// # unimplemented!() |
| 28 |
/// # } |
| 29 |
/// # |
| 30 |
/// #[inline] |
| 31 |
/// fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| 32 |
/// where |
| 33 |
/// V: Visitor<'de>, |
| 34 |
/// { |
| 35 |
/// self.deserialize_any(visitor) |
| 36 |
/// } |
| 37 |
/// # |
| 38 |
/// # forward_to_deserialize_any! { |
| 39 |
/// # i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string |
| 40 |
/// # bytes byte_buf option unit unit_struct newtype_struct seq tuple |
| 41 |
/// # tuple_struct map struct enum identifier ignored_any |
| 42 |
/// # } |
| 43 |
/// # } |
| 44 |
/// ``` |
| 45 |
/// |
| 46 |
/// The `forward_to_deserialize_any!` macro implements these simple forwarding |
| 47 |
/// methods so that they forward directly to [`Deserializer::deserialize_any`]. |
| 48 |
/// You can choose which methods to forward. |
| 49 |
/// |
| 50 |
/// ```edition2021 |
| 51 |
/// # use serde::forward_to_deserialize_any; |
| 52 |
/// # use serde::de::{value, Deserializer, Visitor}; |
| 53 |
/// # |
| 54 |
/// # struct MyDeserializer; |
| 55 |
/// # |
| 56 |
/// impl<'de> Deserializer<'de> for MyDeserializer { |
| 57 |
/// # type Error = value::Error; |
| 58 |
/// # |
| 59 |
/// fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| 60 |
/// where |
| 61 |
/// V: Visitor<'de>, |
| 62 |
/// { |
| 63 |
/// /* ... */ |
| 64 |
/// # let _ = visitor; |
| 65 |
/// # unimplemented!() |
| 66 |
/// } |
| 67 |
/// |
| 68 |
/// forward_to_deserialize_any! { |
| 69 |
/// bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string |
| 70 |
/// bytes byte_buf option unit unit_struct newtype_struct seq tuple |
| 71 |
/// tuple_struct map struct enum identifier ignored_any |
| 72 |
/// } |
| 73 |
/// } |
| 74 |
/// ``` |
| 75 |
/// |
| 76 |
/// The macro assumes the convention that your `Deserializer` lifetime parameter |
| 77 |
/// is called `'de` and that the `Visitor` type parameters on each method are |
| 78 |
/// called `V`. A different type parameter and a different lifetime can be |
| 79 |
/// specified explicitly if necessary. |
| 80 |
/// |
| 81 |
/// ```edition2021 |
| 82 |
/// # use serde::forward_to_deserialize_any; |
| 83 |
/// # use serde::de::{value, Deserializer, Visitor}; |
| 84 |
/// # use std::marker::PhantomData; |
| 85 |
/// # |
| 86 |
/// # struct MyDeserializer<V>(PhantomData<V>); |
| 87 |
/// # |
| 88 |
/// # impl<'q, V> Deserializer<'q> for MyDeserializer<V> { |
| 89 |
/// # type Error = value::Error; |
| 90 |
/// # |
| 91 |
/// # fn deserialize_any<W>(self, visitor: W) -> Result<W::Value, Self::Error> |
| 92 |
/// # where |
| 93 |
/// # W: Visitor<'q>, |
| 94 |
/// # { |
| 95 |
/// # unimplemented!() |
| 96 |
/// # } |
| 97 |
/// # |
| 98 |
/// forward_to_deserialize_any! { |
| 99 |
/// <W: Visitor<'q>> |
| 100 |
/// bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string |
| 101 |
/// bytes byte_buf option unit unit_struct newtype_struct seq tuple |
| 102 |
/// tuple_struct map struct enum identifier ignored_any |
| 103 |
/// } |
| 104 |
/// # } |
| 105 |
/// ``` |
| 106 |
/// |
| 107 |
/// [`Deserializer`]: trait.Deserializer.html |
| 108 |
/// [`Visitor`]: de/trait.Visitor.html |
| 109 |
/// [`Deserializer::deserialize_any`]: trait.Deserializer.html#tymethod.deserialize_any |
| 110 |
#[macro_export(local_inner_macros)] |
| 111 |
macro_rules! forward_to_deserialize_any { |
| 112 |
(<$visitor:ident: Visitor<$lifetime:tt>> $($func:ident)*) => { |
| 113 |
$(forward_to_deserialize_any_helper!{$func<$lifetime, $visitor>})* |
| 114 |
}; |
| 115 |
// This case must be after the previous one. |
| 116 |
($($func:ident)*) => { |
| 117 |
$(forward_to_deserialize_any_helper!{$func<'de, V>})* |
| 118 |
}; |
| 119 |
} |
| 120 |
|
| 121 |
#[doc(hidden)] |
| 122 |
#[macro_export] |
| 123 |
macro_rules! forward_to_deserialize_any_method { |
| 124 |
($func:ident<$l:tt, $v:ident>($($arg:ident : $ty:ty),*)) => { |
| 125 |
#[inline] |
| 126 |
fn $func<$v>(self, $($arg: $ty,)* visitor: $v) -> $crate::__private::Result<$v::Value, <Self as $crate::de::Deserializer<$l>>::Error> |
| 127 |
where |
| 128 |
$v: $crate::de::Visitor<$l>, |
| 129 |
{ |
| 130 |
$( |
| 131 |
let _ = $arg; |
| 132 |
)* |
| 133 |
self.deserialize_any(visitor) |
| 134 |
} |
| 135 |
}; |
| 136 |
} |
| 137 |
|
| 138 |
#[doc(hidden)] |
| 139 |
#[macro_export(local_inner_macros)] |
| 140 |
macro_rules! forward_to_deserialize_any_helper { |
| 141 |
(bool<$l:tt, $v:ident>) => { |
| 142 |
forward_to_deserialize_any_method!{deserialize_bool<$l, $v>()} |
| 143 |
}; |
| 144 |
(i8<$l:tt, $v:ident>) => { |
| 145 |
forward_to_deserialize_any_method!{deserialize_i8<$l, $v>()} |
| 146 |
}; |
| 147 |
(i16<$l:tt, $v:ident>) => { |
| 148 |
forward_to_deserialize_any_method!{deserialize_i16<$l, $v>()} |
| 149 |
}; |
| 150 |
(i32<$l:tt, $v:ident>) => { |
| 151 |
forward_to_deserialize_any_method!{deserialize_i32<$l, $v>()} |
| 152 |
}; |
| 153 |
(i64<$l:tt, $v:ident>) => { |
| 154 |
forward_to_deserialize_any_method!{deserialize_i64<$l, $v>()} |
| 155 |
}; |
| 156 |
(i128<$l:tt, $v:ident>) => { |
| 157 |
forward_to_deserialize_any_method!{deserialize_i128<$l, $v>()} |
| 158 |
}; |
| 159 |
(u8<$l:tt, $v:ident>) => { |
| 160 |
forward_to_deserialize_any_method!{deserialize_u8<$l, $v>()} |
| 161 |
}; |
| 162 |
(u16<$l:tt, $v:ident>) => { |
| 163 |
forward_to_deserialize_any_method!{deserialize_u16<$l, $v>()} |
| 164 |
}; |
| 165 |
(u32<$l:tt, $v:ident>) => { |
| 166 |
forward_to_deserialize_any_method!{deserialize_u32<$l, $v>()} |
| 167 |
}; |
| 168 |
(u64<$l:tt, $v:ident>) => { |
| 169 |
forward_to_deserialize_any_method!{deserialize_u64<$l, $v>()} |
| 170 |
}; |
| 171 |
(u128<$l:tt, $v:ident>) => { |
| 172 |
forward_to_deserialize_any_method!{deserialize_u128<$l, $v>()} |
| 173 |
}; |
| 174 |
(f32<$l:tt, $v:ident>) => { |
| 175 |
forward_to_deserialize_any_method!{deserialize_f32<$l, $v>()} |
| 176 |
}; |
| 177 |
(f64<$l:tt, $v:ident>) => { |
| 178 |
forward_to_deserialize_any_method!{deserialize_f64<$l, $v>()} |
| 179 |
}; |
| 180 |
(char<$l:tt, $v:ident>) => { |
| 181 |
forward_to_deserialize_any_method!{deserialize_char<$l, $v>()} |
| 182 |
}; |
| 183 |
(str<$l:tt, $v:ident>) => { |
| 184 |
forward_to_deserialize_any_method!{deserialize_str<$l, $v>()} |
| 185 |
}; |
| 186 |
(string<$l:tt, $v:ident>) => { |
| 187 |
forward_to_deserialize_any_method!{deserialize_string<$l, $v>()} |
| 188 |
}; |
| 189 |
(bytes<$l:tt, $v:ident>) => { |
| 190 |
forward_to_deserialize_any_method!{deserialize_bytes<$l, $v>()} |
| 191 |
}; |
| 192 |
(byte_buf<$l:tt, $v:ident>) => { |
| 193 |
forward_to_deserialize_any_method!{deserialize_byte_buf<$l, $v>()} |
| 194 |
}; |
| 195 |
(option<$l:tt, $v:ident>) => { |
| 196 |
forward_to_deserialize_any_method!{deserialize_option<$l, $v>()} |
| 197 |
}; |
| 198 |
(unit<$l:tt, $v:ident>) => { |
| 199 |
forward_to_deserialize_any_method!{deserialize_unit<$l, $v>()} |
| 200 |
}; |
| 201 |
(unit_struct<$l:tt, $v:ident>) => { |
| 202 |
forward_to_deserialize_any_method!{deserialize_unit_struct<$l, $v>(name: &'static str)} |
| 203 |
}; |
| 204 |
(newtype_struct<$l:tt, $v:ident>) => { |
| 205 |
forward_to_deserialize_any_method!{deserialize_newtype_struct<$l, $v>(name: &'static str)} |
| 206 |
}; |
| 207 |
(seq<$l:tt, $v:ident>) => { |
| 208 |
forward_to_deserialize_any_method!{deserialize_seq<$l, $v>()} |
| 209 |
}; |
| 210 |
(tuple<$l:tt, $v:ident>) => { |
| 211 |
forward_to_deserialize_any_method!{deserialize_tuple<$l, $v>(len: usize)} |
| 212 |
}; |
| 213 |
(tuple_struct<$l:tt, $v:ident>) => { |
| 214 |
forward_to_deserialize_any_method!{deserialize_tuple_struct<$l, $v>(name: &'static str, len: usize)} |
| 215 |
}; |
| 216 |
(map<$l:tt, $v:ident>) => { |
| 217 |
forward_to_deserialize_any_method!{deserialize_map<$l, $v>()} |
| 218 |
}; |
| 219 |
(struct<$l:tt, $v:ident>) => { |
| 220 |
forward_to_deserialize_any_method!{deserialize_struct<$l, $v>(name: &'static str, fields: &'static [&'static str])} |
| 221 |
}; |
| 222 |
(enum<$l:tt, $v:ident>) => { |
| 223 |
forward_to_deserialize_any_method!{deserialize_enum<$l, $v>(name: &'static str, variants: &'static [&'static str])} |
| 224 |
}; |
| 225 |
(identifier<$l:tt, $v:ident>) => { |
| 226 |
forward_to_deserialize_any_method!{deserialize_identifier<$l, $v>()} |
| 227 |
}; |
| 228 |
(ignored_any<$l:tt, $v:ident>) => { |
| 229 |
forward_to_deserialize_any_method!{deserialize_ignored_any<$l, $v>()} |
| 230 |
}; |
| 231 |
} |