#[macro_export]
macro_rules! body {
($($body:tt)*) => {
$crate::body_internal!($($body)*)
};
}
#[macro_export]
#[doc(hidden)]
macro_rules! body_internal {
(@structures [$(($elems:expr))*]) => {
std::vec![$($elems),*]
};
(@structures [$(($elems:expr))*] $key:tt = $expr:tt $($rest:tt)*) => {
$crate::body_internal!(@structures [$(($elems))* ($crate::structure!($key = $expr))] $($rest)*)
};
(@structures [$(($elems:expr))*] $ident:tt $($rest:tt)+) => {
$crate::body_internal!(@block [$(($elems))*] $ident $($rest)+)
};
(@block [$(($elems:expr))*] ($ident:expr) [$(($labels:expr))*] { $($body:tt)* } $($rest:tt)*) => {
$crate::body_internal!(@structures [$(($elems))* ($crate::structure!(($ident) [$(($labels))*] { $($body)* }))] $($rest)*)
};
(@block [$(($elems:expr))*] ($ident:expr) [$(($labels:expr))*] $label:ident $($rest:tt)+) => {
$crate::body_internal!(@block [$(($elems))*] ($ident) [$(($labels))* ($crate::block_label!($label))] $($rest)+)
};
(@block [$(($elems:expr))*] ($ident:expr) [$(($labels:expr))*] $label:literal $($rest:tt)+) => {
$crate::body_internal!(@block [$(($elems))*] ($ident) [$(($labels))* ($crate::block_label!($label))] $($rest)+)
};
(@block [$(($elems:expr))*] ($ident:expr) [$(($labels:expr))*] ($label:expr) $($rest:tt)+) => {
$crate::body_internal!(@block [$(($elems))*] ($ident) [$(($labels))* ($crate::block_label!(($label)))] $($rest)+)
};
(@block [$(($elems:expr))*] $ident:ident $($rest:tt)+) => {
$crate::body_internal!(@block [$(($elems))*] (std::stringify!($ident)) [] $($rest)+)
};
(@block [$(($elems:expr))*] ($ident:expr) $($rest:tt)+) => {
$crate::body_internal!(@block [$(($elems))*] ($ident) [] $($rest)+)
};
({ $($tt:tt)* }) => {
$crate::body_internal!($($tt)*)
};
($($tt:tt)*) => {
$crate::structure::Body($crate::body_internal!(@structures [] $($tt)*))
};
}
#[macro_export]
macro_rules! structure {
($($structure:tt)+) => {
$crate::structure_internal!($($structure)+)
};
}
#[macro_export]
#[doc(hidden)]
macro_rules! structure_internal {
({ $($structure:tt)+ }) => {
$crate::structure_internal!($($structure)+)
};
($key:tt = $($expr:tt)+) => {
$crate::structure::Structure::Attribute($crate::attribute!($key = $($expr)+))
};
($($block:tt)+) => {
$crate::structure::Structure::Block($crate::block!($($block)+))
};
}
#[macro_export]
macro_rules! attribute {
($($attr:tt)+) => {
$crate::attribute_internal!($($attr)+)
};
}
#[macro_export]
#[doc(hidden)]
macro_rules! attribute_internal {
({ $($attribute:tt)+ }) => {
$crate::attribute_internal!($($attribute)+)
};
(($key:expr) = $($expr:tt)+) => {
$crate::Attribute {
key: ($key).into(),
expr: $crate::expression_internal!($($expr)+),
}
};
($key:ident = $($expr:tt)+) => {
$crate::attribute_internal!((std::stringify!($key)) = $($expr)+)
};
}
#[macro_export]
macro_rules! block {
($($block:tt)+) => {
$crate::block_internal!($($block)+)
};
}
#[macro_export]
#[doc(hidden)]
macro_rules! block_internal {
({ $($block:tt)+ }) => {
$crate::block_internal!($($block)+)
};
(($ident:expr) [$(($labels:expr))*] $label:ident $($rest:tt)+) => {
$crate::block_internal!(($ident) [$(($labels))* ($crate::block_label!($label))] $($rest)+)
};
(($ident:expr) [$(($labels:expr))*] $label:literal $($rest:tt)+) => {
$crate::block_internal!(($ident) [$(($labels))* ($crate::block_label!($label))] $($rest)+)
};
(($ident:expr) [$(($labels:expr))*] ($label:expr) $($rest:tt)+) => {
$crate::block_internal!(($ident) [$(($labels))* ($crate::block_label!(($label)))] $($rest)+)
};
(($ident:expr) [$(($labels:expr))*] {$($body:tt)*}) => {
$crate::Block {
identifier: ($ident).into(),
labels: std::vec![$($labels),*],
body: $crate::body!($($body)*),
}
};
(($ident:expr) $($rest:tt)+) => {
$crate::block_internal!(($ident) [] $($rest)+)
};
($ident:ident $($rest:tt)+) => {
$crate::block_internal!((std::stringify!($ident)) [] $($rest)+)
};
}
#[macro_export]
#[doc(hidden)]
macro_rules! block_label {
($ident:ident) => {
$crate::structure::BlockLabel::Identifier($crate::Identifier::unchecked(std::stringify!(
$ident
)))
};
(($expr:expr)) => {
$crate::structure::BlockLabel::String(($expr).into())
};
($literal:literal) => {
$crate::block_label!(($literal))
};
}
#[macro_export]
#[doc(hidden)]
macro_rules! object_key {
($ident:ident) => {
$crate::expr::ObjectKey::Identifier($crate::Identifier::unchecked(std::stringify!($ident)))
};
(#{$expr:expr}) => {
$crate::expr::ObjectKey::Expression($crate::expression!(#{$expr}))
};
(($expr:expr)) => {
$crate::expr::ObjectKey::Expression($crate::expression!($expr))
};
($literal:literal) => {
$crate::object_key!(($literal))
};
}
#[macro_export]
macro_rules! expression {
($($expr:tt)+) => {
$crate::expression_internal!($($expr)+)
};
}
#[macro_export]
#[doc(hidden)]
macro_rules! expression_internal {
(@array [$($elems:expr,)*]) => {
std::vec![$($elems,)*]
};
(@array [$($elems:expr),*]) => {
std::vec![$($elems),*]
};
(@array [$($elems:expr,)*] null $($rest:tt)*) => {
$crate::expression_internal!(@array [$($elems,)* $crate::expression_internal!(null)] $($rest)*)
};
(@array [$($elems:expr,)*] true $($rest:tt)*) => {
$crate::expression_internal!(@array [$($elems,)* $crate::expression_internal!(true)] $($rest)*)
};
(@array [$($elems:expr,)*] false $($rest:tt)*) => {
$crate::expression_internal!(@array [$($elems,)* $crate::expression_internal!(false)] $($rest)*)
};
(@array [$($elems:expr,)*] [$($array:tt)*] $($rest:tt)*) => {
$crate::expression_internal!(@array [$($elems,)* $crate::expression_internal!([$($array)*])] $($rest)*)
};
(@array [$($elems:expr,)*] {$($map:tt)*} $($rest:tt)*) => {
$crate::expression_internal!(@array [$($elems,)* $crate::expression_internal!({$($map)*})] $($rest)*)
};
(@array [$($elems:expr,)*] $next:expr, $($rest:tt)*) => {
$crate::expression_internal!(@array [$($elems,)* $crate::expression_internal!($next),] $($rest)*)
};
(@array [$($elems:expr,)*] $last:expr) => {
$crate::expression_internal!(@array [$($elems,)* $crate::expression_internal!($last)])
};
(@array [$($elems:expr),*] , $($rest:tt)*) => {
$crate::expression_internal!(@array [$($elems,)*] $($rest)*)
};
(@array [$($elems:expr),*] $unexpected:tt $($rest:tt)*) => {
$crate::hcl_unexpected!($unexpected)
};
(@object $object:ident () () ()) => {};
(@object $object:ident [$key:expr] ($value:expr) , $($rest:tt)*) => {
let _ = $object.insert($key, $value);
$crate::expression_internal!(@object $object () ($($rest)*) ($($rest)*));
};
(@object $object:ident [$key:expr] ($value:expr) $($rest:tt)*) => {
let _ = $object.insert($key, $value);
$crate::expression_internal!(@object $object () ($($rest)*) ($($rest)*));
};
(@object $object:ident [$key:expr] ($value:expr)) => {
let _ = $object.insert($key, $value);
};
(@object $object:ident ($key:expr) (= null $($rest:tt)*) $copy:tt) => {
$crate::expression_internal!(@object $object [$key] ($crate::expression_internal!(null)) $($rest)*);
};
(@object $object:ident ($key:expr) (= true $($rest:tt)*) $copy:tt) => {
$crate::expression_internal!(@object $object [$key] ($crate::expression_internal!(true)) $($rest)*);
};
(@object $object:ident ($key:expr) (= false $($rest:tt)*) $copy:tt) => {
$crate::expression_internal!(@object $object [$key] ($crate::expression_internal!(false)) $($rest)*);
};
(@object $object:ident ($key:expr) (= [$($array:tt)*] $($rest:tt)*) $copy:tt) => {
$crate::expression_internal!(@object $object [$key] ($crate::expression_internal!([$($array)*])) $($rest)*);
};
(@object $object:ident ($key:expr) (= {$($map:tt)*} $($rest:tt)*) $copy:tt) => {
$crate::expression_internal!(@object $object [$key] ($crate::expression_internal!({$($map)*})) $($rest)*);
};
(@object $object:ident ($key:expr) (= $value:expr , $($rest:tt)*) $copy:tt) => {
$crate::expression_internal!(@object $object [$key] ($crate::expression_internal!($value)) , $($rest)*);
};
(@object $object:ident ($key:expr) (= $value:tt $($rest:tt)*) $copy:tt) => {
$crate::expression_internal!(@object $object [$key] ($crate::expression_internal!($value)) $($rest)*);
};
(@object $object:ident ($key:expr) (= $value:expr) $copy:tt) => {
$crate::expression_internal!(@object $object [$key] ($crate::expression_internal!($value)));
};
(@object $object:ident ($key:expr) (=) $copy:tt) => {
$crate::expression_internal!();
};
(@object $object:ident ($key:expr) () $copy:tt) => {
$crate::expression_internal!();
};
(@object $object:ident () (= $($rest:tt)*) ($equals:tt $($copy:tt)*)) => {
$crate::hcl_unexpected!($equals);
};
(@object $object:ident ($key:expr) (, $($rest:tt)*) ($comma:tt $($copy:tt)*)) => {
$crate::hcl_unexpected!($comma);
};
(@object $object:ident ($key:expr) (= $($unexpected:tt)+) $copy:tt) => {
$crate::hcl_expect_expr_comma!($($unexpected)+);
};
(@object $object:ident () ($key:ident $($rest:tt)*) $copy:tt) => {
$crate::expression_internal!(@object $object ($crate::object_key!($key)) ($($rest)*) ($($rest)*));
};
(@object $object:ident () ($key:literal $($rest:tt)*) $copy:tt) => {
$crate::expression_internal!(@object $object ($crate::object_key!($key)) ($($rest)*) ($($rest)*));
};
(@object $object:ident () (#{$key:expr} $($rest:tt)*) $copy:tt) => {
$crate::expression_internal!(@object $object ($crate::object_key!(#{$key})) ($($rest)*) ($($rest)*));
};
(@object $object:ident () (($key:expr) $($rest:tt)*) $copy:tt) => {
$crate::expression_internal!(@object $object ($crate::object_key!(($key))) ($($rest)*) ($($rest)*));
};
(null) => {
$crate::expr::Expression::Null
};
(true) => {
$crate::expr::Expression::Bool(true)
};
(false) => {
$crate::expr::Expression::Bool(false)
};
(#{$expr:expr}) => {
$crate::expr::Expression::Raw(($expr).into())
};
([]) => {
$crate::expr::Expression::Array(std::vec![])
};
([ $($tt:tt)+ ]) => {
$crate::expr::Expression::Array($crate::expression_internal!(@array [] $($tt)+))
};
({}) => {
$crate::expr::Expression::Object($crate::expr::Object::new())
};
({ $($tt:tt)+ }) => {
$crate::expr::Expression::Object({
let mut object = $crate::expr::Object::new();
$crate::expression_internal!(@object object () ($($tt)+) ($($tt)+));
object
})
};
($other:expr) => {
$crate::expr::to_expression(&$other).unwrap()
};
}
#[macro_export]
macro_rules! value {
($($expr:tt)+) => {
$crate::value_internal!($($expr)+)
};
}
#[macro_export]
#[doc(hidden)]
macro_rules! value_internal {
(@array [$($elems:expr,)*]) => {
std::vec![$($elems,)*]
};
(@array [$($elems:expr),*]) => {
std::vec![$($elems),*]
};
(@array [$($elems:expr,)*] null $($rest:tt)*) => {
$crate::value_internal!(@array [$($elems,)* $crate::value_internal!(null)] $($rest)*)
};
(@array [$($elems:expr,)*] true $($rest:tt)*) => {
$crate::value_internal!(@array [$($elems,)* $crate::value_internal!(true)] $($rest)*)
};
(@array [$($elems:expr,)*] false $($rest:tt)*) => {
$crate::value_internal!(@array [$($elems,)* $crate::value_internal!(false)] $($rest)*)
};
(@array [$($elems:expr,)*] [$($array:tt)*] $($rest:tt)*) => {
$crate::value_internal!(@array [$($elems,)* $crate::value_internal!([$($array)*])] $($rest)*)
};
(@array [$($elems:expr,)*] {$($map:tt)*} $($rest:tt)*) => {
$crate::value_internal!(@array [$($elems,)* $crate::value_internal!({$($map)*})] $($rest)*)
};
(@array [$($elems:expr,)*] $next:expr, $($rest:tt)*) => {
$crate::value_internal!(@array [$($elems,)* $crate::value_internal!($next),] $($rest)*)
};
(@array [$($elems:expr,)*] $last:expr) => {
$crate::value_internal!(@array [$($elems,)* $crate::value_internal!($last)])
};
(@array [$($elems:expr),*] , $($rest:tt)*) => {
$crate::value_internal!(@array [$($elems,)*] $($rest)*)
};
(@array [$($elems:expr),*] $unexpected:tt $($rest:tt)*) => {
$crate::hcl_unexpected!($unexpected)
};
(@object $object:ident () () ()) => {};
(@object $object:ident [$key:expr] ($value:expr) , $($rest:tt)*) => {
let _ = $object.insert(($key).into(), $value);
$crate::value_internal!(@object $object () ($($rest)*) ($($rest)*));
};
(@object $object:ident [$key:expr] ($value:expr) $($rest:tt)*) => {
let _ = $object.insert(($key).into(), $value);
$crate::value_internal!(@object $object () ($($rest)*) ($($rest)*));
};
(@object $object:ident [$key:expr] ($value:expr)) => {
let _ = $object.insert(($key).into(), $value);
};
(@object $object:ident ($key:expr) (= null $($rest:tt)*) $copy:tt) => {
$crate::value_internal!(@object $object [$key] ($crate::value_internal!(null)) $($rest)*);
};
(@object $object:ident ($key:expr) (= true $($rest:tt)*) $copy:tt) => {
$crate::value_internal!(@object $object [$key] ($crate::value_internal!(true)) $($rest)*);
};
(@object $object:ident ($key:expr) (= false $($rest:tt)*) $copy:tt) => {
$crate::value_internal!(@object $object [$key] ($crate::value_internal!(false)) $($rest)*);
};
(@object $object:ident ($key:expr) (= [$($array:tt)*] $($rest:tt)*) $copy:tt) => {
$crate::value_internal!(@object $object [$key] ($crate::value_internal!([$($array)*])) $($rest)*);
};
(@object $object:ident ($key:expr) (= {$($map:tt)*} $($rest:tt)*) $copy:tt) => {
$crate::value_internal!(@object $object [$key] ($crate::value_internal!({$($map)*})) $($rest)*);
};
(@object $object:ident ($key:expr) (= $value:expr , $($rest:tt)*) $copy:tt) => {
$crate::value_internal!(@object $object [$key] ($crate::value_internal!($value)) , $($rest)*);
};
(@object $object:ident ($key:expr) (= $value:tt $($rest:tt)*) $copy:tt) => {
$crate::value_internal!(@object $object [$key] ($crate::value_internal!($value)) $($rest)*);
};
(@object $object:ident ($key:expr) (= $value:expr) $copy:tt) => {
$crate::value_internal!(@object $object [$key] ($crate::value_internal!($value)));
};
(@object $object:ident ($key:expr) (=) $copy:tt) => {
$crate::value_internal!();
};
(@object $object:ident ($key:expr) () $copy:tt) => {
$crate::value_internal!();
};
(@object $object:ident () (= $($rest:tt)*) ($equals:tt $($copy:tt)*)) => {
$crate::hcl_unexpected!($equals);
};
(@object $object:ident ($key:expr) (, $($rest:tt)*) ($comma:tt $($copy:tt)*)) => {
$crate::hcl_unexpected!($comma);
};
(@object $object:ident ($key:expr) (= $($unexpected:tt)+) $copy:tt) => {
$crate::hcl_expect_expr_comma!($($unexpected)+);
};
(@object $object:ident () ($key:ident $($rest:tt)*) $copy:tt) => {
$crate::value_internal!(@object $object ((std::stringify!($key))) ($($rest)*) ($($rest)*));
};
(@object $object:ident () ($key:literal $($rest:tt)*) $copy:tt) => {
$crate::value_internal!(@object $object (($key)) ($($rest)*) ($($rest)*));
};
(@object $object:ident () (($key:expr) $($rest:tt)*) $copy:tt) => {
$crate::value_internal!(@object $object (($key)) ($($rest)*) ($($rest)*));
};
(null) => {
$crate::value::Value::Null
};
(true) => {
$crate::value::Value::Bool(true)
};
(false) => {
$crate::value::Value::Bool(false)
};
([]) => {
$crate::value::Value::Array(std::vec![])
};
([ $($tt:tt)+ ]) => {
$crate::value::Value::Array($crate::value_internal!(@array [] $($tt)+))
};
({}) => {
$crate::value::Value::Object($crate::value::Map::new())
};
({ $($tt:tt)+ }) => {
$crate::value::Value::Object({
let mut object = $crate::value::Map::new();
$crate::value_internal!(@object object () ($($tt)+) ($($tt)+));
object
})
};
($other:expr) => {
$crate::value::to_value(&$other).unwrap()
};
}
#[macro_export]
#[doc(hidden)]
macro_rules! hcl_unexpected {
() => {};
}
#[macro_export]
#[doc(hidden)]
macro_rules! hcl_expect_expr_comma {
($e:expr , $($tt:tt)*) => {};
}
#[macro_export]
#[doc(hidden)]
macro_rules! serialize_unsupported {
(bool) => {
$crate::serialize_unsupported_method!{serialize_bool(v: bool)}
};
(i8) => {
$crate::serialize_unsupported_method!{serialize_i8(v: i8)}
};
(i16) => {
$crate::serialize_unsupported_method!{serialize_i16(v: i16)}
};
(i32) => {
$crate::serialize_unsupported_method!{serialize_i32(v: i32)}
};
(i64) => {
$crate::serialize_unsupported_method!{serialize_i64(v: i64)}
};
(i128) => {
serde::serde_if_integer128! {
$crate::serialize_unsupported_method!{serialize_i128(v: i128)}
}
};
(u8) => {
$crate::serialize_unsupported_method!{serialize_u8(v: u8)}
};
(u16) => {
$crate::serialize_unsupported_method!{serialize_u16(v: u16)}
};
(u32) => {
$crate::serialize_unsupported_method!{serialize_u32(v: u32)}
};
(u64) => {
$crate::serialize_unsupported_method!{serialize_u64(v: u64)}
};
(u128) => {
serde::serde_if_integer128! {
$crate::serialize_unsupported_method!{serialize_u128(v: u128)}
}
};
(f32) => {
$crate::serialize_unsupported_method!{serialize_f32(v: f32)}
};
(f64) => {
$crate::serialize_unsupported_method!{serialize_f64(v: f64)}
};
(char) => {
$crate::serialize_unsupported_method!{serialize_char(v: char)}
};
(str) => {
$crate::serialize_unsupported_method!{serialize_str(v: &str)}
};
(bytes) => {
$crate::serialize_unsupported_method!{serialize_bytes(v: &[u8])}
};
(some) => {
$crate::serialize_unsupported_method!{serialize_some<T>(value: &T)}
};
(none) => {
$crate::serialize_unsupported_method!{serialize_none()}
};
(unit) => {
$crate::serialize_unsupported_method!{serialize_unit()}
};
(unit_struct) => {
$crate::serialize_unsupported_method!{serialize_unit_struct(name: &'static str)}
};
(unit_variant) => {
$crate::serialize_unsupported_method!{serialize_unit_variant(name: &'static str, variant_index: u32, variant: &'static str)}
};
(newtype_struct) => {
$crate::serialize_unsupported_method!{serialize_newtype_struct<T>(name: &'static str, value: &T)}
};
(newtype_variant) => {
$crate::serialize_unsupported_method!{serialize_newtype_variant<T>(name: &'static str, variant_index: u32, variant: &'static str, value: &T)}
};
(seq) => {
$crate::serialize_unsupported_method!{serialize_seq(len: Option<usize>) -> Result<SerializeSeq>}
};
(tuple) => {
$crate::serialize_unsupported_method!{serialize_tuple(len: usize) -> Result<SerializeTuple>}
};
(tuple_struct) => {
$crate::serialize_unsupported_method!{serialize_tuple_struct(name: &'static str, len: usize) -> Result<SerializeTupleStruct>}
};
(tuple_variant) => {
$crate::serialize_unsupported_method!{serialize_tuple_variant(name: &'static str, variant_index: u32, variant: &'static str, len: usize) -> Result<SerializeTupleVariant>}
};
(map) => {
$crate::serialize_unsupported_method!{serialize_map(len: Option<usize>) -> Result<SerializeMap>}
};
(struct) => {
$crate::serialize_unsupported_method!{serialize_struct(name: &'static str, len: usize) -> Result<SerializeStruct>}
};
(struct_variant) => {
$crate::serialize_unsupported_method!{serialize_struct_variant(name: &'static str, variant_index: u32, variant: &'static str, len: usize) -> Result<SerializeStructVariant>}
};
($($func:ident)*) => {
$($crate::serialize_unsupported!{$func})*
};
}
#[macro_export]
#[doc(hidden)]
macro_rules! serialize_unsupported_method {
($func:ident<T>($($arg:ident : $ty:ty),*)) => {
#[inline]
fn $func<T>(self, $($arg: $ty,)*) -> $crate::Result<Self::Ok, Self::Error>
where
T: ?Sized + serde::ser::Serialize,
{
$(
let _ = $arg;
)*
Err(serde::ser::Error::custom(std::format!("`{}` not supported", std::stringify!($func))))
}
};
($func:ident($($arg:ident : $ty:ty),*) -> Result<$rty:ident>) => {
#[inline]
fn $func(self, $($arg: $ty,)*) -> $crate::Result<Self::$rty, Self::Error> {
$(
let _ = $arg;
)*
Err(serde::ser::Error::custom(std::format!("`{}` not supported", std::stringify!($func))))
}
};
($func:ident($($arg:ident : $ty:ty),*)) => {
#[inline]
fn $func(self, $($arg: $ty,)*) -> $crate::Result<Self::Ok, Self::Error> {
$(
let _ = $arg;
)*
Err(serde::ser::Error::custom(std::format!("`{}` not supported", std::stringify!($func))))
}
};
}
#[macro_export]
#[doc(hidden)]
macro_rules! serialize_self {
(some) => {
$crate::serialize_self_method!{serialize_some()}
};
(newtype_struct) => {
$crate::serialize_self_method!{serialize_newtype_struct(name: &'static str)}
};
(newtype_variant) => {
$crate::serialize_self_method!{serialize_newtype_variant(name: &'static str, variant_index: u32, variant: &'static str)}
};
($($func:ident)*) => {
$($crate::serialize_self!{$func})*
};
}
#[macro_export]
#[doc(hidden)]
macro_rules! serialize_self_method {
($func:ident($($arg:ident : $ty:ty),*)) => {
#[inline]
fn $func<T>(self, $($arg: $ty,)* value: &T) -> $crate::Result<Self::Ok, Self::Error>
where
T: ?Sized + serde::ser::Serialize,
{
$(
let _ = $arg;
)*
value.serialize(self)
}
};
}
#[macro_export]
#[doc(hidden)]
macro_rules! forward_to_serialize_seq {
(tuple) => {
$crate::forward_to_serialize_seq_method!{serialize_tuple() -> Result<SerializeTuple>}
};
(tuple_struct) => {
$crate::forward_to_serialize_seq_method!{serialize_tuple_struct(name: &'static str) -> Result<SerializeTupleStruct>}
};
($($func:ident)*) => {
$($crate::forward_to_serialize_seq!{$func})*
};
}
#[macro_export]
#[doc(hidden)]
macro_rules! forward_to_serialize_seq_method {
($func:ident($($arg:ident : $ty:ty),*) -> Result<$rty:ident>) => {
#[inline]
fn $func(self, $($arg: $ty,)* len: usize) -> $crate::Result<Self::$rty, Self::Error> {
$(
let _ = $arg;
)*
self.serialize_seq(Some(len))
}
};
}
#[macro_export]
#[doc(hidden)]
macro_rules! impl_forward_to_serialize_seq {
($method:ident, $ok:ty, $error:ty) => {
type Ok = $ok;
type Error = $error;
impl_forward_to_serialize_seq!($method);
};
($method:ident, $ok:ty) => {
impl_forward_to_serialize_seq!($method, $ok, $crate::Error);
};
($method:ident) => {
fn $method<T>(&mut self, value: &T) -> $crate::Result<(), Self::Error>
where
T: ?Sized + serde::ser::Serialize,
{
serde::ser::SerializeSeq::serialize_element(self, value)
}
fn end(self) -> $crate::Result<Self::Ok, Self::Error> {
serde::ser::SerializeSeq::end(self)
}
};
}
#[macro_export]
#[doc(hidden)]
macro_rules! impl_forward_to_inner {
($ty:ty, $($tt:tt)+) => {
type Ok = $ty;
type Error = $crate::Error;
impl_forward_to_inner_internal!($($tt)+);
fn end(self) -> $crate::Result<Self::Ok, Self::Error> {
self.inner.end().map(Into::into)
}
};
}
#[macro_export]
#[doc(hidden)]
macro_rules! impl_forward_to_inner_internal {
($method:ident($($arg:ident: $ty:ty),*) $(,$rest:tt)*) => {
fn $method<T>(&mut self, $($arg: $ty,)* value: &T) -> $crate::Result<(), Self::Error>
where
T: ?Sized + serde::ser::Serialize,
{
self.inner.$method($($arg,)* value)
}
impl_forward_to_inner_internal!($($rest),*);
};
($method:ident $(,$rest:tt)*) => {
impl_forward_to_inner_internal!($method() $(,$rest)*);
};
() => {};
}
#[macro_export]
#[doc(hidden)]
macro_rules! impl_deserialize_enum {
() => {
fn deserialize_enum<V>(
self,
_name: &'static str,
_variants: &'static [&'static str],
visitor: V,
) -> $crate::Result<V::Value, Self::Error>
where
V: serde::de::Visitor<'de>,
{
visitor.visit_enum($crate::de::EnumAccess::new(self))
}
};
}
#[macro_export]
#[doc(hidden)]
macro_rules! impl_variant_name {
($($ty:ident => { $($variant:ident),+ }),*) => {
$(
impl $crate::de::VariantName for $ty {
fn variant_name(&self) -> &'static str {
match self {
$(
$ty::$variant { .. } => std::stringify!($variant),
)*
}
}
}
)*
};
}
#[macro_export]
#[doc(hidden)]
macro_rules! impl_into_map_access_deserializer {
($($ty:ty => $access:ident),*) => {
$(
impl<'de> serde::de::IntoDeserializer<'de, Error> for $ty {
type Deserializer = serde::de::value::MapAccessDeserializer<$access>;
fn into_deserializer(self) -> Self::Deserializer {
serde::de::value::MapAccessDeserializer::new($access::new(self))
}
}
)*
};
}