use crate::lib::*; use crate::de::{ Deserialize, Deserializer, EnumAccess, Error, MapAccess, SeqAccess, Unexpected, VariantAccess, Visitor, }; use crate::seed::InPlaceSeed; #[cfg(any(feature = "std", feature = "alloc"))] use crate::de::size_hint; //////////////////////////////////////////////////////////////////////////////// struct UnitVisitor; impl<'de> Visitor<'de> for UnitVisitor { type Value = (); fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("unit") } fn visit_unit(self) -> Result where E: Error, { Ok(()) } } impl<'de> Deserialize<'de> for () { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { deserializer.deserialize_unit(UnitVisitor) } } #[cfg(feature = "unstable")] #[cfg_attr(doc_cfg, doc(cfg(feature = "unstable")))] impl<'de> Deserialize<'de> for ! { fn deserialize(_deserializer: D) -> Result where D: Deserializer<'de>, { Err(Error::custom("cannot deserialize `!`")) } } //////////////////////////////////////////////////////////////////////////////// struct BoolVisitor; impl<'de> Visitor<'de> for BoolVisitor { type Value = bool; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("a boolean") } fn visit_bool(self, v: bool) -> Result where E: Error, { Ok(v) } } impl<'de> Deserialize<'de> for bool { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { deserializer.deserialize_bool(BoolVisitor) } } //////////////////////////////////////////////////////////////////////////////// macro_rules! impl_deserialize_num { ($primitive:ident, $nonzero:ident $(cfg($($cfg:tt)*))*, $deserialize:ident $($method:ident!($($val:ident : $visit:ident)*);)*) => { impl_deserialize_num!($primitive, $deserialize $($method!($($val : $visit)*);)*); $(#[cfg($($cfg)*)])* impl<'de> Deserialize<'de> for num::$nonzero { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { struct NonZeroVisitor; impl<'de> Visitor<'de> for NonZeroVisitor { type Value = num::$nonzero; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str(concat!("a nonzero ", stringify!($primitive))) } $($($method!(nonzero $primitive $val : $visit);)*)* } deserializer.$deserialize(NonZeroVisitor) } } }; ($primitive:ident, $deserialize:ident $($method:ident!($($val:ident : $visit:ident)*);)*) => { impl<'de> Deserialize<'de> for $primitive { #[inline] fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { struct PrimitiveVisitor; impl<'de> Visitor<'de> for PrimitiveVisitor { type Value = $primitive; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str(stringify!($primitive)) } $($($method!($val : $visit);)*)* } deserializer.$deserialize(PrimitiveVisitor) } } }; } macro_rules! num_self { ($ty:ident : $visit:ident) => { #[inline] fn $visit(self, v: $ty) -> Result where E: Error, { Ok(v) } }; (nonzero $primitive:ident $ty:ident : $visit:ident) => { fn $visit(self, v: $ty) -> Result where E: Error, { if let Some(nonzero) = Self::Value::new(v) { Ok(nonzero) } else { Err(Error::invalid_value(Unexpected::Unsigned(0), &self)) } } }; } macro_rules! num_as_self { ($ty:ident : $visit:ident) => { #[inline] fn $visit(self, v: $ty) -> Result where E: Error, { Ok(v as Self::Value) } }; (nonzero $primitive:ident $ty:ident : $visit:ident) => { fn $visit(self, v: $ty) -> Result where E: Error, { if let Some(nonzero) = Self::Value::new(v as $primitive) { Ok(nonzero) } else { Err(Error::invalid_value(Unexpected::Unsigned(0), &self)) } } }; } macro_rules! num_as_copysign_self { ($ty:ident : $visit:ident) => { #[inline] fn $visit(self, v: $ty) -> Result where E: Error, { #[cfg(any(no_float_copysign, not(feature = "std")))] { Ok(v as Self::Value) } #[cfg(all(not(no_float_copysign), feature = "std"))] { // Preserve sign of NaN. The `as` produces a nondeterministic sign. let sign = if v.is_sign_positive() { 1.0 } else { -1.0 }; Ok((v as Self::Value).copysign(sign)) } } }; } macro_rules! int_to_int { ($ty:ident : $visit:ident) => { #[inline] fn $visit(self, v: $ty) -> Result where E: Error, { if Self::Value::min_value() as i64 <= v as i64 && v as i64 <= Self::Value::max_value() as i64 { Ok(v as Self::Value) } else { Err(Error::invalid_value(Unexpected::Signed(v as i64), &self)) } } }; (nonzero $primitive:ident $ty:ident : $visit:ident) => { fn $visit(self, v: $ty) -> Result where E: Error, { if $primitive::min_value() as i64 <= v as i64 && v as i64 <= $primitive::max_value() as i64 { if let Some(nonzero) = Self::Value::new(v as $primitive) { return Ok(nonzero); } } Err(Error::invalid_value(Unexpected::Signed(v as i64), &self)) } }; } macro_rules! int_to_uint { ($ty:ident : $visit:ident) => { #[inline] fn $visit(self, v: $ty) -> Result where E: Error, { if 0 <= v && v as u64 <= Self::Value::max_value() as u64 { Ok(v as Self::Value) } else { Err(Error::invalid_value(Unexpected::Signed(v as i64), &self)) } } }; (nonzero $primitive:ident $ty:ident : $visit:ident) => { fn $visit(self, v: $ty) -> Result where E: Error, { if 0 < v && v as u64 <= $primitive::max_value() as u64 { if let Some(nonzero) = Self::Value::new(v as $primitive) { return Ok(nonzero); } } Err(Error::invalid_value(Unexpected::Signed(v as i64), &self)) } }; } macro_rules! uint_to_self { ($ty:ident : $visit:ident) => { #[inline] fn $visit(self, v: $ty) -> Result where E: Error, { if v as u64 <= Self::Value::max_value() as u64 { Ok(v as Self::Value) } else { Err(Error::invalid_value(Unexpected::Unsigned(v as u64), &self)) } } }; (nonzero $primitive:ident $ty:ident : $visit:ident) => { fn $visit(self, v: $ty) -> Result where E: Error, { if v as u64 <= $primitive::max_value() as u64 { if let Some(nonzero) = Self::Value::new(v as $primitive) { return Ok(nonzero); } } Err(Error::invalid_value(Unexpected::Unsigned(v as u64), &self)) } }; } impl_deserialize_num! { i8, NonZeroI8 cfg(not(no_num_nonzero_signed)), deserialize_i8 num_self!(i8:visit_i8); int_to_int!(i16:visit_i16 i32:visit_i32 i64:visit_i64); uint_to_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64); } impl_deserialize_num! { i16, NonZeroI16 cfg(not(no_num_nonzero_signed)), deserialize_i16 num_self!(i16:visit_i16); num_as_self!(i8:visit_i8); int_to_int!(i32:visit_i32 i64:visit_i64); uint_to_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64); } impl_deserialize_num! { i32, NonZeroI32 cfg(not(no_num_nonzero_signed)), deserialize_i32 num_self!(i32:visit_i32); num_as_self!(i8:visit_i8 i16:visit_i16); int_to_int!(i64:visit_i64); uint_to_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64); } impl_deserialize_num! { i64, NonZeroI64 cfg(not(no_num_nonzero_signed)), deserialize_i64 num_self!(i64:visit_i64); num_as_self!(i8:visit_i8 i16:visit_i16 i32:visit_i32); uint_to_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64); } impl_deserialize_num! { isize, NonZeroIsize cfg(not(no_num_nonzero_signed)), deserialize_i64 num_as_self!(i8:visit_i8 i16:visit_i16); int_to_int!(i32:visit_i32 i64:visit_i64); uint_to_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64); } impl_deserialize_num! { u8, NonZeroU8, deserialize_u8 num_self!(u8:visit_u8); int_to_uint!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64); uint_to_self!(u16:visit_u16 u32:visit_u32 u64:visit_u64); } impl_deserialize_num! { u16, NonZeroU16, deserialize_u16 num_self!(u16:visit_u16); num_as_self!(u8:visit_u8); int_to_uint!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64); uint_to_self!(u32:visit_u32 u64:visit_u64); } impl_deserialize_num! { u32, NonZeroU32, deserialize_u32 num_self!(u32:visit_u32); num_as_self!(u8:visit_u8 u16:visit_u16); int_to_uint!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64); uint_to_self!(u64:visit_u64); } impl_deserialize_num! { u64, NonZeroU64, deserialize_u64 num_self!(u64:visit_u64); num_as_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32); int_to_uint!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64); } impl_deserialize_num! { usize, NonZeroUsize, deserialize_u64 num_as_self!(u8:visit_u8 u16:visit_u16); int_to_uint!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64); uint_to_self!(u32:visit_u32 u64:visit_u64); } impl_deserialize_num! { f32, deserialize_f32 num_self!(f32:visit_f32); num_as_copysign_self!(f64:visit_f64); num_as_self!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64); num_as_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64); } impl_deserialize_num! { f64, deserialize_f64 num_self!(f64:visit_f64); num_as_copysign_self!(f32:visit_f32); num_as_self!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64); num_as_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64); } macro_rules! num_128 { ($ty:ident : $visit:ident) => { fn $visit(self, v: $ty) -> Result where E: Error, { if v as i128 >= Self::Value::min_value() as i128 && v as u128 <= Self::Value::max_value() as u128 { Ok(v as Self::Value) } else { Err(Error::invalid_value( Unexpected::Other(stringify!($ty)), &self, )) } } }; (nonzero $primitive:ident $ty:ident : $visit:ident) => { fn $visit(self, v: $ty) -> Result where E: Error, { if v as i128 >= $primitive::min_value() as i128 && v as u128 <= $primitive::max_value() as u128 { if let Some(nonzero) = Self::Value::new(v as $primitive) { Ok(nonzero) } else { Err(Error::invalid_value(Unexpected::Unsigned(0), &self)) } } else { Err(Error::invalid_value( Unexpected::Other(stringify!($ty)), &self, )) } } }; } impl_deserialize_num! { i128, NonZeroI128 cfg(not(no_num_nonzero_signed)), deserialize_i128 num_self!(i128:visit_i128); num_as_self!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64); num_as_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64); num_128!(u128:visit_u128); } impl_deserialize_num! { u128, NonZeroU128, deserialize_u128 num_self!(u128:visit_u128); num_as_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64); int_to_uint!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64); num_128!(i128:visit_i128); } //////////////////////////////////////////////////////////////////////////////// struct CharVisitor; impl<'de> Visitor<'de> for CharVisitor { type Value = char; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("a character") } #[inline] fn visit_char(self, v: char) -> Result where E: Error, { Ok(v) } #[inline] fn visit_str(self, v: &str) -> Result where E: Error, { let mut iter = v.chars(); match (iter.next(), iter.next()) { (Some(c), None) => Ok(c), _ => Err(Error::invalid_value(Unexpected::Str(v), &self)), } } } impl<'de> Deserialize<'de> for char { #[inline] fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { deserializer.deserialize_char(CharVisitor) } } //////////////////////////////////////////////////////////////////////////////// #[cfg(any(feature = "std", feature = "alloc"))] struct StringVisitor; #[cfg(any(feature = "std", feature = "alloc"))] struct StringInPlaceVisitor<'a>(&'a mut String); #[cfg(any(feature = "std", feature = "alloc"))] impl<'de> Visitor<'de> for StringVisitor { type Value = String; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("a string") } fn visit_str(self, v: &str) -> Result where E: Error, { Ok(v.to_owned()) } fn visit_string(self, v: String) -> Result where E: Error, { Ok(v) } fn visit_bytes(self, v: &[u8]) -> Result where E: Error, { match str::from_utf8(v) { Ok(s) => Ok(s.to_owned()), Err(_) => Err(Error::invalid_value(Unexpected::Bytes(v), &self)), } } fn visit_byte_buf(self, v: Vec) -> Result where E: Error, { match String::from_utf8(v) { Ok(s) => Ok(s), Err(e) => Err(Error::invalid_value( Unexpected::Bytes(&e.into_bytes()), &self, )), } } } #[cfg(any(feature = "std", feature = "alloc"))] impl<'a, 'de> Visitor<'de> for StringInPlaceVisitor<'a> { type Value = (); fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("a string") } fn visit_str(self, v: &str) -> Result where E: Error, { self.0.clear(); self.0.push_str(v); Ok(()) } fn visit_string(self, v: String) -> Result where E: Error, { *self.0 = v; Ok(()) } fn visit_bytes(self, v: &[u8]) -> Result where E: Error, { match str::from_utf8(v) { Ok(s) => { self.0.clear(); self.0.push_str(s); Ok(()) } Err(_) => Err(Error::invalid_value(Unexpected::Bytes(v), &self)), } } fn visit_byte_buf(self, v: Vec) -> Result where E: Error, { match String::from_utf8(v) { Ok(s) => { *self.0 = s; Ok(()) } Err(e) => Err(Error::invalid_value( Unexpected::Bytes(&e.into_bytes()), &self, )), } } } #[cfg(any(feature = "std", feature = "alloc"))] #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))] impl<'de> Deserialize<'de> for String { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { deserializer.deserialize_string(StringVisitor) } fn deserialize_in_place(deserializer: D, place: &mut Self) -> Result<(), D::Error> where D: Deserializer<'de>, { deserializer.deserialize_string(StringInPlaceVisitor(place)) } } //////////////////////////////////////////////////////////////////////////////// struct StrVisitor; impl<'a> Visitor<'a> for StrVisitor { type Value = &'a str; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("a borrowed string") } fn visit_borrowed_str(self, v: &'a str) -> Result where E: Error, { Ok(v) // so easy } fn visit_borrowed_bytes(self, v: &'a [u8]) -> Result where E: Error, { str::from_utf8(v).map_err(|_| Error::invalid_value(Unexpected::Bytes(v), &self)) } } impl<'de: 'a, 'a> Deserialize<'de> for &'a str { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { deserializer.deserialize_str(StrVisitor) } } //////////////////////////////////////////////////////////////////////////////// struct BytesVisitor; impl<'a> Visitor<'a> for BytesVisitor { type Value = &'a [u8]; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("a borrowed byte array") } fn visit_borrowed_bytes(self, v: &'a [u8]) -> Result where E: Error, { Ok(v) } fn visit_borrowed_str(self, v: &'a str) -> Result where E: Error, { Ok(v.as_bytes()) } } impl<'de: 'a, 'a> Deserialize<'de> for &'a [u8] { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { deserializer.deserialize_bytes(BytesVisitor) } } //////////////////////////////////////////////////////////////////////////////// #[cfg(any(feature = "std", all(not(no_core_cstr), feature = "alloc")))] struct CStringVisitor; #[cfg(any(feature = "std", all(not(no_core_cstr), feature = "alloc")))] impl<'de> Visitor<'de> for CStringVisitor { type Value = CString; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("byte array") } fn visit_seq(self, mut seq: A) -> Result where A: SeqAccess<'de>, { let capacity = size_hint::cautious::(seq.size_hint()); let mut values = Vec::::with_capacity(capacity); while let Some(value) = tri!(seq.next_element()) { values.push(value); } CString::new(values).map_err(Error::custom) } fn visit_bytes(self, v: &[u8]) -> Result where E: Error, { CString::new(v).map_err(Error::custom) } fn visit_byte_buf(self, v: Vec) -> Result where E: Error, { CString::new(v).map_err(Error::custom) } fn visit_str(self, v: &str) -> Result where E: Error, { CString::new(v).map_err(Error::custom) } fn visit_string(self, v: String) -> Result where E: Error, { CString::new(v).map_err(Error::custom) } } #[cfg(any(feature = "std", all(not(no_core_cstr), feature = "alloc")))] #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))] impl<'de> Deserialize<'de> for CString { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { deserializer.deserialize_byte_buf(CStringVisitor) } } macro_rules! forwarded_impl { ( $(#[$attr:meta])* ($($id:ident),*), $ty:ty, $func:expr ) => { $(#[$attr])* impl<'de $(, $id : Deserialize<'de>,)*> Deserialize<'de> for $ty { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { Deserialize::deserialize(deserializer).map($func) } } } } forwarded_impl! { #[cfg(any(feature = "std", all(not(no_core_cstr), feature = "alloc")))] #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))] (), Box, CString::into_boxed_c_str } forwarded_impl! { (T), Reverse, Reverse } //////////////////////////////////////////////////////////////////////////////// struct OptionVisitor { marker: PhantomData, } impl<'de, T> Visitor<'de> for OptionVisitor where T: Deserialize<'de>, { type Value = Option; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("option") } #[inline] fn visit_unit(self) -> Result where E: Error, { Ok(None) } #[inline] fn visit_none(self) -> Result where E: Error, { Ok(None) } #[inline] fn visit_some(self, deserializer: D) -> Result where D: Deserializer<'de>, { T::deserialize(deserializer).map(Some) } fn __private_visit_untagged_option(self, deserializer: D) -> Result where D: Deserializer<'de>, { Ok(T::deserialize(deserializer).ok()) } } impl<'de, T> Deserialize<'de> for Option where T: Deserialize<'de>, { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { deserializer.deserialize_option(OptionVisitor { marker: PhantomData, }) } // The Some variant's repr is opaque, so we can't play cute tricks with its // tag to have deserialize_in_place build the content in place unconditionally. // // FIXME: investigate whether branching on the old value being Some to // deserialize_in_place the value is profitable (probably data-dependent?) } //////////////////////////////////////////////////////////////////////////////// struct PhantomDataVisitor { marker: PhantomData, } impl<'de, T: ?Sized> Visitor<'de> for PhantomDataVisitor { type Value = PhantomData; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("unit") } #[inline] fn visit_unit(self) -> Result where E: Error, { Ok(PhantomData) } } impl<'de, T: ?Sized> Deserialize<'de> for PhantomData { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { let visitor = PhantomDataVisitor { marker: PhantomData, }; deserializer.deserialize_unit_struct("PhantomData", visitor) } } //////////////////////////////////////////////////////////////////////////////// macro_rules! seq_impl { ( $(#[$attr:meta])* $ty:ident , $access:ident, $clear:expr, $with_capacity:expr, $reserve:expr, $insert:expr ) => { $(#[$attr])* impl<'de, T $(, $typaram)*> Deserialize<'de> for $ty where T: Deserialize<'de> $(+ $tbound1 $(+ $tbound2)*)*, $($typaram: $bound1 $(+ $bound2)*,)* { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { struct SeqVisitor { marker: PhantomData<$ty>, } impl<'de, T $(, $typaram)*> Visitor<'de> for SeqVisitor where T: Deserialize<'de> $(+ $tbound1 $(+ $tbound2)*)*, $($typaram: $bound1 $(+ $bound2)*,)* { type Value = $ty; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("a sequence") } #[inline] fn visit_seq(self, mut $access: A) -> Result where A: SeqAccess<'de>, { let mut values = $with_capacity; while let Some(value) = tri!($access.next_element()) { $insert(&mut values, value); } Ok(values) } } let visitor = SeqVisitor { marker: PhantomData }; deserializer.deserialize_seq(visitor) } fn deserialize_in_place(deserializer: D, place: &mut Self) -> Result<(), D::Error> where D: Deserializer<'de>, { struct SeqInPlaceVisitor<'a, T: 'a $(, $typaram: 'a)*>(&'a mut $ty); impl<'a, 'de, T $(, $typaram)*> Visitor<'de> for SeqInPlaceVisitor<'a, T $(, $typaram)*> where T: Deserialize<'de> $(+ $tbound1 $(+ $tbound2)*)*, $($typaram: $bound1 $(+ $bound2)*,)* { type Value = (); fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("a sequence") } #[inline] fn visit_seq(mut self, mut $access: A) -> Result where A: SeqAccess<'de>, { $clear(&mut self.0); $reserve(&mut self.0, size_hint::cautious::($access.size_hint())); // FIXME: try to overwrite old values here? (Vec, VecDeque, LinkedList) while let Some(value) = tri!($access.next_element()) { $insert(&mut self.0, value); } Ok(()) } } deserializer.deserialize_seq(SeqInPlaceVisitor(place)) } } } } // Dummy impl of reserve #[cfg(any(feature = "std", feature = "alloc"))] fn nop_reserve(_seq: T, _n: usize) {} seq_impl!( #[cfg(any(feature = "std", feature = "alloc"))] #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))] BinaryHeap, seq, BinaryHeap::clear, BinaryHeap::with_capacity(size_hint::cautious::(seq.size_hint())), BinaryHeap::reserve, BinaryHeap::push ); seq_impl!( #[cfg(any(feature = "std", feature = "alloc"))] #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))] BTreeSet, seq, BTreeSet::clear, BTreeSet::new(), nop_reserve, BTreeSet::insert ); seq_impl!( #[cfg(any(feature = "std", feature = "alloc"))] #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))] LinkedList, seq, LinkedList::clear, LinkedList::new(), nop_reserve, LinkedList::push_back ); seq_impl!( #[cfg(feature = "std")] #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))] HashSet, seq, HashSet::clear, HashSet::with_capacity_and_hasher(size_hint::cautious::(seq.size_hint()), S::default()), HashSet::reserve, HashSet::insert ); seq_impl!( #[cfg(any(feature = "std", feature = "alloc"))] #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))] VecDeque, seq, VecDeque::clear, VecDeque::with_capacity(size_hint::cautious::(seq.size_hint())), VecDeque::reserve, VecDeque::push_back ); //////////////////////////////////////////////////////////////////////////////// #[cfg(any(feature = "std", feature = "alloc"))] #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))] impl<'de, T> Deserialize<'de> for Vec where T: Deserialize<'de>, { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { struct VecVisitor { marker: PhantomData, } impl<'de, T> Visitor<'de> for VecVisitor where T: Deserialize<'de>, { type Value = Vec; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("a sequence") } fn visit_seq(self, mut seq: A) -> Result where A: SeqAccess<'de>, { let capacity = size_hint::cautious::(seq.size_hint()); let mut values = Vec::::with_capacity(capacity); while let Some(value) = tri!(seq.next_element()) { values.push(value); } Ok(values) } } let visitor = VecVisitor { marker: PhantomData, }; deserializer.deserialize_seq(visitor) } fn deserialize_in_place(deserializer: D, place: &mut Self) -> Result<(), D::Error> where D: Deserializer<'de>, { struct VecInPlaceVisitor<'a, T: 'a>(&'a mut Vec); impl<'a, 'de, T> Visitor<'de> for VecInPlaceVisitor<'a, T> where T: Deserialize<'de>, { type Value = (); fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("a sequence") } fn visit_seq(self, mut seq: A) -> Result where A: SeqAccess<'de>, { let hint = size_hint::cautious::(seq.size_hint()); if let Some(additional) = hint.checked_sub(self.0.len()) { self.0.reserve(additional); } for i in 0..self.0.len() { let next = { let next_place = InPlaceSeed(&mut self.0[i]); tri!(seq.next_element_seed(next_place)) }; if next.is_none() { self.0.truncate(i); return Ok(()); } } while let Some(value) = tri!(seq.next_element()) { self.0.push(value); } Ok(()) } } deserializer.deserialize_seq(VecInPlaceVisitor(place)) } } //////////////////////////////////////////////////////////////////////////////// struct ArrayVisitor { marker: PhantomData, } struct ArrayInPlaceVisitor<'a, A: 'a>(&'a mut A); impl ArrayVisitor { fn new() -> Self { ArrayVisitor { marker: PhantomData, } } } impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 0]> { type Value = [T; 0]; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("an empty array") } #[inline] fn visit_seq(self, _: A) -> Result where A: SeqAccess<'de>, { Ok([]) } } // Does not require T: Deserialize<'de>. impl<'de, T> Deserialize<'de> for [T; 0] { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { deserializer.deserialize_tuple(0, ArrayVisitor::<[T; 0]>::new()) } } macro_rules! array_impls { ($($len:expr => ($($n:tt)+))+) => { $( impl<'de, T> Visitor<'de> for ArrayVisitor<[T; $len]> where T: Deserialize<'de>, { type Value = [T; $len]; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str(concat!("an array of length ", $len)) } #[inline] fn visit_seq(self, mut seq: A) -> Result where A: SeqAccess<'de>, { Ok([$( match tri!(seq.next_element()) { Some(val) => val, None => return Err(Error::invalid_length($n, &self)), } ),+]) } } impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a, [T; $len]> where T: Deserialize<'de>, { type Value = (); fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str(concat!("an array of length ", $len)) } #[inline] fn visit_seq(self, mut seq: A) -> Result where A: SeqAccess<'de>, { let mut fail_idx = None; for (idx, dest) in self.0[..].iter_mut().enumerate() { if tri!(seq.next_element_seed(InPlaceSeed(dest))).is_none() { fail_idx = Some(idx); break; } } if let Some(idx) = fail_idx { return Err(Error::invalid_length(idx, &self)); } Ok(()) } } impl<'de, T> Deserialize<'de> for [T; $len] where T: Deserialize<'de>, { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { deserializer.deserialize_tuple($len, ArrayVisitor::<[T; $len]>::new()) } fn deserialize_in_place(deserializer: D, place: &mut Self) -> Result<(), D::Error> where D: Deserializer<'de>, { deserializer.deserialize_tuple($len, ArrayInPlaceVisitor(place)) } } )+ } } array_impls! { 1 => (0) 2 => (0 1) 3 => (0 1 2) 4 => (0 1 2 3) 5 => (0 1 2 3 4) 6 => (0 1 2 3 4 5) 7 => (0 1 2 3 4 5 6) 8 => (0 1 2 3 4 5 6 7) 9 => (0 1 2 3 4 5 6 7 8) 10 => (0 1 2 3 4 5 6 7 8 9) 11 => (0 1 2 3 4 5 6 7 8 9 10) 12 => (0 1 2 3 4 5 6 7 8 9 10 11) 13 => (0 1 2 3 4 5 6 7 8 9 10 11 12) 14 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13) 15 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14) 16 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) 17 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16) 18 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17) 19 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18) 20 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19) 21 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20) 22 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21) 23 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22) 24 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23) 25 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24) 26 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25) 27 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26) 28 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27) 29 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28) 30 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29) 31 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30) 32 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31) } //////////////////////////////////////////////////////////////////////////////// macro_rules! tuple_impls { ($($len:tt => ($($n:tt $name:ident)+))+) => { $( impl<'de, $($name: Deserialize<'de>),+> Deserialize<'de> for ($($name,)+) { #[inline] fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { struct TupleVisitor<$($name,)+> { marker: PhantomData<($($name,)+)>, } impl<'de, $($name: Deserialize<'de>),+> Visitor<'de> for TupleVisitor<$($name,)+> { type Value = ($($name,)+); fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str(concat!("a tuple of size ", $len)) } #[inline] #[allow(non_snake_case)] fn visit_seq(self, mut seq: A) -> Result where A: SeqAccess<'de>, { $( let $name = match tri!(seq.next_element()) { Some(value) => value, None => return Err(Error::invalid_length($n, &self)), }; )+ Ok(($($name,)+)) } } deserializer.deserialize_tuple($len, TupleVisitor { marker: PhantomData }) } #[inline] fn deserialize_in_place(deserializer: D, place: &mut Self) -> Result<(), D::Error> where D: Deserializer<'de>, { struct TupleInPlaceVisitor<'a, $($name: 'a,)+>(&'a mut ($($name,)+)); impl<'a, 'de, $($name: Deserialize<'de>),+> Visitor<'de> for TupleInPlaceVisitor<'a, $($name,)+> { type Value = (); fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str(concat!("a tuple of size ", $len)) } #[inline] #[allow(non_snake_case)] fn visit_seq(self, mut seq: A) -> Result where A: SeqAccess<'de>, { $( if tri!(seq.next_element_seed(InPlaceSeed(&mut (self.0).$n))).is_none() { return Err(Error::invalid_length($n, &self)); } )+ Ok(()) } } deserializer.deserialize_tuple($len, TupleInPlaceVisitor(place)) } } )+ } } tuple_impls! { 1 => (0 T0) 2 => (0 T0 1 T1) 3 => (0 T0 1 T1 2 T2) 4 => (0 T0 1 T1 2 T2 3 T3) 5 => (0 T0 1 T1 2 T2 3 T3 4 T4) 6 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5) 7 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6) 8 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7) 9 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8) 10 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9) 11 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10) 12 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11) 13 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12) 14 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13) 15 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13 14 T14) 16 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13 14 T14 15 T15) } //////////////////////////////////////////////////////////////////////////////// macro_rules! map_impl { ( $(#[$attr:meta])* $ty:ident , $access:ident, $with_capacity:expr, ) => { $(#[$attr])* impl<'de, K, V $(, $typaram)*> Deserialize<'de> for $ty where K: Deserialize<'de> $(+ $kbound1 $(+ $kbound2)*)*, V: Deserialize<'de>, $($typaram: $bound1 $(+ $bound2)*),* { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { struct MapVisitor { marker: PhantomData<$ty>, } impl<'de, K, V $(, $typaram)*> Visitor<'de> for MapVisitor where K: Deserialize<'de> $(+ $kbound1 $(+ $kbound2)*)*, V: Deserialize<'de>, $($typaram: $bound1 $(+ $bound2)*),* { type Value = $ty; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("a map") } #[inline] fn visit_map(self, mut $access: A) -> Result where A: MapAccess<'de>, { let mut values = $with_capacity; while let Some((key, value)) = tri!($access.next_entry()) { values.insert(key, value); } Ok(values) } } let visitor = MapVisitor { marker: PhantomData }; deserializer.deserialize_map(visitor) } } } } map_impl! { #[cfg(any(feature = "std", feature = "alloc"))] #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))] BTreeMap, map, BTreeMap::new(), } map_impl! { #[cfg(feature = "std")] #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))] HashMap, map, HashMap::with_capacity_and_hasher(size_hint::cautious::<(K, V)>(map.size_hint()), S::default()), } //////////////////////////////////////////////////////////////////////////////// macro_rules! parse_ip_impl { ( $(#[$attr:meta])* $ty:ty, $expecting:expr, $size:tt ) => { $(#[$attr])* impl<'de> Deserialize<'de> for $ty { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { if deserializer.is_human_readable() { deserializer.deserialize_str(FromStrVisitor::new($expecting)) } else { <[u8; $size]>::deserialize(deserializer).map(<$ty>::from) } } } }; } #[cfg(feature = "std")] macro_rules! variant_identifier { ( $name_kind:ident ($($variant:ident; $bytes:expr; $index:expr),*) $expecting_message:expr, $variants_name:ident ) => { enum $name_kind { $($variant),* } static $variants_name: &[&str] = &[$(stringify!($variant)),*]; impl<'de> Deserialize<'de> for $name_kind { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { struct KindVisitor; impl<'de> Visitor<'de> for KindVisitor { type Value = $name_kind; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str($expecting_message) } fn visit_u64(self, value: u64) -> Result where E: Error, { match value { $( $index => Ok($name_kind :: $variant), )* _ => Err(Error::invalid_value(Unexpected::Unsigned(value), &self),), } } fn visit_str(self, value: &str) -> Result where E: Error, { match value { $( stringify!($variant) => Ok($name_kind :: $variant), )* _ => Err(Error::unknown_variant(value, $variants_name)), } } fn visit_bytes(self, value: &[u8]) -> Result where E: Error, { match value { $( $bytes => Ok($name_kind :: $variant), )* _ => { match str::from_utf8(value) { Ok(value) => Err(Error::unknown_variant(value, $variants_name)), Err(_) => Err(Error::invalid_value(Unexpected::Bytes(value), &self)), } } } } } deserializer.deserialize_identifier(KindVisitor) } } } } #[cfg(feature = "std")] macro_rules! deserialize_enum { ( $name:ident $name_kind:ident ($($variant:ident; $bytes:expr; $index:expr),*) $expecting_message:expr, $deserializer:expr ) => { variant_identifier! { $name_kind ($($variant; $bytes; $index),*) $expecting_message, VARIANTS } struct EnumVisitor; impl<'de> Visitor<'de> for EnumVisitor { type Value = $name; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str(concat!("a ", stringify!($name))) } fn visit_enum(self, data: A) -> Result where A: EnumAccess<'de>, { match tri!(data.variant()) { $( ($name_kind :: $variant, v) => v.newtype_variant().map($name :: $variant), )* } } } $deserializer.deserialize_enum(stringify!($name), VARIANTS, EnumVisitor) } } #[cfg(feature = "std")] #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))] impl<'de> Deserialize<'de> for net::IpAddr { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { if deserializer.is_human_readable() { deserializer.deserialize_str(FromStrVisitor::new("IP address")) } else { use crate::lib::net::IpAddr; deserialize_enum! { IpAddr IpAddrKind (V4; b"V4"; 0, V6; b"V6"; 1) "`V4` or `V6`", deserializer } } } } parse_ip_impl! { #[cfg(feature = "std")] #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))] net::Ipv4Addr, "IPv4 address", 4 } parse_ip_impl! { #[cfg(feature = "std")] #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))] net::Ipv6Addr, "IPv6 address", 16 } macro_rules! parse_socket_impl { ( $(#[$attr:meta])* $ty:ty, $expecting:tt, $new:expr, ) => { $(#[$attr])* impl<'de> Deserialize<'de> for $ty { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { if deserializer.is_human_readable() { deserializer.deserialize_str(FromStrVisitor::new($expecting)) } else { <(_, u16)>::deserialize(deserializer).map($new) } } } }; } #[cfg(feature = "std")] #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))] impl<'de> Deserialize<'de> for net::SocketAddr { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { if deserializer.is_human_readable() { deserializer.deserialize_str(FromStrVisitor::new("socket address")) } else { use crate::lib::net::SocketAddr; deserialize_enum! { SocketAddr SocketAddrKind (V4; b"V4"; 0, V6; b"V6"; 1) "`V4` or `V6`", deserializer } } } } parse_socket_impl! { #[cfg(feature = "std")] #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))] net::SocketAddrV4, "IPv4 socket address", |(ip, port)| net::SocketAddrV4::new(ip, port), } parse_socket_impl! { #[cfg(feature = "std")] #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))] net::SocketAddrV6, "IPv6 socket address", |(ip, port)| net::SocketAddrV6::new(ip, port, 0, 0), } //////////////////////////////////////////////////////////////////////////////// #[cfg(feature = "std")] struct PathVisitor; #[cfg(feature = "std")] impl<'a> Visitor<'a> for PathVisitor { type Value = &'a Path; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("a borrowed path") } fn visit_borrowed_str(self, v: &'a str) -> Result where E: Error, { Ok(v.as_ref()) } fn visit_borrowed_bytes(self, v: &'a [u8]) -> Result where E: Error, { str::from_utf8(v) .map(AsRef::as_ref) .map_err(|_| Error::invalid_value(Unexpected::Bytes(v), &self)) } } #[cfg(feature = "std")] #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))] impl<'de: 'a, 'a> Deserialize<'de> for &'a Path { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { deserializer.deserialize_str(PathVisitor) } } #[cfg(feature = "std")] struct PathBufVisitor; #[cfg(feature = "std")] impl<'de> Visitor<'de> for PathBufVisitor { type Value = PathBuf; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("path string") } fn visit_str(self, v: &str) -> Result where E: Error, { Ok(From::from(v)) } fn visit_string(self, v: String) -> Result where E: Error, { Ok(From::from(v)) } fn visit_bytes(self, v: &[u8]) -> Result where E: Error, { str::from_utf8(v) .map(From::from) .map_err(|_| Error::invalid_value(Unexpected::Bytes(v), &self)) } fn visit_byte_buf(self, v: Vec) -> Result where E: Error, { String::from_utf8(v) .map(From::from) .map_err(|e| Error::invalid_value(Unexpected::Bytes(&e.into_bytes()), &self)) } } #[cfg(feature = "std")] #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))] impl<'de> Deserialize<'de> for PathBuf { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { deserializer.deserialize_string(PathBufVisitor) } } forwarded_impl! { #[cfg(feature = "std")] #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))] (), Box, PathBuf::into_boxed_path } //////////////////////////////////////////////////////////////////////////////// // If this were outside of the serde crate, it would just use: // // #[derive(Deserialize)] // #[serde(variant_identifier)] #[cfg(all(feature = "std", any(unix, windows)))] variant_identifier! { OsStringKind (Unix; b"Unix"; 0, Windows; b"Windows"; 1) "`Unix` or `Windows`", OSSTR_VARIANTS } #[cfg(all(feature = "std", any(unix, windows)))] struct OsStringVisitor; #[cfg(all(feature = "std", any(unix, windows)))] impl<'de> Visitor<'de> for OsStringVisitor { type Value = OsString; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("os string") } #[cfg(unix)] fn visit_enum(self, data: A) -> Result where A: EnumAccess<'de>, { use std::os::unix::ffi::OsStringExt; match tri!(data.variant()) { (OsStringKind::Unix, v) => v.newtype_variant().map(OsString::from_vec), (OsStringKind::Windows, _) => Err(Error::custom( "cannot deserialize Windows OS string on Unix", )), } } #[cfg(windows)] fn visit_enum(self, data: A) -> Result where A: EnumAccess<'de>, { use std::os::windows::ffi::OsStringExt; match tri!(data.variant()) { (OsStringKind::Windows, v) => v .newtype_variant::>() .map(|vec| OsString::from_wide(&vec)), (OsStringKind::Unix, _) => Err(Error::custom( "cannot deserialize Unix OS string on Windows", )), } } } #[cfg(all(feature = "std", any(unix, windows)))] #[cfg_attr(doc_cfg, doc(cfg(all(feature = "std", any(unix, windows)))))] impl<'de> Deserialize<'de> for OsString { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { deserializer.deserialize_enum("OsString", OSSTR_VARIANTS, OsStringVisitor) } } //////////////////////////////////////////////////////////////////////////////// forwarded_impl! { #[cfg(any(feature = "std", feature = "alloc"))] #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))] (T), Box, Box::new } forwarded_impl! { #[cfg(any(feature = "std", feature = "alloc"))] #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))] (T), Box<[T]>, Vec::into_boxed_slice } forwarded_impl! { #[cfg(any(feature = "std", feature = "alloc"))] #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))] (), Box, String::into_boxed_str } forwarded_impl! { #[cfg(all(feature = "std", any(unix, windows)))] #[cfg_attr(doc_cfg, doc(cfg(all(feature = "std", any(unix, windows)))))] (), Box, OsString::into_boxed_os_str } #[cfg(any(feature = "std", feature = "alloc"))] #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))] impl<'de, 'a, T: ?Sized> Deserialize<'de> for Cow<'a, T> where T: ToOwned, T::Owned: Deserialize<'de>, { #[inline] fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { T::Owned::deserialize(deserializer).map(Cow::Owned) } } //////////////////////////////////////////////////////////////////////////////// /// This impl requires the [`"rc"`] Cargo feature of Serde. The resulting /// `Weak` has a reference count of 0 and cannot be upgraded. /// /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))] #[cfg_attr( doc_cfg, doc(cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))) )] impl<'de, T: ?Sized> Deserialize<'de> for RcWeak where T: Deserialize<'de>, { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { tri!(Option::::deserialize(deserializer)); Ok(RcWeak::new()) } } /// This impl requires the [`"rc"`] Cargo feature of Serde. The resulting /// `Weak` has a reference count of 0 and cannot be upgraded. /// /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))] #[cfg_attr( doc_cfg, doc(cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))) )] impl<'de, T: ?Sized> Deserialize<'de> for ArcWeak where T: Deserialize<'de>, { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { tri!(Option::::deserialize(deserializer)); Ok(ArcWeak::new()) } } //////////////////////////////////////////////////////////////////////////////// macro_rules! box_forwarded_impl { ( $(#[$attr:meta])* $t:ident ) => { $(#[$attr])* impl<'de, T: ?Sized> Deserialize<'de> for $t where Box: Deserialize<'de>, { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { Box::deserialize(deserializer).map(Into::into) } } }; } box_forwarded_impl! { /// This impl requires the [`"rc"`] Cargo feature of Serde. /// /// Deserializing a data structure containing `Rc` will not attempt to /// deduplicate `Rc` references to the same data. Every deserialized `Rc` /// will end up with a strong count of 1. /// /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))] #[cfg_attr(doc_cfg, doc(cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))))] Rc } box_forwarded_impl! { /// This impl requires the [`"rc"`] Cargo feature of Serde. /// /// Deserializing a data structure containing `Arc` will not attempt to /// deduplicate `Arc` references to the same data. Every deserialized `Arc` /// will end up with a strong count of 1. /// /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))] #[cfg_attr(doc_cfg, doc(cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))))] Arc } //////////////////////////////////////////////////////////////////////////////// impl<'de, T> Deserialize<'de> for Cell where T: Deserialize<'de> + Copy, { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { T::deserialize(deserializer).map(Cell::new) } } forwarded_impl! { (T), RefCell, RefCell::new } forwarded_impl! { #[cfg(feature = "std")] #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))] (T), Mutex, Mutex::new } forwarded_impl! { #[cfg(feature = "std")] #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))] (T), RwLock, RwLock::new } //////////////////////////////////////////////////////////////////////////////// // This is a cleaned-up version of the impl generated by: // // #[derive(Deserialize)] // #[serde(deny_unknown_fields)] // struct Duration { // secs: u64, // nanos: u32, // } impl<'de> Deserialize<'de> for Duration { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { // If this were outside of the serde crate, it would just use: // // #[derive(Deserialize)] // #[serde(field_identifier, rename_all = "lowercase")] enum Field { Secs, Nanos, } impl<'de> Deserialize<'de> for Field { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { struct FieldVisitor; impl<'de> Visitor<'de> for FieldVisitor { type Value = Field; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("`secs` or `nanos`") } fn visit_str(self, value: &str) -> Result where E: Error, { match value { "secs" => Ok(Field::Secs), "nanos" => Ok(Field::Nanos), _ => Err(Error::unknown_field(value, FIELDS)), } } fn visit_bytes(self, value: &[u8]) -> Result where E: Error, { match value { b"secs" => Ok(Field::Secs), b"nanos" => Ok(Field::Nanos), _ => { let value = crate::__private::from_utf8_lossy(value); Err(Error::unknown_field(&*value, FIELDS)) } } } } deserializer.deserialize_identifier(FieldVisitor) } } fn check_overflow(secs: u64, nanos: u32) -> Result<(), E> where E: Error, { static NANOS_PER_SEC: u32 = 1_000_000_000; match secs.checked_add((nanos / NANOS_PER_SEC) as u64) { Some(_) => Ok(()), None => Err(E::custom("overflow deserializing Duration")), } } struct DurationVisitor; impl<'de> Visitor<'de> for DurationVisitor { type Value = Duration; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("struct Duration") } fn visit_seq(self, mut seq: A) -> Result where A: SeqAccess<'de>, { let secs: u64 = match tri!(seq.next_element()) { Some(value) => value, None => { return Err(Error::invalid_length(0, &self)); } }; let nanos: u32 = match tri!(seq.next_element()) { Some(value) => value, None => { return Err(Error::invalid_length(1, &self)); } }; tri!(check_overflow(secs, nanos)); Ok(Duration::new(secs, nanos)) } fn visit_map(self, mut map: A) -> Result where A: MapAccess<'de>, { let mut secs: Option = None; let mut nanos: Option = None; while let Some(key) = tri!(map.next_key()) { match key { Field::Secs => { if secs.is_some() { return Err(::duplicate_field("secs")); } secs = Some(tri!(map.next_value())); } Field::Nanos => { if nanos.is_some() { return Err(::duplicate_field("nanos")); } nanos = Some(tri!(map.next_value())); } } } let secs = match secs { Some(secs) => secs, None => return Err(::missing_field("secs")), }; let nanos = match nanos { Some(nanos) => nanos, None => return Err(::missing_field("nanos")), }; tri!(check_overflow(secs, nanos)); Ok(Duration::new(secs, nanos)) } } const FIELDS: &[&str] = &["secs", "nanos"]; deserializer.deserialize_struct("Duration", FIELDS, DurationVisitor) } } //////////////////////////////////////////////////////////////////////////////// #[cfg(feature = "std")] #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))] impl<'de> Deserialize<'de> for SystemTime { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { // Reuse duration enum Field { Secs, Nanos, } impl<'de> Deserialize<'de> for Field { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { struct FieldVisitor; impl<'de> Visitor<'de> for FieldVisitor { type Value = Field; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("`secs_since_epoch` or `nanos_since_epoch`") } fn visit_str(self, value: &str) -> Result where E: Error, { match value { "secs_since_epoch" => Ok(Field::Secs), "nanos_since_epoch" => Ok(Field::Nanos), _ => Err(Error::unknown_field(value, FIELDS)), } } fn visit_bytes(self, value: &[u8]) -> Result where E: Error, { match value { b"secs_since_epoch" => Ok(Field::Secs), b"nanos_since_epoch" => Ok(Field::Nanos), _ => { let value = String::from_utf8_lossy(value); Err(Error::unknown_field(&value, FIELDS)) } } } } deserializer.deserialize_identifier(FieldVisitor) } } fn check_overflow(secs: u64, nanos: u32) -> Result<(), E> where E: Error, { static NANOS_PER_SEC: u32 = 1_000_000_000; match secs.checked_add((nanos / NANOS_PER_SEC) as u64) { Some(_) => Ok(()), None => Err(E::custom("overflow deserializing SystemTime epoch offset")), } } struct DurationVisitor; impl<'de> Visitor<'de> for DurationVisitor { type Value = Duration; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("struct SystemTime") } fn visit_seq(self, mut seq: A) -> Result where A: SeqAccess<'de>, { let secs: u64 = match tri!(seq.next_element()) { Some(value) => value, None => { return Err(Error::invalid_length(0, &self)); } }; let nanos: u32 = match tri!(seq.next_element()) { Some(value) => value, None => { return Err(Error::invalid_length(1, &self)); } }; tri!(check_overflow(secs, nanos)); Ok(Duration::new(secs, nanos)) } fn visit_map(self, mut map: A) -> Result where A: MapAccess<'de>, { let mut secs: Option = None; let mut nanos: Option = None; while let Some(key) = tri!(map.next_key()) { match key { Field::Secs => { if secs.is_some() { return Err(::duplicate_field( "secs_since_epoch", )); } secs = Some(tri!(map.next_value())); } Field::Nanos => { if nanos.is_some() { return Err(::duplicate_field( "nanos_since_epoch", )); } nanos = Some(tri!(map.next_value())); } } } let secs = match secs { Some(secs) => secs, None => return Err(::missing_field("secs_since_epoch")), }; let nanos = match nanos { Some(nanos) => nanos, None => return Err(::missing_field("nanos_since_epoch")), }; tri!(check_overflow(secs, nanos)); Ok(Duration::new(secs, nanos)) } } const FIELDS: &[&str] = &["secs_since_epoch", "nanos_since_epoch"]; let duration = tri!(deserializer.deserialize_struct("SystemTime", FIELDS, DurationVisitor)); #[cfg(not(no_systemtime_checked_add))] let ret = UNIX_EPOCH .checked_add(duration) .ok_or_else(|| D::Error::custom("overflow deserializing SystemTime")); #[cfg(no_systemtime_checked_add)] let ret = Ok(UNIX_EPOCH + duration); ret } } //////////////////////////////////////////////////////////////////////////////// // Similar to: // // #[derive(Deserialize)] // #[serde(deny_unknown_fields)] // struct Range { // start: Idx, // end: Idx, // } impl<'de, Idx> Deserialize<'de> for Range where Idx: Deserialize<'de>, { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { let (start, end) = tri!(deserializer.deserialize_struct( "Range", range::FIELDS, range::RangeVisitor { expecting: "struct Range", phantom: PhantomData, }, )); Ok(start..end) } } impl<'de, Idx> Deserialize<'de> for RangeInclusive where Idx: Deserialize<'de>, { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { let (start, end) = tri!(deserializer.deserialize_struct( "RangeInclusive", range::FIELDS, range::RangeVisitor { expecting: "struct RangeInclusive", phantom: PhantomData, }, )); Ok(RangeInclusive::new(start, end)) } } mod range { use crate::lib::*; use crate::de::{Deserialize, Deserializer, Error, MapAccess, SeqAccess, Visitor}; pub const FIELDS: &[&str] = &["start", "end"]; // If this were outside of the serde crate, it would just use: // // #[derive(Deserialize)] // #[serde(field_identifier, rename_all = "lowercase")] enum Field { Start, End, } impl<'de> Deserialize<'de> for Field { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { struct FieldVisitor; impl<'de> Visitor<'de> for FieldVisitor { type Value = Field; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("`start` or `end`") } fn visit_str(self, value: &str) -> Result where E: Error, { match value { "start" => Ok(Field::Start), "end" => Ok(Field::End), _ => Err(Error::unknown_field(value, FIELDS)), } } fn visit_bytes(self, value: &[u8]) -> Result where E: Error, { match value { b"start" => Ok(Field::Start), b"end" => Ok(Field::End), _ => { let value = crate::__private::from_utf8_lossy(value); Err(Error::unknown_field(&*value, FIELDS)) } } } } deserializer.deserialize_identifier(FieldVisitor) } } pub struct RangeVisitor { pub expecting: &'static str, pub phantom: PhantomData, } impl<'de, Idx> Visitor<'de> for RangeVisitor where Idx: Deserialize<'de>, { type Value = (Idx, Idx); fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str(self.expecting) } fn visit_seq(self, mut seq: A) -> Result where A: SeqAccess<'de>, { let start: Idx = match tri!(seq.next_element()) { Some(value) => value, None => { return Err(Error::invalid_length(0, &self)); } }; let end: Idx = match tri!(seq.next_element()) { Some(value) => value, None => { return Err(Error::invalid_length(1, &self)); } }; Ok((start, end)) } fn visit_map(self, mut map: A) -> Result where A: MapAccess<'de>, { let mut start: Option = None; let mut end: Option = None; while let Some(key) = tri!(map.next_key()) { match key { Field::Start => { if start.is_some() { return Err(::duplicate_field("start")); } start = Some(tri!(map.next_value())); } Field::End => { if end.is_some() { return Err(::duplicate_field("end")); } end = Some(tri!(map.next_value())); } } } let start = match start { Some(start) => start, None => return Err(::missing_field("start")), }; let end = match end { Some(end) => end, None => return Err(::missing_field("end")), }; Ok((start, end)) } } } //////////////////////////////////////////////////////////////////////////////// // Similar to: // // #[derive(Deserialize)] // #[serde(deny_unknown_fields)] // struct RangeFrom { // start: Idx, // } impl<'de, Idx> Deserialize<'de> for RangeFrom where Idx: Deserialize<'de>, { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { let start = tri!(deserializer.deserialize_struct( "RangeFrom", range_from::FIELDS, range_from::RangeFromVisitor { expecting: "struct RangeFrom", phantom: PhantomData, }, )); Ok(start..) } } mod range_from { use crate::lib::*; use crate::de::{Deserialize, Deserializer, Error, MapAccess, SeqAccess, Visitor}; pub const FIELDS: &[&str] = &["start"]; // If this were outside of the serde crate, it would just use: // // #[derive(Deserialize)] // #[serde(field_identifier, rename_all = "lowercase")] enum Field { Start, } impl<'de> Deserialize<'de> for Field { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { struct FieldVisitor; impl<'de> Visitor<'de> for FieldVisitor { type Value = Field; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("`start`") } fn visit_str(self, value: &str) -> Result where E: Error, { match value { "start" => Ok(Field::Start), _ => Err(Error::unknown_field(value, FIELDS)), } } fn visit_bytes(self, value: &[u8]) -> Result where E: Error, { match value { b"start" => Ok(Field::Start), _ => { let value = crate::__private::from_utf8_lossy(value); Err(Error::unknown_field(&*value, FIELDS)) } } } } deserializer.deserialize_identifier(FieldVisitor) } } pub struct RangeFromVisitor { pub expecting: &'static str, pub phantom: PhantomData, } impl<'de, Idx> Visitor<'de> for RangeFromVisitor where Idx: Deserialize<'de>, { type Value = Idx; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str(self.expecting) } fn visit_seq(self, mut seq: A) -> Result where A: SeqAccess<'de>, { let start: Idx = match tri!(seq.next_element()) { Some(value) => value, None => { return Err(Error::invalid_length(0, &self)); } }; Ok(start) } fn visit_map(self, mut map: A) -> Result where A: MapAccess<'de>, { let mut start: Option = None; while let Some(key) = tri!(map.next_key()) { match key { Field::Start => { if start.is_some() { return Err(::duplicate_field("start")); } start = Some(tri!(map.next_value())); } } } let start = match start { Some(start) => start, None => return Err(::missing_field("start")), }; Ok(start) } } } //////////////////////////////////////////////////////////////////////////////// // Similar to: // // #[derive(Deserialize)] // #[serde(deny_unknown_fields)] // struct RangeTo { // end: Idx, // } impl<'de, Idx> Deserialize<'de> for RangeTo where Idx: Deserialize<'de>, { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { let end = tri!(deserializer.deserialize_struct( "RangeTo", range_to::FIELDS, range_to::RangeToVisitor { expecting: "struct RangeTo", phantom: PhantomData, }, )); Ok(..end) } } mod range_to { use crate::lib::*; use crate::de::{Deserialize, Deserializer, Error, MapAccess, SeqAccess, Visitor}; pub const FIELDS: &[&str] = &["end"]; // If this were outside of the serde crate, it would just use: // // #[derive(Deserialize)] // #[serde(field_identifier, rename_all = "lowercase")] enum Field { End, } impl<'de> Deserialize<'de> for Field { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { struct FieldVisitor; impl<'de> Visitor<'de> for FieldVisitor { type Value = Field; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("`end`") } fn visit_str(self, value: &str) -> Result where E: Error, { match value { "end" => Ok(Field::End), _ => Err(Error::unknown_field(value, FIELDS)), } } fn visit_bytes(self, value: &[u8]) -> Result where E: Error, { match value { b"end" => Ok(Field::End), _ => { let value = crate::__private::from_utf8_lossy(value); Err(Error::unknown_field(&*value, FIELDS)) } } } } deserializer.deserialize_identifier(FieldVisitor) } } pub struct RangeToVisitor { pub expecting: &'static str, pub phantom: PhantomData, } impl<'de, Idx> Visitor<'de> for RangeToVisitor where Idx: Deserialize<'de>, { type Value = Idx; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str(self.expecting) } fn visit_seq(self, mut seq: A) -> Result where A: SeqAccess<'de>, { let end: Idx = match tri!(seq.next_element()) { Some(value) => value, None => { return Err(Error::invalid_length(0, &self)); } }; Ok(end) } fn visit_map(self, mut map: A) -> Result where A: MapAccess<'de>, { let mut end: Option = None; while let Some(key) = tri!(map.next_key()) { match key { Field::End => { if end.is_some() { return Err(::duplicate_field("end")); } end = Some(tri!(map.next_value())); } } } let end = match end { Some(end) => end, None => return Err(::missing_field("end")), }; Ok(end) } } } //////////////////////////////////////////////////////////////////////////////// impl<'de, T> Deserialize<'de> for Bound where T: Deserialize<'de>, { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { enum Field { Unbounded, Included, Excluded, } impl<'de> Deserialize<'de> for Field { #[inline] fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { struct FieldVisitor; impl<'de> Visitor<'de> for FieldVisitor { type Value = Field; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("`Unbounded`, `Included` or `Excluded`") } fn visit_u64(self, value: u64) -> Result where E: Error, { match value { 0 => Ok(Field::Unbounded), 1 => Ok(Field::Included), 2 => Ok(Field::Excluded), _ => Err(Error::invalid_value(Unexpected::Unsigned(value), &self)), } } fn visit_str(self, value: &str) -> Result where E: Error, { match value { "Unbounded" => Ok(Field::Unbounded), "Included" => Ok(Field::Included), "Excluded" => Ok(Field::Excluded), _ => Err(Error::unknown_variant(value, VARIANTS)), } } fn visit_bytes(self, value: &[u8]) -> Result where E: Error, { match value { b"Unbounded" => Ok(Field::Unbounded), b"Included" => Ok(Field::Included), b"Excluded" => Ok(Field::Excluded), _ => match str::from_utf8(value) { Ok(value) => Err(Error::unknown_variant(value, VARIANTS)), Err(_) => { Err(Error::invalid_value(Unexpected::Bytes(value), &self)) } }, } } } deserializer.deserialize_identifier(FieldVisitor) } } struct BoundVisitor(PhantomData>); impl<'de, T> Visitor<'de> for BoundVisitor where T: Deserialize<'de>, { type Value = Bound; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("enum Bound") } fn visit_enum(self, data: A) -> Result where A: EnumAccess<'de>, { match tri!(data.variant()) { (Field::Unbounded, v) => v.unit_variant().map(|()| Bound::Unbounded), (Field::Included, v) => v.newtype_variant().map(Bound::Included), (Field::Excluded, v) => v.newtype_variant().map(Bound::Excluded), } } } const VARIANTS: &[&str] = &["Unbounded", "Included", "Excluded"]; deserializer.deserialize_enum("Bound", VARIANTS, BoundVisitor(PhantomData)) } } //////////////////////////////////////////////////////////////////////////////// impl<'de, T, E> Deserialize<'de> for Result where T: Deserialize<'de>, E: Deserialize<'de>, { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { // If this were outside of the serde crate, it would just use: // // #[derive(Deserialize)] // #[serde(variant_identifier)] enum Field { Ok, Err, } impl<'de> Deserialize<'de> for Field { #[inline] fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { struct FieldVisitor; impl<'de> Visitor<'de> for FieldVisitor { type Value = Field; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("`Ok` or `Err`") } fn visit_u64(self, value: u64) -> Result where E: Error, { match value { 0 => Ok(Field::Ok), 1 => Ok(Field::Err), _ => Err(Error::invalid_value(Unexpected::Unsigned(value), &self)), } } fn visit_str(self, value: &str) -> Result where E: Error, { match value { "Ok" => Ok(Field::Ok), "Err" => Ok(Field::Err), _ => Err(Error::unknown_variant(value, VARIANTS)), } } fn visit_bytes(self, value: &[u8]) -> Result where E: Error, { match value { b"Ok" => Ok(Field::Ok), b"Err" => Ok(Field::Err), _ => match str::from_utf8(value) { Ok(value) => Err(Error::unknown_variant(value, VARIANTS)), Err(_) => { Err(Error::invalid_value(Unexpected::Bytes(value), &self)) } }, } } } deserializer.deserialize_identifier(FieldVisitor) } } struct ResultVisitor(PhantomData>); impl<'de, T, E> Visitor<'de> for ResultVisitor where T: Deserialize<'de>, E: Deserialize<'de>, { type Value = Result; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("enum Result") } fn visit_enum(self, data: A) -> Result where A: EnumAccess<'de>, { match tri!(data.variant()) { (Field::Ok, v) => v.newtype_variant().map(Ok), (Field::Err, v) => v.newtype_variant().map(Err), } } } const VARIANTS: &[&str] = &["Ok", "Err"]; deserializer.deserialize_enum("Result", VARIANTS, ResultVisitor(PhantomData)) } } //////////////////////////////////////////////////////////////////////////////// impl<'de, T> Deserialize<'de> for Wrapping where T: Deserialize<'de>, { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { Deserialize::deserialize(deserializer).map(Wrapping) } } #[cfg(all(feature = "std", not(no_std_atomic)))] macro_rules! atomic_impl { ($($ty:ident $size:expr)*) => { $( #[cfg(any(no_target_has_atomic, target_has_atomic = $size))] #[cfg_attr(doc_cfg, doc(cfg(all(feature = "std", target_has_atomic = $size))))] impl<'de> Deserialize<'de> for $ty { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { Deserialize::deserialize(deserializer).map(Self::new) } } )* }; } #[cfg(all(feature = "std", not(no_std_atomic)))] atomic_impl! { AtomicBool "8" AtomicI8 "8" AtomicI16 "16" AtomicI32 "32" AtomicIsize "ptr" AtomicU8 "8" AtomicU16 "16" AtomicU32 "32" AtomicUsize "ptr" } #[cfg(all(feature = "std", not(no_std_atomic64)))] atomic_impl! { AtomicI64 "64" AtomicU64 "64" } #[cfg(feature = "std")] struct FromStrVisitor { expecting: &'static str, ty: PhantomData, } #[cfg(feature = "std")] impl FromStrVisitor { fn new(expecting: &'static str) -> Self { FromStrVisitor { expecting, ty: PhantomData, } } } #[cfg(feature = "std")] impl<'de, T> Visitor<'de> for FromStrVisitor where T: str::FromStr, T::Err: fmt::Display, { type Value = T; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str(self.expecting) } fn visit_str(self, s: &str) -> Result where E: Error, { s.parse().map_err(Error::custom) } }