From 15abc71201ec178591da3b993c1b8bb2543d49e9 Mon Sep 17 00:00:00 2001 From: jskoiz <20649937+jskoiz@users.noreply.github.com> Date: Mon, 8 Jun 2026 10:17:29 -1000 Subject: [PATCH] Reduce serde and iterator forwarding boilerplate Collapse hand-copied forwarding methods into three small declarative macros, replacing roughly 115 near-identical method bodies: - with.rs: forward_singleton_deserialize! for the SingletonMap and SingletonMapRecursive Deserializer impls, and forward_visit_scalars! for the recursive Visitor's scalar visits. The recursive visit_some/seq/map/newtype methods stay explicit. - ser.rs: serialize_value_from_scalars! for the uniform fixed-width integer and float serialize methods across five Serializer impls. bool, i128, and u128 keep their per-serializer handling. - ast.rs: mapping_projection_iter! for the Mapping key/value iterator views. IntoIter stays explicit. Also remove two unused private helpers in event_de. No behavior change; the public API is unchanged. --- src/ast.rs | 222 +++++---------- src/event_de/source.rs | 18 -- src/ser.rs | 252 ++++------------- src/with.rs | 602 ++++++++--------------------------------- 4 files changed, 228 insertions(+), 866 deletions(-) diff --git a/src/ast.rs b/src/ast.rs index d662b4e..88bb153 100644 --- a/src/ast.rs +++ b/src/ast.rs @@ -1782,63 +1782,77 @@ where } } -/// Iterator over borrowed mapping key/value pairs. -pub struct Iter<'a> { - iter: std::slice::Iter<'a, (Value, Value)>, -} +/// Generates the `Iterator`/`DoubleEndedIterator`/`ExactSizeIterator` trio for a +/// mapping view that projects the inner `(Value, Value)` pair iterator. The first +/// arm handles borrowed views (with a lifetime), the second owning views. +macro_rules! mapping_projection_iter { + ($name:ident<$lt:lifetime>, $item:ty, |$pair:pat_param| $proj:expr) => { + impl<$lt> Iterator for $name<$lt> { + type Item = $item; + + fn next(&mut self) -> Option { + self.iter.next().map(|$pair| $proj) + } -impl<'a> Iterator for Iter<'a> { - type Item = (&'a Value, &'a Value); + fn size_hint(&self) -> (usize, Option) { + self.iter.size_hint() + } + } - fn next(&mut self) -> Option { - self.iter.next().map(|(key, value)| (key, value)) - } + impl DoubleEndedIterator for $name<'_> { + fn next_back(&mut self) -> Option { + self.iter.next_back().map(|$pair| $proj) + } + } - fn size_hint(&self) -> (usize, Option) { - self.iter.size_hint() - } -} + impl ExactSizeIterator for $name<'_> { + fn len(&self) -> usize { + self.iter.len() + } + } + }; + ($name:ident, $item:ty, |$pair:pat_param| $proj:expr) => { + impl Iterator for $name { + type Item = $item; -impl DoubleEndedIterator for Iter<'_> { - fn next_back(&mut self) -> Option { - self.iter.next_back().map(|(key, value)| (key, value)) - } + fn next(&mut self) -> Option { + self.iter.next().map(|$pair| $proj) + } + + fn size_hint(&self) -> (usize, Option) { + self.iter.size_hint() + } + } + + impl DoubleEndedIterator for $name { + fn next_back(&mut self) -> Option { + self.iter.next_back().map(|$pair| $proj) + } + } + + impl ExactSizeIterator for $name { + fn len(&self) -> usize { + self.iter.len() + } + } + }; } -impl ExactSizeIterator for Iter<'_> { - fn len(&self) -> usize { - self.iter.len() - } +/// Iterator over borrowed mapping key/value pairs. +pub struct Iter<'a> { + iter: std::slice::Iter<'a, (Value, Value)>, } +mapping_projection_iter!(Iter<'a>, (&'a Value, &'a Value), |(key, value)| (key, value)); + /// Iterator over borrowed mapping keys and mutable values. pub struct IterMut<'a> { iter: std::slice::IterMut<'a, (Value, Value)>, } -impl<'a> Iterator for IterMut<'a> { - type Item = (&'a Value, &'a mut Value); - - fn next(&mut self) -> Option { - self.iter.next().map(|(key, value)| (&*key, value)) - } - - fn size_hint(&self) -> (usize, Option) { - self.iter.size_hint() - } -} - -impl DoubleEndedIterator for IterMut<'_> { - fn next_back(&mut self) -> Option { - self.iter.next_back().map(|(key, value)| (&*key, value)) - } -} - -impl ExactSizeIterator for IterMut<'_> { - fn len(&self) -> usize { - self.iter.len() - } -} +mapping_projection_iter!(IterMut<'a>, (&'a Value, &'a mut Value), |(key, value)| ( + &*key, value +)); /// Owning iterator over mapping key/value pairs. pub struct IntoIter { @@ -1874,145 +1888,35 @@ pub struct Keys<'a> { iter: std::slice::Iter<'a, (Value, Value)>, } -impl<'a> Iterator for Keys<'a> { - type Item = &'a Value; - - fn next(&mut self) -> Option { - self.iter.next().map(|(key, _)| key) - } - - fn size_hint(&self) -> (usize, Option) { - self.iter.size_hint() - } -} - -impl DoubleEndedIterator for Keys<'_> { - fn next_back(&mut self) -> Option { - self.iter.next_back().map(|(key, _)| key) - } -} - -impl ExactSizeIterator for Keys<'_> { - fn len(&self) -> usize { - self.iter.len() - } -} +mapping_projection_iter!(Keys<'a>, &'a Value, |(key, _)| key); /// Owning iterator over mapping keys. pub struct IntoKeys { iter: std::vec::IntoIter<(Value, Value)>, } -impl Iterator for IntoKeys { - type Item = Value; - - fn next(&mut self) -> Option { - self.iter.next().map(|(key, _)| key) - } - - fn size_hint(&self) -> (usize, Option) { - self.iter.size_hint() - } -} - -impl DoubleEndedIterator for IntoKeys { - fn next_back(&mut self) -> Option { - self.iter.next_back().map(|(key, _)| key) - } -} - -impl ExactSizeIterator for IntoKeys { - fn len(&self) -> usize { - self.iter.len() - } -} +mapping_projection_iter!(IntoKeys, Value, |(key, _)| key); /// Iterator over borrowed mapping values. pub struct Values<'a> { iter: std::slice::Iter<'a, (Value, Value)>, } -impl<'a> Iterator for Values<'a> { - type Item = &'a Value; - - fn next(&mut self) -> Option { - self.iter.next().map(|(_, value)| value) - } - - fn size_hint(&self) -> (usize, Option) { - self.iter.size_hint() - } -} - -impl DoubleEndedIterator for Values<'_> { - fn next_back(&mut self) -> Option { - self.iter.next_back().map(|(_, value)| value) - } -} - -impl ExactSizeIterator for Values<'_> { - fn len(&self) -> usize { - self.iter.len() - } -} +mapping_projection_iter!(Values<'a>, &'a Value, |(_, value)| value); /// Iterator over mutable mapping values. pub struct ValuesMut<'a> { iter: std::slice::IterMut<'a, (Value, Value)>, } -impl<'a> Iterator for ValuesMut<'a> { - type Item = &'a mut Value; - - fn next(&mut self) -> Option { - self.iter.next().map(|(_, value)| value) - } - - fn size_hint(&self) -> (usize, Option) { - self.iter.size_hint() - } -} - -impl DoubleEndedIterator for ValuesMut<'_> { - fn next_back(&mut self) -> Option { - self.iter.next_back().map(|(_, value)| value) - } -} - -impl ExactSizeIterator for ValuesMut<'_> { - fn len(&self) -> usize { - self.iter.len() - } -} +mapping_projection_iter!(ValuesMut<'a>, &'a mut Value, |(_, value)| value); /// Owning iterator over mapping values. pub struct IntoValues { iter: std::vec::IntoIter<(Value, Value)>, } -impl Iterator for IntoValues { - type Item = Value; - - fn next(&mut self) -> Option { - self.iter.next().map(|(_, value)| value) - } - - fn size_hint(&self) -> (usize, Option) { - self.iter.size_hint() - } -} - -impl DoubleEndedIterator for IntoValues { - fn next_back(&mut self) -> Option { - self.iter.next_back().map(|(_, value)| value) - } -} - -impl ExactSizeIterator for IntoValues { - fn len(&self) -> usize { - self.iter.len() - } -} +mapping_projection_iter!(IntoValues, Value, |(_, value)| value); /// Entry view into a [`Mapping`]. pub enum Entry<'a> { diff --git a/src/event_de/source.rs b/src/event_de/source.rs index d945510..abc042c 100644 --- a/src/event_de/source.rs +++ b/src/event_de/source.rs @@ -631,24 +631,6 @@ impl<'de> EventSource<'de> { } } - fn scalar_key_at(&self, pos: usize) -> Result> { - self.scalar_key_at_in(&self.events, pos) - } - - fn scalar_key_at_in(&self, events: &[Event], pos: usize) -> Result> { - let Some(Event::Scalar { - value, - style, - meta, - span, - }) = events.get(pos) - else { - return Ok(None); - }; - self.scalar_from_event(value.clone(), *style, meta, *span) - .map(|node| Some((node, pos + 1))) - } - fn scalar_key_node_from_event( &self, value: String, diff --git a/src/ser.rs b/src/ser.rs index 28a3881..ececfd5 100644 --- a/src/ser.rs +++ b/src/ser.rs @@ -35,6 +35,56 @@ const NUMBER_STRUCT: &str = "$saneyaml::Number"; const BYTES_UNSUPPORTED: &str = "serialization of bytes in YAML is not implemented"; const MAX_SERIALIZE_HINT_PREALLOC: usize = 4096; +/// Generates the `Serializer` numeric scalar methods that all map through +/// `Value::from`. Only the fixed-width integer/float types that share a single +/// uniform body are generated here; `bool`, `i128`, and `u128` keep their +/// per-serializer handling (lossless 128-bit narrowing, etc.) and stay +/// hand-written. `|value| ` names how the resulting [`Value`] is wrapped. +macro_rules! serialize_value_from_scalars { + ($ret:ty, |$converted:ident| $wrap:expr) => { + fn serialize_i8(self, value: i8) -> $ret { + let $converted = Value::from(value); + $wrap + } + fn serialize_i16(self, value: i16) -> $ret { + let $converted = Value::from(value); + $wrap + } + fn serialize_i32(self, value: i32) -> $ret { + let $converted = Value::from(value); + $wrap + } + fn serialize_i64(self, value: i64) -> $ret { + let $converted = Value::from(value); + $wrap + } + fn serialize_u8(self, value: u8) -> $ret { + let $converted = Value::from(value); + $wrap + } + fn serialize_u16(self, value: u16) -> $ret { + let $converted = Value::from(value); + $wrap + } + fn serialize_u32(self, value: u32) -> $ret { + let $converted = Value::from(value); + $wrap + } + fn serialize_u64(self, value: u64) -> $ret { + let $converted = Value::from(value); + $wrap + } + fn serialize_f32(self, value: f32) -> $ret { + let $converted = Value::from(value); + $wrap + } + fn serialize_f64(self, value: f64) -> $ret { + let $converted = Value::from(value); + $wrap + } + }; +} + /// Converts a serializable value into a YAML [`Value`]. pub fn to_value(value: T) -> Result where @@ -629,21 +679,7 @@ impl ser::Serializer for ValueSerializer { Ok(Value::Bool(value)) } - fn serialize_i8(self, value: i8) -> Result { - Ok(Value::from(value)) - } - - fn serialize_i16(self, value: i16) -> Result { - Ok(Value::from(value)) - } - - fn serialize_i32(self, value: i32) -> Result { - Ok(Value::from(value)) - } - - fn serialize_i64(self, value: i64) -> Result { - Ok(Value::from(value)) - } + serialize_value_from_scalars!(Result, |converted| Ok(converted)); /// Serializes a 128-bit signed integer losslessly. /// @@ -662,22 +698,6 @@ impl ser::Serializer for ValueSerializer { } } - fn serialize_u8(self, value: u8) -> Result { - Ok(Value::from(value)) - } - - fn serialize_u16(self, value: u16) -> Result { - Ok(Value::from(value)) - } - - fn serialize_u32(self, value: u32) -> Result { - Ok(Value::from(value)) - } - - fn serialize_u64(self, value: u64) -> Result { - Ok(Value::from(value)) - } - /// Serializes a 128-bit unsigned integer losslessly. /// /// Values that fit in `u64` are narrowed to match the corresponding @@ -692,14 +712,6 @@ impl ser::Serializer for ValueSerializer { } } - fn serialize_f32(self, value: f32) -> Result { - Ok(Value::from(value)) - } - - fn serialize_f64(self, value: f64) -> Result { - Ok(Value::from(value)) - } - fn serialize_char(self, value: char) -> Result { Ok(Value::String(value.to_string())) } @@ -871,54 +883,16 @@ impl ser::Serializer for NestedValueSerializer { ValueSerializer.serialize_bool(value) } - fn serialize_i8(self, value: i8) -> Result { - ValueSerializer.serialize_i8(value) - } - - fn serialize_i16(self, value: i16) -> Result { - ValueSerializer.serialize_i16(value) - } - - fn serialize_i32(self, value: i32) -> Result { - ValueSerializer.serialize_i32(value) - } - - fn serialize_i64(self, value: i64) -> Result { - ValueSerializer.serialize_i64(value) - } + serialize_value_from_scalars!(Result, |converted| Ok(converted)); fn serialize_i128(self, value: i128) -> Result { ValueSerializer.serialize_i128(value) } - fn serialize_u8(self, value: u8) -> Result { - ValueSerializer.serialize_u8(value) - } - - fn serialize_u16(self, value: u16) -> Result { - ValueSerializer.serialize_u16(value) - } - - fn serialize_u32(self, value: u32) -> Result { - ValueSerializer.serialize_u32(value) - } - - fn serialize_u64(self, value: u64) -> Result { - ValueSerializer.serialize_u64(value) - } - fn serialize_u128(self, value: u128) -> Result { ValueSerializer.serialize_u128(value) } - fn serialize_f32(self, value: f32) -> Result { - ValueSerializer.serialize_f32(value) - } - - fn serialize_f64(self, value: f64) -> Result { - ValueSerializer.serialize_f64(value) - } - fn serialize_char(self, value: char) -> Result { ValueSerializer.serialize_char(value) } @@ -1083,54 +1057,16 @@ impl ser::Serializer for ByteCompatibleRootSerializer { Ok(node_from_value(Value::Bool(value))) } - fn serialize_i8(self, value: i8) -> Result { - Ok(node_from_value(Value::from(value))) - } - - fn serialize_i16(self, value: i16) -> Result { - Ok(node_from_value(Value::from(value))) - } - - fn serialize_i32(self, value: i32) -> Result { - Ok(node_from_value(Value::from(value))) - } - - fn serialize_i64(self, value: i64) -> Result { - Ok(node_from_value(Value::from(value))) - } + serialize_value_from_scalars!(Result, |converted| Ok(node_from_value(converted))); fn serialize_i128(self, value: i128) -> Result { Ok(node_from_value(ValueSerializer.serialize_i128(value)?)) } - fn serialize_u8(self, value: u8) -> Result { - Ok(node_from_value(Value::from(value))) - } - - fn serialize_u16(self, value: u16) -> Result { - Ok(node_from_value(Value::from(value))) - } - - fn serialize_u32(self, value: u32) -> Result { - Ok(node_from_value(Value::from(value))) - } - - fn serialize_u64(self, value: u64) -> Result { - Ok(node_from_value(Value::from(value))) - } - fn serialize_u128(self, value: u128) -> Result { Ok(node_from_value(ValueSerializer.serialize_u128(value)?)) } - fn serialize_f32(self, value: f32) -> Result { - Ok(node_from_value(Value::from(value))) - } - - fn serialize_f64(self, value: f64) -> Result { - Ok(node_from_value(Value::from(value))) - } - fn serialize_char(self, value: char) -> Result { Ok(byte_compatible_single_quoted_node(value.to_string())) } @@ -1734,54 +1670,18 @@ impl ser::Serializer for TagDetectingKeySerializer { Ok(SerializedKey::Value(Value::Bool(value))) } - fn serialize_i8(self, value: i8) -> Result { - Ok(SerializedKey::Value(Value::from(value))) - } - - fn serialize_i16(self, value: i16) -> Result { - Ok(SerializedKey::Value(Value::from(value))) - } - - fn serialize_i32(self, value: i32) -> Result { - Ok(SerializedKey::Value(Value::from(value))) - } - - fn serialize_i64(self, value: i64) -> Result { - Ok(SerializedKey::Value(Value::from(value))) - } + serialize_value_from_scalars!(Result, |converted| Ok(SerializedKey::Value( + converted + ))); fn serialize_i128(self, value: i128) -> Result { Ok(SerializedKey::Value(ValueSerializer.serialize_i128(value)?)) } - fn serialize_u8(self, value: u8) -> Result { - Ok(SerializedKey::Value(Value::from(value))) - } - - fn serialize_u16(self, value: u16) -> Result { - Ok(SerializedKey::Value(Value::from(value))) - } - - fn serialize_u32(self, value: u32) -> Result { - Ok(SerializedKey::Value(Value::from(value))) - } - - fn serialize_u64(self, value: u64) -> Result { - Ok(SerializedKey::Value(Value::from(value))) - } - fn serialize_u128(self, value: u128) -> Result { Ok(SerializedKey::Value(ValueSerializer.serialize_u128(value)?)) } - fn serialize_f32(self, value: f32) -> Result { - Ok(SerializedKey::Value(Value::from(value))) - } - - fn serialize_f64(self, value: f64) -> Result { - Ok(SerializedKey::Value(Value::from(value))) - } - fn serialize_char(self, value: char) -> Result { Ok(SerializedKey::Value(Value::String(value.to_string()))) } @@ -2313,54 +2213,16 @@ impl ser::Serializer for PreserveNumberSerializer { Ok(Value::Bool(value)) } - fn serialize_i8(self, value: i8) -> Result { - Ok(Value::from(value)) - } - - fn serialize_i16(self, value: i16) -> Result { - Ok(Value::from(value)) - } - - fn serialize_i32(self, value: i32) -> Result { - Ok(Value::from(value)) - } - - fn serialize_i64(self, value: i64) -> Result { - Ok(Value::from(value)) - } + serialize_value_from_scalars!(Result, |converted| Ok(converted)); fn serialize_i128(self, value: i128) -> Result { Ok(Value::Number(Number::Integer(value))) } - fn serialize_u8(self, value: u8) -> Result { - Ok(Value::from(value)) - } - - fn serialize_u16(self, value: u16) -> Result { - Ok(Value::from(value)) - } - - fn serialize_u32(self, value: u32) -> Result { - Ok(Value::from(value)) - } - - fn serialize_u64(self, value: u64) -> Result { - Ok(Value::from(value)) - } - fn serialize_u128(self, value: u128) -> Result { Ok(Value::Number(Number::Unsigned(value))) } - fn serialize_f32(self, value: f32) -> Result { - Ok(Value::from(value)) - } - - fn serialize_f64(self, value: f64) -> Result { - Ok(Value::from(value)) - } - fn serialize_char(self, value: char) -> Result { Ok(Value::String(value.to_string())) } diff --git a/src/with.rs b/src/with.rs index 87eca15..a308edb 100644 --- a/src/with.rs +++ b/src/with.rs @@ -24,6 +24,41 @@ use crate::{Mapping, Value}; +/// Generates the trivial single-visitor-argument `Deserializer` forwarding +/// methods shared by the `singleton_map` and `singleton_map_recursive` wrappers. +/// +/// `|visitor| ` describes how the incoming visitor is handed to the +/// delegate: verbatim for the non-recursive wrapper, re-wrapped for the +/// recursive one. +macro_rules! forward_singleton_deserialize { + (|$visitor:ident| $wrapped:expr; $($method:ident),+ $(,)?) => { + $( + fn $method(self, $visitor: V) -> Result + where + V: Visitor<'de>, + { + self.delegate.$method($wrapped) + } + )+ + }; +} + +/// Generates the trivial value-carrying `Visitor` scalar forwarding methods. +/// Scalars cannot contain nested enums, so the recursive wrapper forwards them +/// to its delegate unchanged. +macro_rules! forward_visit_scalars { + ($($method:ident($ty:ty)),+ $(,)?) => { + $( + fn $method(self, value: $ty) -> Result + where + E: de::Error, + { + self.delegate.$method(value) + } + )+ + }; +} + fn tagged_to_singleton_map(value: Value, recursive: bool) -> Value { match value { Value::Tagged(tagged) => { @@ -108,137 +143,32 @@ pub mod singleton_map { { type Error = D::Error; - fn deserialize_any(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate.deserialize_any(visitor) - } - - fn deserialize_bool(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate.deserialize_bool(visitor) - } - - fn deserialize_i8(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate.deserialize_i8(visitor) - } - - fn deserialize_i16(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate.deserialize_i16(visitor) - } - - fn deserialize_i32(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate.deserialize_i32(visitor) - } - - fn deserialize_i64(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate.deserialize_i64(visitor) - } - - fn deserialize_i128(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate.deserialize_i128(visitor) - } - - fn deserialize_u8(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate.deserialize_u8(visitor) - } - - fn deserialize_u16(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate.deserialize_u16(visitor) - } - - fn deserialize_u32(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate.deserialize_u32(visitor) - } - - fn deserialize_u64(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate.deserialize_u64(visitor) - } - - fn deserialize_u128(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate.deserialize_u128(visitor) - } - - fn deserialize_f32(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate.deserialize_f32(visitor) - } - - fn deserialize_f64(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate.deserialize_f64(visitor) - } - - fn deserialize_char(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate.deserialize_char(visitor) - } - - fn deserialize_str(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate.deserialize_str(visitor) - } - - fn deserialize_string(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate.deserialize_string(visitor) - } - - fn deserialize_bytes(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate.deserialize_bytes(visitor) - } - - fn deserialize_byte_buf(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate.deserialize_byte_buf(visitor) + forward_singleton_deserialize! { + |visitor| visitor; + deserialize_any, + deserialize_bool, + deserialize_i8, + deserialize_i16, + deserialize_i32, + deserialize_i64, + deserialize_i128, + deserialize_u8, + deserialize_u16, + deserialize_u32, + deserialize_u64, + deserialize_u128, + deserialize_f32, + deserialize_f64, + deserialize_char, + deserialize_str, + deserialize_string, + deserialize_bytes, + deserialize_byte_buf, + deserialize_unit, + deserialize_seq, + deserialize_map, + deserialize_identifier, + deserialize_ignored_any, } fn deserialize_option(self, visitor: V) -> Result @@ -251,13 +181,6 @@ pub mod singleton_map { }) } - fn deserialize_unit(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate.deserialize_unit(visitor) - } - fn deserialize_unit_struct( self, name: &'static str, @@ -280,13 +203,6 @@ pub mod singleton_map { self.delegate.deserialize_newtype_struct(name, visitor) } - fn deserialize_seq(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate.deserialize_seq(visitor) - } - fn deserialize_tuple(self, len: usize, visitor: V) -> Result where V: Visitor<'de>, @@ -306,13 +222,6 @@ pub mod singleton_map { self.delegate.deserialize_tuple_struct(name, len, visitor) } - fn deserialize_map(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate.deserialize_map(visitor) - } - fn deserialize_struct( self, name: &'static str, @@ -340,20 +249,6 @@ pub mod singleton_map { }) } - fn deserialize_identifier(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate.deserialize_identifier(visitor) - } - - fn deserialize_ignored_any(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate.deserialize_ignored_any(visitor) - } - fn is_human_readable(&self) -> bool { self.delegate.is_human_readable() } @@ -602,156 +497,32 @@ pub mod singleton_map_recursive { { type Error = D::Error; - fn deserialize_any(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate - .deserialize_any(SingletonMapRecursive { delegate: visitor }) - } - - fn deserialize_bool(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate - .deserialize_bool(SingletonMapRecursive { delegate: visitor }) - } - - fn deserialize_i8(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate - .deserialize_i8(SingletonMapRecursive { delegate: visitor }) - } - - fn deserialize_i16(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate - .deserialize_i16(SingletonMapRecursive { delegate: visitor }) - } - - fn deserialize_i32(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate - .deserialize_i32(SingletonMapRecursive { delegate: visitor }) - } - - fn deserialize_i64(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate - .deserialize_i64(SingletonMapRecursive { delegate: visitor }) - } - - fn deserialize_i128(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate - .deserialize_i128(SingletonMapRecursive { delegate: visitor }) - } - - fn deserialize_u8(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate - .deserialize_u8(SingletonMapRecursive { delegate: visitor }) - } - - fn deserialize_u16(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate - .deserialize_u16(SingletonMapRecursive { delegate: visitor }) - } - - fn deserialize_u32(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate - .deserialize_u32(SingletonMapRecursive { delegate: visitor }) - } - - fn deserialize_u64(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate - .deserialize_u64(SingletonMapRecursive { delegate: visitor }) - } - - fn deserialize_u128(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate - .deserialize_u128(SingletonMapRecursive { delegate: visitor }) - } - - fn deserialize_f32(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate - .deserialize_f32(SingletonMapRecursive { delegate: visitor }) - } - - fn deserialize_f64(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate - .deserialize_f64(SingletonMapRecursive { delegate: visitor }) - } - - fn deserialize_char(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate - .deserialize_char(SingletonMapRecursive { delegate: visitor }) - } - - fn deserialize_str(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate - .deserialize_str(SingletonMapRecursive { delegate: visitor }) - } - - fn deserialize_string(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate - .deserialize_string(SingletonMapRecursive { delegate: visitor }) - } - - fn deserialize_bytes(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate - .deserialize_bytes(SingletonMapRecursive { delegate: visitor }) - } - - fn deserialize_byte_buf(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate - .deserialize_byte_buf(SingletonMapRecursive { delegate: visitor }) + forward_singleton_deserialize! { + |visitor| SingletonMapRecursive { delegate: visitor }; + deserialize_any, + deserialize_bool, + deserialize_i8, + deserialize_i16, + deserialize_i32, + deserialize_i64, + deserialize_i128, + deserialize_u8, + deserialize_u16, + deserialize_u32, + deserialize_u64, + deserialize_u128, + deserialize_f32, + deserialize_f64, + deserialize_char, + deserialize_str, + deserialize_string, + deserialize_bytes, + deserialize_byte_buf, + deserialize_unit, + deserialize_seq, + deserialize_map, + deserialize_identifier, + deserialize_ignored_any, } fn deserialize_option(self, visitor: V) -> Result @@ -765,14 +536,6 @@ pub mod singleton_map_recursive { }) } - fn deserialize_unit(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate - .deserialize_unit(SingletonMapRecursive { delegate: visitor }) - } - fn deserialize_unit_struct( self, name: &'static str, @@ -797,14 +560,6 @@ pub mod singleton_map_recursive { .deserialize_newtype_struct(name, SingletonMapRecursive { delegate: visitor }) } - fn deserialize_seq(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate - .deserialize_seq(SingletonMapRecursive { delegate: visitor }) - } - fn deserialize_tuple(self, len: usize, visitor: V) -> Result where V: Visitor<'de>, @@ -829,14 +584,6 @@ pub mod singleton_map_recursive { ) } - fn deserialize_map(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate - .deserialize_map(SingletonMapRecursive { delegate: visitor }) - } - fn deserialize_struct( self, name: &'static str, @@ -868,22 +615,6 @@ pub mod singleton_map_recursive { }) } - fn deserialize_identifier(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate - .deserialize_identifier(SingletonMapRecursive { delegate: visitor }) - } - - fn deserialize_ignored_any(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - self.delegate - .deserialize_ignored_any(SingletonMapRecursive { delegate: visitor }) - } - fn is_human_readable(&self) -> bool { self.delegate.is_human_readable() } @@ -899,144 +630,27 @@ pub mod singleton_map_recursive { self.delegate.expecting(formatter) } - fn visit_bool(self, value: bool) -> Result - where - E: de::Error, - { - self.delegate.visit_bool(value) - } - - fn visit_i8(self, value: i8) -> Result - where - E: de::Error, - { - self.delegate.visit_i8(value) - } - - fn visit_i16(self, value: i16) -> Result - where - E: de::Error, - { - self.delegate.visit_i16(value) - } - - fn visit_i32(self, value: i32) -> Result - where - E: de::Error, - { - self.delegate.visit_i32(value) - } - - fn visit_i64(self, value: i64) -> Result - where - E: de::Error, - { - self.delegate.visit_i64(value) - } - - fn visit_i128(self, value: i128) -> Result - where - E: de::Error, - { - self.delegate.visit_i128(value) - } - - fn visit_u8(self, value: u8) -> Result - where - E: de::Error, - { - self.delegate.visit_u8(value) - } - - fn visit_u16(self, value: u16) -> Result - where - E: de::Error, - { - self.delegate.visit_u16(value) - } - - fn visit_u32(self, value: u32) -> Result - where - E: de::Error, - { - self.delegate.visit_u32(value) - } - - fn visit_u64(self, value: u64) -> Result - where - E: de::Error, - { - self.delegate.visit_u64(value) - } - - fn visit_u128(self, value: u128) -> Result - where - E: de::Error, - { - self.delegate.visit_u128(value) - } - - fn visit_f32(self, value: f32) -> Result - where - E: de::Error, - { - self.delegate.visit_f32(value) - } - - fn visit_f64(self, value: f64) -> Result - where - E: de::Error, - { - self.delegate.visit_f64(value) - } - - fn visit_char(self, value: char) -> Result - where - E: de::Error, - { - self.delegate.visit_char(value) - } - - fn visit_str(self, value: &str) -> Result - where - E: de::Error, - { - self.delegate.visit_str(value) - } - - fn visit_borrowed_str(self, value: &'de str) -> Result - where - E: de::Error, - { - self.delegate.visit_borrowed_str(value) - } - - fn visit_string(self, value: String) -> Result - where - E: de::Error, - { - self.delegate.visit_string(value) - } - - fn visit_bytes(self, value: &[u8]) -> Result - where - E: de::Error, - { - self.delegate.visit_bytes(value) - } - - fn visit_borrowed_bytes(self, value: &'de [u8]) -> Result - where - E: de::Error, - { - self.delegate.visit_borrowed_bytes(value) - } - - fn visit_byte_buf(self, value: Vec) -> Result - where - E: de::Error, - { - self.delegate.visit_byte_buf(value) + forward_visit_scalars! { + visit_bool(bool), + visit_i8(i8), + visit_i16(i16), + visit_i32(i32), + visit_i64(i64), + visit_i128(i128), + visit_u8(u8), + visit_u16(u16), + visit_u32(u32), + visit_u64(u64), + visit_u128(u128), + visit_f32(f32), + visit_f64(f64), + visit_char(char), + visit_str(&str), + visit_borrowed_str(&'de str), + visit_string(String), + visit_bytes(&[u8]), + visit_borrowed_bytes(&'de [u8]), + visit_byte_buf(Vec), } fn visit_none(self) -> Result