aboutsummaryrefslogtreecommitdiff
path: root/vendor/serde/src/macros.rs
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/serde/src/macros.rs')
-rw-r--r--vendor/serde/src/macros.rs231
1 files changed, 231 insertions, 0 deletions
diff --git a/vendor/serde/src/macros.rs b/vendor/serde/src/macros.rs
new file mode 100644
index 0000000..a8fd85a
--- /dev/null
+++ b/vendor/serde/src/macros.rs
@@ -0,0 +1,231 @@
+// Super explicit first paragraph because this shows up at the top level and
+// trips up people who are just looking for basic Serialize / Deserialize
+// documentation.
+//
+/// Helper macro when implementing the `Deserializer` part of a new data format
+/// for Serde.
+///
+/// Some [`Deserializer`] implementations for self-describing formats do not
+/// care what hint the [`Visitor`] gives them, they just want to blindly call
+/// the [`Visitor`] method corresponding to the data they can tell is in the
+/// input. This requires repetitive implementations of all the [`Deserializer`]
+/// trait methods.
+///
+/// ```edition2021
+/// # use serde::forward_to_deserialize_any;
+/// # use serde::de::{value, Deserializer, Visitor};
+/// #
+/// # struct MyDeserializer;
+/// #
+/// # impl<'de> Deserializer<'de> for MyDeserializer {
+/// # type Error = value::Error;
+/// #
+/// # fn deserialize_any<V>(self, _: V) -> Result<V::Value, Self::Error>
+/// # where
+/// # V: Visitor<'de>,
+/// # {
+/// # unimplemented!()
+/// # }
+/// #
+/// #[inline]
+/// fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+/// where
+/// V: Visitor<'de>,
+/// {
+/// self.deserialize_any(visitor)
+/// }
+/// #
+/// # forward_to_deserialize_any! {
+/// # i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
+/// # bytes byte_buf option unit unit_struct newtype_struct seq tuple
+/// # tuple_struct map struct enum identifier ignored_any
+/// # }
+/// # }
+/// ```
+///
+/// The `forward_to_deserialize_any!` macro implements these simple forwarding
+/// methods so that they forward directly to [`Deserializer::deserialize_any`].
+/// You can choose which methods to forward.
+///
+/// ```edition2021
+/// # use serde::forward_to_deserialize_any;
+/// # use serde::de::{value, Deserializer, Visitor};
+/// #
+/// # struct MyDeserializer;
+/// #
+/// impl<'de> Deserializer<'de> for MyDeserializer {
+/// # type Error = value::Error;
+/// #
+/// fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+/// where
+/// V: Visitor<'de>,
+/// {
+/// /* ... */
+/// # let _ = visitor;
+/// # unimplemented!()
+/// }
+///
+/// forward_to_deserialize_any! {
+/// bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
+/// bytes byte_buf option unit unit_struct newtype_struct seq tuple
+/// tuple_struct map struct enum identifier ignored_any
+/// }
+/// }
+/// ```
+///
+/// The macro assumes the convention that your `Deserializer` lifetime parameter
+/// is called `'de` and that the `Visitor` type parameters on each method are
+/// called `V`. A different type parameter and a different lifetime can be
+/// specified explicitly if necessary.
+///
+/// ```edition2021
+/// # use serde::forward_to_deserialize_any;
+/// # use serde::de::{value, Deserializer, Visitor};
+/// # use std::marker::PhantomData;
+/// #
+/// # struct MyDeserializer<V>(PhantomData<V>);
+/// #
+/// # impl<'q, V> Deserializer<'q> for MyDeserializer<V> {
+/// # type Error = value::Error;
+/// #
+/// # fn deserialize_any<W>(self, visitor: W) -> Result<W::Value, Self::Error>
+/// # where
+/// # W: Visitor<'q>,
+/// # {
+/// # unimplemented!()
+/// # }
+/// #
+/// forward_to_deserialize_any! {
+/// <W: Visitor<'q>>
+/// bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
+/// bytes byte_buf option unit unit_struct newtype_struct seq tuple
+/// tuple_struct map struct enum identifier ignored_any
+/// }
+/// # }
+/// ```
+///
+/// [`Deserializer`]: trait.Deserializer.html
+/// [`Visitor`]: de/trait.Visitor.html
+/// [`Deserializer::deserialize_any`]: trait.Deserializer.html#tymethod.deserialize_any
+#[macro_export(local_inner_macros)]
+macro_rules! forward_to_deserialize_any {
+ (<$visitor:ident: Visitor<$lifetime:tt>> $($func:ident)*) => {
+ $(forward_to_deserialize_any_helper!{$func<$lifetime, $visitor>})*
+ };
+ // This case must be after the previous one.
+ ($($func:ident)*) => {
+ $(forward_to_deserialize_any_helper!{$func<'de, V>})*
+ };
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! forward_to_deserialize_any_method {
+ ($func:ident<$l:tt, $v:ident>($($arg:ident : $ty:ty),*)) => {
+ #[inline]
+ fn $func<$v>(self, $($arg: $ty,)* visitor: $v) -> $crate::__private::Result<$v::Value, Self::Error>
+ where
+ $v: $crate::de::Visitor<$l>,
+ {
+ $(
+ let _ = $arg;
+ )*
+ self.deserialize_any(visitor)
+ }
+ };
+}
+
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! forward_to_deserialize_any_helper {
+ (bool<$l:tt, $v:ident>) => {
+ forward_to_deserialize_any_method!{deserialize_bool<$l, $v>()}
+ };
+ (i8<$l:tt, $v:ident>) => {
+ forward_to_deserialize_any_method!{deserialize_i8<$l, $v>()}
+ };
+ (i16<$l:tt, $v:ident>) => {
+ forward_to_deserialize_any_method!{deserialize_i16<$l, $v>()}
+ };
+ (i32<$l:tt, $v:ident>) => {
+ forward_to_deserialize_any_method!{deserialize_i32<$l, $v>()}
+ };
+ (i64<$l:tt, $v:ident>) => {
+ forward_to_deserialize_any_method!{deserialize_i64<$l, $v>()}
+ };
+ (i128<$l:tt, $v:ident>) => {
+ forward_to_deserialize_any_method!{deserialize_i128<$l, $v>()}
+ };
+ (u8<$l:tt, $v:ident>) => {
+ forward_to_deserialize_any_method!{deserialize_u8<$l, $v>()}
+ };
+ (u16<$l:tt, $v:ident>) => {
+ forward_to_deserialize_any_method!{deserialize_u16<$l, $v>()}
+ };
+ (u32<$l:tt, $v:ident>) => {
+ forward_to_deserialize_any_method!{deserialize_u32<$l, $v>()}
+ };
+ (u64<$l:tt, $v:ident>) => {
+ forward_to_deserialize_any_method!{deserialize_u64<$l, $v>()}
+ };
+ (u128<$l:tt, $v:ident>) => {
+ forward_to_deserialize_any_method!{deserialize_u128<$l, $v>()}
+ };
+ (f32<$l:tt, $v:ident>) => {
+ forward_to_deserialize_any_method!{deserialize_f32<$l, $v>()}
+ };
+ (f64<$l:tt, $v:ident>) => {
+ forward_to_deserialize_any_method!{deserialize_f64<$l, $v>()}
+ };
+ (char<$l:tt, $v:ident>) => {
+ forward_to_deserialize_any_method!{deserialize_char<$l, $v>()}
+ };
+ (str<$l:tt, $v:ident>) => {
+ forward_to_deserialize_any_method!{deserialize_str<$l, $v>()}
+ };
+ (string<$l:tt, $v:ident>) => {
+ forward_to_deserialize_any_method!{deserialize_string<$l, $v>()}
+ };
+ (bytes<$l:tt, $v:ident>) => {
+ forward_to_deserialize_any_method!{deserialize_bytes<$l, $v>()}
+ };
+ (byte_buf<$l:tt, $v:ident>) => {
+ forward_to_deserialize_any_method!{deserialize_byte_buf<$l, $v>()}
+ };
+ (option<$l:tt, $v:ident>) => {
+ forward_to_deserialize_any_method!{deserialize_option<$l, $v>()}
+ };
+ (unit<$l:tt, $v:ident>) => {
+ forward_to_deserialize_any_method!{deserialize_unit<$l, $v>()}
+ };
+ (unit_struct<$l:tt, $v:ident>) => {
+ forward_to_deserialize_any_method!{deserialize_unit_struct<$l, $v>(name: &'static str)}
+ };
+ (newtype_struct<$l:tt, $v:ident>) => {
+ forward_to_deserialize_any_method!{deserialize_newtype_struct<$l, $v>(name: &'static str)}
+ };
+ (seq<$l:tt, $v:ident>) => {
+ forward_to_deserialize_any_method!{deserialize_seq<$l, $v>()}
+ };
+ (tuple<$l:tt, $v:ident>) => {
+ forward_to_deserialize_any_method!{deserialize_tuple<$l, $v>(len: usize)}
+ };
+ (tuple_struct<$l:tt, $v:ident>) => {
+ forward_to_deserialize_any_method!{deserialize_tuple_struct<$l, $v>(name: &'static str, len: usize)}
+ };
+ (map<$l:tt, $v:ident>) => {
+ forward_to_deserialize_any_method!{deserialize_map<$l, $v>()}
+ };
+ (struct<$l:tt, $v:ident>) => {
+ forward_to_deserialize_any_method!{deserialize_struct<$l, $v>(name: &'static str, fields: &'static [&'static str])}
+ };
+ (enum<$l:tt, $v:ident>) => {
+ forward_to_deserialize_any_method!{deserialize_enum<$l, $v>(name: &'static str, variants: &'static [&'static str])}
+ };
+ (identifier<$l:tt, $v:ident>) => {
+ forward_to_deserialize_any_method!{deserialize_identifier<$l, $v>()}
+ };
+ (ignored_any<$l:tt, $v:ident>) => {
+ forward_to_deserialize_any_method!{deserialize_ignored_any<$l, $v>()}
+ };
+}
Copyright © 2024 Valentin A. Popov. All Rights Reverse Engineered.