Merge pull request #1965 from serde-rs/int
Reduce post-macro-expansion code in integer deserialize impls
This commit is contained in:
David Tolnay
GitHub
commit
deaf600af7
@ -1,260 +0,0 @@
|
||||
use lib::*;
|
||||
|
||||
macro_rules! int_to_int {
|
||||
($dst:ident, $n:ident) => {
|
||||
if $dst::min_value() as i64 <= $n as i64 && $n as i64 <= $dst::max_value() as i64 {
|
||||
Some($n as $dst)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
macro_rules! int_to_uint {
|
||||
($dst:ident, $n:ident) => {
|
||||
if 0 <= $n && $n as u64 <= $dst::max_value() as u64 {
|
||||
Some($n as $dst)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
macro_rules! uint_to {
|
||||
($dst:ident, $n:ident) => {
|
||||
if $n as u64 <= $dst::max_value() as u64 {
|
||||
Some($n as $dst)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
pub trait FromPrimitive: Sized {
|
||||
fn from_i8(n: i8) -> Option<Self>;
|
||||
fn from_i16(n: i16) -> Option<Self>;
|
||||
fn from_i32(n: i32) -> Option<Self>;
|
||||
fn from_i64(n: i64) -> Option<Self>;
|
||||
fn from_u8(n: u8) -> Option<Self>;
|
||||
fn from_u16(n: u16) -> Option<Self>;
|
||||
fn from_u32(n: u32) -> Option<Self>;
|
||||
fn from_u64(n: u64) -> Option<Self>;
|
||||
}
|
||||
|
||||
macro_rules! impl_from_primitive_for_int {
|
||||
($t:ident) => {
|
||||
impl FromPrimitive for $t {
|
||||
#[inline]
|
||||
fn from_i8(n: i8) -> Option<Self> {
|
||||
int_to_int!($t, n)
|
||||
}
|
||||
#[inline]
|
||||
fn from_i16(n: i16) -> Option<Self> {
|
||||
int_to_int!($t, n)
|
||||
}
|
||||
#[inline]
|
||||
fn from_i32(n: i32) -> Option<Self> {
|
||||
int_to_int!($t, n)
|
||||
}
|
||||
#[inline]
|
||||
fn from_i64(n: i64) -> Option<Self> {
|
||||
int_to_int!($t, n)
|
||||
}
|
||||
#[inline]
|
||||
fn from_u8(n: u8) -> Option<Self> {
|
||||
uint_to!($t, n)
|
||||
}
|
||||
#[inline]
|
||||
fn from_u16(n: u16) -> Option<Self> {
|
||||
uint_to!($t, n)
|
||||
}
|
||||
#[inline]
|
||||
fn from_u32(n: u32) -> Option<Self> {
|
||||
uint_to!($t, n)
|
||||
}
|
||||
#[inline]
|
||||
fn from_u64(n: u64) -> Option<Self> {
|
||||
uint_to!($t, n)
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
macro_rules! impl_from_primitive_for_uint {
|
||||
($t:ident) => {
|
||||
impl FromPrimitive for $t {
|
||||
#[inline]
|
||||
fn from_i8(n: i8) -> Option<Self> {
|
||||
int_to_uint!($t, n)
|
||||
}
|
||||
#[inline]
|
||||
fn from_i16(n: i16) -> Option<Self> {
|
||||
int_to_uint!($t, n)
|
||||
}
|
||||
#[inline]
|
||||
fn from_i32(n: i32) -> Option<Self> {
|
||||
int_to_uint!($t, n)
|
||||
}
|
||||
#[inline]
|
||||
fn from_i64(n: i64) -> Option<Self> {
|
||||
int_to_uint!($t, n)
|
||||
}
|
||||
#[inline]
|
||||
fn from_u8(n: u8) -> Option<Self> {
|
||||
uint_to!($t, n)
|
||||
}
|
||||
#[inline]
|
||||
fn from_u16(n: u16) -> Option<Self> {
|
||||
uint_to!($t, n)
|
||||
}
|
||||
#[inline]
|
||||
fn from_u32(n: u32) -> Option<Self> {
|
||||
uint_to!($t, n)
|
||||
}
|
||||
#[inline]
|
||||
fn from_u64(n: u64) -> Option<Self> {
|
||||
uint_to!($t, n)
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
macro_rules! impl_from_primitive_for_float {
|
||||
($t:ident) => {
|
||||
impl FromPrimitive for $t {
|
||||
#[inline]
|
||||
fn from_i8(n: i8) -> Option<Self> {
|
||||
Some(n as Self)
|
||||
}
|
||||
#[inline]
|
||||
fn from_i16(n: i16) -> Option<Self> {
|
||||
Some(n as Self)
|
||||
}
|
||||
#[inline]
|
||||
fn from_i32(n: i32) -> Option<Self> {
|
||||
Some(n as Self)
|
||||
}
|
||||
#[inline]
|
||||
fn from_i64(n: i64) -> Option<Self> {
|
||||
Some(n as Self)
|
||||
}
|
||||
#[inline]
|
||||
fn from_u8(n: u8) -> Option<Self> {
|
||||
Some(n as Self)
|
||||
}
|
||||
#[inline]
|
||||
fn from_u16(n: u16) -> Option<Self> {
|
||||
Some(n as Self)
|
||||
}
|
||||
#[inline]
|
||||
fn from_u32(n: u32) -> Option<Self> {
|
||||
Some(n as Self)
|
||||
}
|
||||
#[inline]
|
||||
fn from_u64(n: u64) -> Option<Self> {
|
||||
Some(n as Self)
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
impl_from_primitive_for_int!(isize);
|
||||
impl_from_primitive_for_int!(i8);
|
||||
impl_from_primitive_for_int!(i16);
|
||||
impl_from_primitive_for_int!(i32);
|
||||
impl_from_primitive_for_int!(i64);
|
||||
impl_from_primitive_for_uint!(usize);
|
||||
impl_from_primitive_for_uint!(u8);
|
||||
impl_from_primitive_for_uint!(u16);
|
||||
impl_from_primitive_for_uint!(u32);
|
||||
impl_from_primitive_for_uint!(u64);
|
||||
impl_from_primitive_for_float!(f32);
|
||||
impl_from_primitive_for_float!(f64);
|
||||
|
||||
serde_if_integer128! {
|
||||
impl FromPrimitive for i128 {
|
||||
#[inline]
|
||||
fn from_i8(n: i8) -> Option<Self> {
|
||||
Some(n as i128)
|
||||
}
|
||||
#[inline]
|
||||
fn from_i16(n: i16) -> Option<Self> {
|
||||
Some(n as i128)
|
||||
}
|
||||
#[inline]
|
||||
fn from_i32(n: i32) -> Option<Self> {
|
||||
Some(n as i128)
|
||||
}
|
||||
#[inline]
|
||||
fn from_i64(n: i64) -> Option<Self> {
|
||||
Some(n as i128)
|
||||
}
|
||||
#[inline]
|
||||
fn from_u8(n: u8) -> Option<Self> {
|
||||
Some(n as i128)
|
||||
}
|
||||
#[inline]
|
||||
fn from_u16(n: u16) -> Option<Self> {
|
||||
Some(n as i128)
|
||||
}
|
||||
#[inline]
|
||||
fn from_u32(n: u32) -> Option<Self> {
|
||||
Some(n as i128)
|
||||
}
|
||||
#[inline]
|
||||
fn from_u64(n: u64) -> Option<Self> {
|
||||
Some(n as i128)
|
||||
}
|
||||
}
|
||||
|
||||
impl FromPrimitive for u128 {
|
||||
#[inline]
|
||||
fn from_i8(n: i8) -> Option<Self> {
|
||||
if n >= 0 {
|
||||
Some(n as u128)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
fn from_i16(n: i16) -> Option<Self> {
|
||||
if n >= 0 {
|
||||
Some(n as u128)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
fn from_i32(n: i32) -> Option<Self> {
|
||||
if n >= 0 {
|
||||
Some(n as u128)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
fn from_i64(n: i64) -> Option<Self> {
|
||||
if n >= 0 {
|
||||
Some(n as u128)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
fn from_u8(n: u8) -> Option<Self> {
|
||||
Some(n as u128)
|
||||
}
|
||||
#[inline]
|
||||
fn from_u16(n: u16) -> Option<Self> {
|
||||
Some(n as u128)
|
||||
}
|
||||
#[inline]
|
||||
fn from_u32(n: u32) -> Option<Self> {
|
||||
Some(n as u128)
|
||||
}
|
||||
#[inline]
|
||||
fn from_u64(n: u64) -> Option<Self> {
|
||||
Some(n as u128)
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -8,7 +8,6 @@ use de::{
|
||||
use de::MapAccess;
|
||||
|
||||
use __private::de::InPlaceSeed;
|
||||
use de::from_primitive::FromPrimitive;
|
||||
|
||||
#[cfg(any(feature = "std", feature = "alloc"))]
|
||||
use __private::de::size_hint;
|
||||
@ -81,38 +80,8 @@ impl<'de> Deserialize<'de> for bool {
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
macro_rules! visit_integer_method {
|
||||
($src_ty:ident, $method:ident, $from_method:ident, $group:ident, $group_ty:ident) => {
|
||||
#[inline]
|
||||
fn $method<E>(self, v: $src_ty) -> Result<Self::Value, E>
|
||||
where
|
||||
E: Error,
|
||||
{
|
||||
match FromPrimitive::$from_method(v) {
|
||||
Some(v) => Ok(v),
|
||||
None => Err(Error::invalid_value(
|
||||
Unexpected::$group(v as $group_ty),
|
||||
&self,
|
||||
)),
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
macro_rules! visit_float_method {
|
||||
($src_ty:ident, $method:ident) => {
|
||||
#[inline]
|
||||
fn $method<E>(self, v: $src_ty) -> Result<Self::Value, E>
|
||||
where
|
||||
E: Error,
|
||||
{
|
||||
Ok(v as Self::Value)
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
macro_rules! impl_deserialize_num {
|
||||
($ty:ident, $method:ident, $($visit:ident),*) => {
|
||||
($ty:ident, $deserialize:ident $($methods:tt)*) => {
|
||||
impl<'de> Deserialize<'de> for $ty {
|
||||
#[inline]
|
||||
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
|
||||
@ -128,131 +97,221 @@ macro_rules! impl_deserialize_num {
|
||||
formatter.write_str(stringify!($ty))
|
||||
}
|
||||
|
||||
$(
|
||||
impl_deserialize_num!($visit);
|
||||
)*
|
||||
$($methods)*
|
||||
}
|
||||
|
||||
deserializer.$method(PrimitiveVisitor)
|
||||
deserializer.$deserialize(PrimitiveVisitor)
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
(integer) => {
|
||||
visit_integer_method!(i8, visit_i8, from_i8, Signed, i64);
|
||||
visit_integer_method!(i16, visit_i16, from_i16, Signed, i64);
|
||||
visit_integer_method!(i32, visit_i32, from_i32, Signed, i64);
|
||||
visit_integer_method!(i64, visit_i64, from_i64, Signed, i64);
|
||||
|
||||
visit_integer_method!(u8, visit_u8, from_u8, Unsigned, u64);
|
||||
visit_integer_method!(u16, visit_u16, from_u16, Unsigned, u64);
|
||||
visit_integer_method!(u32, visit_u32, from_u32, Unsigned, u64);
|
||||
visit_integer_method!(u64, visit_u64, from_u64, Unsigned, u64);
|
||||
};
|
||||
|
||||
(float) => {
|
||||
visit_float_method!(f32, visit_f32);
|
||||
visit_float_method!(f64, visit_f64);
|
||||
};
|
||||
}
|
||||
|
||||
impl_deserialize_num!(i8, deserialize_i8, integer);
|
||||
impl_deserialize_num!(i16, deserialize_i16, integer);
|
||||
impl_deserialize_num!(i32, deserialize_i32, integer);
|
||||
impl_deserialize_num!(i64, deserialize_i64, integer);
|
||||
impl_deserialize_num!(isize, deserialize_i64, integer);
|
||||
|
||||
impl_deserialize_num!(u8, deserialize_u8, integer);
|
||||
impl_deserialize_num!(u16, deserialize_u16, integer);
|
||||
impl_deserialize_num!(u32, deserialize_u32, integer);
|
||||
impl_deserialize_num!(u64, deserialize_u64, integer);
|
||||
impl_deserialize_num!(usize, deserialize_u64, integer);
|
||||
|
||||
impl_deserialize_num!(f32, deserialize_f32, integer, float);
|
||||
impl_deserialize_num!(f64, deserialize_f64, integer, float);
|
||||
|
||||
serde_if_integer128! {
|
||||
impl<'de> Deserialize<'de> for i128 {
|
||||
macro_rules! num_self {
|
||||
($ty:ident : $visit:ident) => {
|
||||
#[inline]
|
||||
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
|
||||
fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
|
||||
where
|
||||
D: Deserializer<'de>,
|
||||
E: Error,
|
||||
{
|
||||
struct PrimitiveVisitor;
|
||||
Ok(v)
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
impl<'de> Visitor<'de> for PrimitiveVisitor {
|
||||
type Value = i128;
|
||||
macro_rules! num_as_self {
|
||||
($($ty:ident : $visit:ident)*) => {
|
||||
$(
|
||||
#[inline]
|
||||
fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
|
||||
where
|
||||
E: Error,
|
||||
{
|
||||
Ok(v as Self::Value)
|
||||
}
|
||||
)*
|
||||
};
|
||||
}
|
||||
|
||||
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
|
||||
formatter.write_str("i128")
|
||||
}
|
||||
|
||||
impl_deserialize_num!(integer);
|
||||
|
||||
#[inline]
|
||||
fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
|
||||
where
|
||||
E: Error,
|
||||
{
|
||||
Ok(v)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
|
||||
where
|
||||
E: Error,
|
||||
{
|
||||
if v <= i128::max_value() as u128 {
|
||||
Ok(v as i128)
|
||||
} else {
|
||||
Err(Error::invalid_value(Unexpected::Other("u128"), &self))
|
||||
}
|
||||
macro_rules! int_to_int {
|
||||
($($ty:ident : $visit:ident)*) => {
|
||||
$(
|
||||
#[inline]
|
||||
fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
|
||||
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))
|
||||
}
|
||||
}
|
||||
)*
|
||||
};
|
||||
}
|
||||
|
||||
deserializer.deserialize_i128(PrimitiveVisitor)
|
||||
macro_rules! int_to_uint {
|
||||
($($ty:ident : $visit:ident)*) => {
|
||||
$(
|
||||
#[inline]
|
||||
fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
|
||||
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))
|
||||
}
|
||||
}
|
||||
)*
|
||||
};
|
||||
}
|
||||
|
||||
macro_rules! uint_to_self {
|
||||
($($ty:ident : $visit:ident)*) => {
|
||||
$(
|
||||
#[inline]
|
||||
fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
|
||||
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))
|
||||
}
|
||||
}
|
||||
)*
|
||||
};
|
||||
}
|
||||
|
||||
impl_deserialize_num! {
|
||||
i8, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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_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_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);
|
||||
}
|
||||
|
||||
serde_if_integer128! {
|
||||
impl_deserialize_num! {
|
||||
i128, 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);
|
||||
|
||||
#[inline]
|
||||
fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
|
||||
where
|
||||
E: Error,
|
||||
{
|
||||
if v <= i128::max_value() as u128 {
|
||||
Ok(v as i128)
|
||||
} else {
|
||||
Err(Error::invalid_value(Unexpected::Other("u128"), &self))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'de> Deserialize<'de> for u128 {
|
||||
impl_deserialize_num! {
|
||||
u128, 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);
|
||||
|
||||
#[inline]
|
||||
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
|
||||
fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
|
||||
where
|
||||
D: Deserializer<'de>,
|
||||
E: Error,
|
||||
{
|
||||
struct PrimitiveVisitor;
|
||||
|
||||
impl<'de> Visitor<'de> for PrimitiveVisitor {
|
||||
type Value = u128;
|
||||
|
||||
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
|
||||
formatter.write_str("u128")
|
||||
}
|
||||
|
||||
impl_deserialize_num!(integer);
|
||||
|
||||
#[inline]
|
||||
fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
|
||||
where
|
||||
E: Error,
|
||||
{
|
||||
if v >= 0 {
|
||||
Ok(v as u128)
|
||||
} else {
|
||||
Err(Error::invalid_value(Unexpected::Other("i128"), &self))
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
|
||||
where
|
||||
E: Error,
|
||||
{
|
||||
Ok(v)
|
||||
}
|
||||
if 0 <= v {
|
||||
Ok(v as u128)
|
||||
} else {
|
||||
Err(Error::invalid_value(Unexpected::Other("i128"), &self))
|
||||
}
|
||||
|
||||
deserializer.deserialize_u128(PrimitiveVisitor)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -118,7 +118,6 @@ use lib::*;
|
||||
|
||||
pub mod value;
|
||||
|
||||
mod from_primitive;
|
||||
mod ignored_any;
|
||||
mod impls;
|
||||
mod utf8;
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user