pezkuwichain/serde
1
0
Fork 0
mirror of https://github.com/pezkuwichain/serde.git synced 2026-06-13 07:51:03 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #2600 from dtolnay/oldemscripten

Browse Source 
Remove support for emscripten targets on rustc older than 1.40
This commit is contained in:
David Tolnay
2023-08-23 22:18:20 -07:00
committed by GitHub
parent 5d036515ed dc24d12ce0
commit dbbfe7abe2
10 changed files with 156 additions and 281 deletions
Download Patch File Download Diff File Expand all files Collapse all files
serde/build.rs
-7
View File
@@ -27,13 +27,6 @@ fn main() {
println!("cargo:rustc-cfg=no_relaxed_trait_bounds"); println!("cargo:rustc-cfg=no_relaxed_trait_bounds");
} }
// Disabled on Emscripten targets before Rust 1.40 since
// Emscripten did not support 128-bit integers until Rust 1.40
// (https://github.com/rust-lang/rust/pull/65251)
if emscripten && minor < 40 {
println!("cargo:rustc-cfg=no_integer128");
}
// Current minimum supported version of serde_derive crate is Rust 1.56. // Current minimum supported version of serde_derive crate is Rust 1.56.
if minor < 56 { if minor < 56 {
println!("cargo:rustc-cfg=no_serde_derive"); println!("cargo:rustc-cfg=no_serde_derive");
serde/src/de/ignored_any.rs
+8 -12
View File
@@ -129,12 +129,10 @@ impl<'de> Visitor<'de> for IgnoredAny {
Ok(IgnoredAny) Ok(IgnoredAny)
} }
serde_if_integer128! { #[inline]
#[inline] fn visit_i128<E>(self, x: i128) -> Result<Self::Value, E> {
fn visit_i128<E>(self, x: i128) -> Result<Self::Value, E> { let _ = x;
let _ = x; Ok(IgnoredAny)
Ok(IgnoredAny)
}
} }
#[inline] #[inline]
@@ -143,12 +141,10 @@ impl<'de> Visitor<'de> for IgnoredAny {
Ok(IgnoredAny) Ok(IgnoredAny)
} }
serde_if_integer128! { #[inline]
#[inline] fn visit_u128<E>(self, x: u128) -> Result<Self::Value, E> {
fn visit_u128<E>(self, x: u128) -> Result<Self::Value, E> { let _ = x;
let _ = x; Ok(IgnoredAny)
Ok(IgnoredAny)
}
} }
#[inline] #[inline]
serde/src/de/impls.rs
+47 -49
View File
@@ -364,64 +364,62 @@ impl_deserialize_num! {
num_as_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64); num_as_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
} }
serde_if_integer128! { macro_rules! num_128 {
macro_rules! num_128 { ($ty:ident : $visit:ident) => {
($ty:ident : $visit:ident) => { fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
fn $visit<E>(self, v: $ty) -> Result<Self::Value, E> where
where E: Error,
E: Error, {
if v as i128 >= Self::Value::min_value() as i128
&& v as u128 <= Self::Value::max_value() as u128
{ {
if v as i128 >= Self::Value::min_value() as i128 Ok(v as Self::Value)
&& v as u128 <= Self::Value::max_value() as u128 } else {
{ Err(Error::invalid_value(
Ok(v as Self::Value) Unexpected::Other(stringify!($ty)),
} else { &self,
Err(Error::invalid_value( ))
Unexpected::Other(stringify!($ty)),
&self,
))
}
} }
}; }
};
(nonzero $primitive:ident $ty:ident : $visit:ident) => { (nonzero $primitive:ident $ty:ident : $visit:ident) => {
fn $visit<E>(self, v: $ty) -> Result<Self::Value, E> fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
where where
E: Error, E: Error,
{
if v as i128 >= $primitive::min_value() as i128
&& v as u128 <= $primitive::max_value() as u128
{ {
if v as i128 >= $primitive::min_value() as i128 if let Some(nonzero) = Self::Value::new(v as $primitive) {
&& v as u128 <= $primitive::max_value() as u128 Ok(nonzero)
{
if let Some(nonzero) = Self::Value::new(v as $primitive) {
Ok(nonzero)
} else {
Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
}
} else { } else {
Err(Error::invalid_value( Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
Unexpected::Other(stringify!($ty)),
&self,
))
} }
} else {
Err(Error::invalid_value(
Unexpected::Other(stringify!($ty)),
&self,
))
} }
}; }
} };
}
impl_deserialize_num! { impl_deserialize_num! {
i128, NonZeroI128 cfg(not(no_num_nonzero_signed)), deserialize_i128 i128, NonZeroI128 cfg(not(no_num_nonzero_signed)), deserialize_i128
num_self!(i128:visit_i128); num_self!(i128:visit_i128);
num_as_self!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64); 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_as_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
num_128!(u128:visit_u128); num_128!(u128:visit_u128);
} }
impl_deserialize_num! { impl_deserialize_num! {
u128, NonZeroU128, deserialize_u128 u128, NonZeroU128, deserialize_u128
num_self!(u128:visit_u128); num_self!(u128:visit_u128);
num_as_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64); 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); int_to_uint!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
num_128!(i128:visit_i128); num_128!(i128:visit_i128);
}
} }
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
serde/src/de/mod.rs
+46 -53
View File
@@ -118,7 +118,6 @@ use crate::lib::*;
pub mod value; pub mod value;
#[cfg(not(no_integer128))]
mod format; mod format;
mod ignored_any; mod ignored_any;
mod impls; mod impls;
@@ -949,18 +948,15 @@ pub trait Deserializer<'de>: Sized {
where where
V: Visitor<'de>; V: Visitor<'de>;
serde_if_integer128! { /// Hint that the `Deserialize` type is expecting an `i128` value.
/// Hint that the `Deserialize` type is expecting an `i128` value. ///
/// /// The default behavior unconditionally returns an error.
/// This method is available only on Rust compiler versions >=1.26. The fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
/// default behavior unconditionally returns an error. where
fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Self::Error> V: Visitor<'de>,
where {
V: Visitor<'de> let _ = visitor;
{ Err(Error::custom("i128 is not supported"))
let _ = visitor;
Err(Error::custom("i128 is not supported"))
}
} }
/// Hint that the `Deserialize` type is expecting a `u8` value. /// Hint that the `Deserialize` type is expecting a `u8` value.
@@ -983,18 +979,15 @@ pub trait Deserializer<'de>: Sized {
where where
V: Visitor<'de>; V: Visitor<'de>;
serde_if_integer128! { /// Hint that the `Deserialize` type is expecting an `u128` value.
/// Hint that the `Deserialize` type is expecting an `u128` value. ///
/// /// The default behavior unconditionally returns an error.
/// This method is available only on Rust compiler versions >=1.26. The fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
/// default behavior unconditionally returns an error. where
fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Self::Error> V: Visitor<'de>,
where {
V: Visitor<'de> let _ = visitor;
{ Err(Error::custom("u128 is not supported"))
let _ = visitor;
Err(Error::custom("u128 is not supported"))
}
} }
/// Hint that the `Deserialize` type is expecting a `f32` value. /// Hint that the `Deserialize` type is expecting a `f32` value.
@@ -1366,20 +1359,20 @@ pub trait Visitor<'de>: Sized {
Err(Error::invalid_type(Unexpected::Signed(v), &self)) Err(Error::invalid_type(Unexpected::Signed(v), &self))
} }
serde_if_integer128! { /// The input contains a `i128`.
/// The input contains a `i128`. ///
/// /// The default implementation fails with a type error.
/// This method is available only on Rust compiler versions >=1.26. The fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
/// default implementation fails with a type error. where
fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E> E: Error,
where {
E: Error, let mut buf = [0u8; 58];
{ let mut writer = format::Buf::new(&mut buf);
let mut buf = [0u8; 58]; fmt::Write::write_fmt(&mut writer, format_args!("integer `{}` as i128", v)).unwrap();
let mut writer = format::Buf::new(&mut buf); Err(Error::invalid_type(
fmt::Write::write_fmt(&mut writer, format_args!("integer `{}` as i128", v)).unwrap(); Unexpected::Other(writer.as_str()),
Err(Error::invalid_type(Unexpected::Other(writer.as_str()), &self)) &self,
} ))
} }
/// The input contains a `u8`. /// The input contains a `u8`.
@@ -1428,20 +1421,20 @@ pub trait Visitor<'de>: Sized {
Err(Error::invalid_type(Unexpected::Unsigned(v), &self)) Err(Error::invalid_type(Unexpected::Unsigned(v), &self))
} }
serde_if_integer128! { /// The input contains a `u128`.
/// The input contains a `u128`. ///
/// /// The default implementation fails with a type error.
/// This method is available only on Rust compiler versions >=1.26. The fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
/// default implementation fails with a type error. where
fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E> E: Error,
where {
E: Error, let mut buf = [0u8; 57];
{ let mut writer = format::Buf::new(&mut buf);
let mut buf = [0u8; 57]; fmt::Write::write_fmt(&mut writer, format_args!("integer `{}` as u128", v)).unwrap();
let mut writer = format::Buf::new(&mut buf); Err(Error::invalid_type(
fmt::Write::write_fmt(&mut writer, format_args!("integer `{}` as u128", v)).unwrap(); Unexpected::Other(writer.as_str()),
Err(Error::invalid_type(Unexpected::Other(writer.as_str()), &self)) &self,
} ))
} }
/// The input contains an `f32`. /// The input contains an `f32`.
serde/src/de/value.rs
+2 -5
View File
@@ -292,20 +292,17 @@ primitive_deserializer!(i8, "an `i8`.", I8Deserializer, visit_i8);
primitive_deserializer!(i16, "an `i16`.", I16Deserializer, visit_i16); primitive_deserializer!(i16, "an `i16`.", I16Deserializer, visit_i16);
primitive_deserializer!(i32, "an `i32`.", I32Deserializer, visit_i32); primitive_deserializer!(i32, "an `i32`.", I32Deserializer, visit_i32);
primitive_deserializer!(i64, "an `i64`.", I64Deserializer, visit_i64); primitive_deserializer!(i64, "an `i64`.", I64Deserializer, visit_i64);
primitive_deserializer!(i128, "an `i128`.", I128Deserializer, visit_i128);
primitive_deserializer!(isize, "an `isize`.", IsizeDeserializer, visit_i64 as i64); primitive_deserializer!(isize, "an `isize`.", IsizeDeserializer, visit_i64 as i64);
primitive_deserializer!(u8, "a `u8`.", U8Deserializer, visit_u8); primitive_deserializer!(u8, "a `u8`.", U8Deserializer, visit_u8);
primitive_deserializer!(u16, "a `u16`.", U16Deserializer, visit_u16); primitive_deserializer!(u16, "a `u16`.", U16Deserializer, visit_u16);
primitive_deserializer!(u64, "a `u64`.", U64Deserializer, visit_u64); primitive_deserializer!(u64, "a `u64`.", U64Deserializer, visit_u64);
primitive_deserializer!(u128, "a `u128`.", U128Deserializer, visit_u128);
primitive_deserializer!(usize, "a `usize`.", UsizeDeserializer, visit_u64 as u64); primitive_deserializer!(usize, "a `usize`.", UsizeDeserializer, visit_u64 as u64);
primitive_deserializer!(f32, "an `f32`.", F32Deserializer, visit_f32); primitive_deserializer!(f32, "an `f32`.", F32Deserializer, visit_f32);
primitive_deserializer!(f64, "an `f64`.", F64Deserializer, visit_f64); primitive_deserializer!(f64, "an `f64`.", F64Deserializer, visit_f64);
primitive_deserializer!(char, "a `char`.", CharDeserializer, visit_char); primitive_deserializer!(char, "a `char`.", CharDeserializer, visit_char);
serde_if_integer128! {
primitive_deserializer!(i128, "an `i128`.", I128Deserializer, visit_i128);
primitive_deserializer!(u128, "a `u128`.", U128Deserializer, visit_u128);
}
/// A deserializer holding a `u32`. /// A deserializer holding a `u32`.
pub struct U32Deserializer<E> { pub struct U32Deserializer<E> {
value: u32, value: u32,
serde/src/integer128.rs
+3 -76
View File
@@ -1,82 +1,9 @@
/// Conditional compilation depending on whether Serde is built with support for // No longer used. Old versions of serde used this macro for supporting targets
/// 128-bit integers. // that did not yet have 128-bit integer support.
///
/// Data formats that wish to support Rust compiler versions older than 1.26
/// (or targets that lack 128-bit integers) may place the i128 / u128 methods
/// of their Serializer and Deserializer behind this macro.
///
/// Data formats that require a minimum Rust compiler version of at least 1.26,
/// or do not target platforms that lack 128-bit integers, do not need to
/// bother with this macro and may assume support for 128-bit integers.
///
/// ```edition2021
/// # use serde::__private::doc::Error;
/// #
/// # struct MySerializer;
/// #
/// use serde::{serde_if_integer128, Serializer};
///
/// impl Serializer for MySerializer {
/// type Ok = ();
/// type Error = Error;
///
/// fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
/// /* ... */
/// # unimplemented!()
/// }
///
/// /* ... */
///
/// serde_if_integer128! {
/// fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
/// /* ... */
/// # unimplemented!()
/// }
///
/// fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
/// /* ... */
/// # unimplemented!()
/// }
/// }
/// #
/// # serde::__serialize_unimplemented! {
/// # bool i8 i16 i32 u8 u16 u32 u64 f32 f64 char str bytes none some
/// # unit unit_struct unit_variant newtype_struct newtype_variant seq
/// # tuple tuple_struct tuple_variant map struct struct_variant
/// # }
/// }
/// ```
///
/// When Serde is built with support for 128-bit integers, this macro expands
/// transparently into just the input tokens.
///
/// ```edition2021
/// macro_rules! serde_if_integer128 {
/// ($($tt:tt)*) => {
/// $($tt)*
/// };
/// }
/// ```
///
/// When built without support for 128-bit integers, this macro expands to
/// nothing.
///
/// ```edition2021
/// macro_rules! serde_if_integer128 {
/// ($($tt:tt)*) => {};
/// }
/// ```
#[cfg(not(no_integer128))]
#[macro_export] #[macro_export]
#[doc(hidden)]
macro_rules! serde_if_integer128 { macro_rules! serde_if_integer128 {
($($tt:tt)*) => { ($($tt:tt)*) => {
$($tt)* $($tt)*
}; };
} }
#[cfg(no_integer128)]
#[macro_export]
#[doc(hidden)]
macro_rules! serde_if_integer128 {
($($tt:tt)*) => {};
}
serde/src/macros.rs
+2 -6
View File
@@ -154,9 +154,7 @@ macro_rules! forward_to_deserialize_any_helper {
forward_to_deserialize_any_method!{deserialize_i64<$l, $v>()} forward_to_deserialize_any_method!{deserialize_i64<$l, $v>()}
}; };
(i128<$l:tt, $v:ident>) => { (i128<$l:tt, $v:ident>) => {
serde_if_integer128! { forward_to_deserialize_any_method!{deserialize_i128<$l, $v>()}
forward_to_deserialize_any_method!{deserialize_i128<$l, $v>()}
}
}; };
(u8<$l:tt, $v:ident>) => { (u8<$l:tt, $v:ident>) => {
forward_to_deserialize_any_method!{deserialize_u8<$l, $v>()} forward_to_deserialize_any_method!{deserialize_u8<$l, $v>()}
@@ -171,9 +169,7 @@ macro_rules! forward_to_deserialize_any_helper {
forward_to_deserialize_any_method!{deserialize_u64<$l, $v>()} forward_to_deserialize_any_method!{deserialize_u64<$l, $v>()}
}; };
(u128<$l:tt, $v:ident>) => { (u128<$l:tt, $v:ident>) => {
serde_if_integer128! { forward_to_deserialize_any_method!{deserialize_u128<$l, $v>()}
forward_to_deserialize_any_method!{deserialize_u128<$l, $v>()}
}
}; };
(f32<$l:tt, $v:ident>) => { (f32<$l:tt, $v:ident>) => {
forward_to_deserialize_any_method!{deserialize_f32<$l, $v>()} forward_to_deserialize_any_method!{deserialize_f32<$l, $v>()}
serde/src/ser/fmt.rs
+2 -7
View File
@@ -52,10 +52,12 @@ impl<'a, 'b> Serializer for &'a mut fmt::Formatter<'b> {
serialize_i16: i16, serialize_i16: i16,
serialize_i32: i32, serialize_i32: i32,
serialize_i64: i64, serialize_i64: i64,
serialize_i128: i128,
serialize_u8: u8, serialize_u8: u8,
serialize_u16: u16, serialize_u16: u16,
serialize_u32: u32, serialize_u32: u32,
serialize_u64: u64, serialize_u64: u64,
serialize_u128: u128,
serialize_f32: f32, serialize_f32: f32,
serialize_f64: f64, serialize_f64: f64,
serialize_char: char, serialize_char: char,
@@ -63,13 +65,6 @@ impl<'a, 'b> Serializer for &'a mut fmt::Formatter<'b> {
serialize_unit_struct: &'static str, serialize_unit_struct: &'static str,
} }
serde_if_integer128! {
fmt_primitives! {
serialize_i128: i128,
serialize_u128: u128,
}
}
fn serialize_unit_variant( fn serialize_unit_variant(
self, self,
_name: &'static str, _name: &'static str,
serde/src/ser/impls.rs
+4 -18
View File
@@ -24,20 +24,17 @@ primitive_impl!(i8, serialize_i8);
primitive_impl!(i16, serialize_i16); primitive_impl!(i16, serialize_i16);
primitive_impl!(i32, serialize_i32); primitive_impl!(i32, serialize_i32);
primitive_impl!(i64, serialize_i64); primitive_impl!(i64, serialize_i64);
primitive_impl!(i128, serialize_i128);
primitive_impl!(usize, serialize_u64 as u64); primitive_impl!(usize, serialize_u64 as u64);
primitive_impl!(u8, serialize_u8); primitive_impl!(u8, serialize_u8);
primitive_impl!(u16, serialize_u16); primitive_impl!(u16, serialize_u16);
primitive_impl!(u32, serialize_u32); primitive_impl!(u32, serialize_u32);
primitive_impl!(u64, serialize_u64); primitive_impl!(u64, serialize_u64);
primitive_impl!(u128, serialize_u128);
primitive_impl!(f32, serialize_f32); primitive_impl!(f32, serialize_f32);
primitive_impl!(f64, serialize_f64); primitive_impl!(f64, serialize_f64);
primitive_impl!(char, serialize_char); primitive_impl!(char, serialize_char);
serde_if_integer128! {
primitive_impl!(i128, serialize_i128);
primitive_impl!(u128, serialize_u128);
}
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
impl Serialize for str { impl Serialize for str {
@@ -553,6 +550,7 @@ nonzero_integers! {
NonZeroU16, NonZeroU16,
NonZeroU32, NonZeroU32,
NonZeroU64, NonZeroU64,
NonZeroU128,
NonZeroUsize, NonZeroUsize,
} }
@@ -562,22 +560,10 @@ nonzero_integers! {
NonZeroI16, NonZeroI16,
NonZeroI32, NonZeroI32,
NonZeroI64, NonZeroI64,
NonZeroI128,
NonZeroIsize, NonZeroIsize,
} }
// Currently 128-bit integers do not work on Emscripten targets so we need an
// additional `#[cfg]`
serde_if_integer128! {
nonzero_integers! {
NonZeroU128,
}
#[cfg(not(no_num_nonzero_signed))]
nonzero_integers! {
NonZeroI128,
}
}
impl<T> Serialize for Cell<T> impl<T> Serialize for Cell<T>
where where
T: Serialize + Copy, T: Serialize + Copy,
serde/src/ser/mod.rs
+42 -48
View File
@@ -488,30 +488,27 @@ pub trait Serializer: Sized {
/// ``` /// ```
fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error>; fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error>;
serde_if_integer128! { /// Serialize an `i128` value.
/// Serialize an `i128` value. ///
/// /// ```edition2021
/// ```edition2021 /// # use serde::Serializer;
/// # use serde::Serializer; /// #
/// # /// # serde::__private_serialize!();
/// # serde::__private_serialize!(); /// #
/// # /// impl Serialize for i128 {
/// impl Serialize for i128 { /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
/// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> /// where
/// where /// S: Serializer,
/// S: Serializer, /// {
/// { /// serializer.serialize_i128(*self)
/// serializer.serialize_i128(*self) /// }
/// } /// }
/// } /// ```
/// ``` ///
/// /// The default behavior unconditionally returns an error.
/// This method is available only on Rust compiler versions >=1.26. The fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
/// default behavior unconditionally returns an error. let _ = v;
fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> { Err(Error::custom("i128 is not supported"))
let _ = v;
Err(Error::custom("i128 is not supported"))
}
} }
/// Serialize a `u8` value. /// Serialize a `u8` value.
@@ -598,30 +595,27 @@ pub trait Serializer: Sized {
/// ``` /// ```
fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error>; fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error>;
serde_if_integer128! { /// Serialize a `u128` value.
/// Serialize a `u128` value. ///
/// /// ```edition2021
/// ```edition2021 /// # use serde::Serializer;
/// # use serde::Serializer; /// #
/// # /// # serde::__private_serialize!();
/// # serde::__private_serialize!(); /// #
/// # /// impl Serialize for u128 {
/// impl Serialize for u128 { /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
/// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> /// where
/// where /// S: Serializer,
/// S: Serializer, /// {
/// { /// serializer.serialize_u128(*self)
/// serializer.serialize_u128(*self) /// }
/// } /// }
/// } /// ```
/// ``` ///
/// /// The default behavior unconditionally returns an error.
/// This method is available only on Rust compiler versions >=1.26. The fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
/// default behavior unconditionally returns an error. let _ = v;
fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> { Err(Error::custom("u128 is not supported"))
let _ = v;
Err(Error::custom("u128 is not supported"))
}
} }
/// Serialize an `f32` value. /// Serialize an `f32` value.