Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Improves u128/i128 handling #1679

Closed
wants to merge 5 commits into from
Closed

Improves u128/i128 handling #1679

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
5 commits
Select commit Hold shift + click to select a range
94f0b40
Adds support for `i128`/`u128` for `de::Content`
bkchr Nov 21, 2019
2bf6d84
Add support for converting from `i128`/`u128` to other primitive types
bkchr Nov 21, 2019
ba1c319
Remove newly added `Unexpected` variants
bkchr Nov 21, 2019
9b9a61a
Fix macro for older rustc versions
bkchr Nov 21, 2019
bbf4395
Try to make rust 1.13 happy
bkchr Nov 21, 2019
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
141 changes: 53 additions & 88 deletions serde/src/de/from_primitive.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,8 +1,22 @@
use lib::*;

#[cfg(integer128)]
type SignedInt = i128;

#[cfg(not(integer128))]
type SignedInt = i64;

#[cfg(integer128)]
type UnsignedInt = u128;

#[cfg(not(integer128))]
type UnsignedInt = u64;

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 {
if $dst::min_value() as SignedInt <= $n as SignedInt &&
$n as SignedInt <= $dst::max_value() as SignedInt
{
Some($n as $dst)
} else {
None
Expand All @@ -12,7 +26,7 @@ macro_rules! int_to_int {

macro_rules! int_to_uint {
($dst:ident, $n:ident) => {
if 0 <= $n && $n as u64 <= $dst::max_value() as u64 {
if 0 <= $n && $n as UnsignedInt <= $dst::max_value() as UnsignedInt {
Some($n as $dst)
} else {
None
Expand All @@ -22,7 +36,7 @@ macro_rules! int_to_uint {

macro_rules! uint_to {
($dst:ident, $n:ident) => {
if $n as u64 <= $dst::max_value() as u64 {
if $n as UnsignedInt <= $dst::max_value() as UnsignedInt {
Some($n as $dst)
} else {
None
Expand All @@ -35,10 +49,14 @@ pub trait FromPrimitive: Sized {
fn from_i16(n: i16) -> Option<Self>;
fn from_i32(n: i32) -> Option<Self>;
fn from_i64(n: i64) -> Option<Self>;
#[cfg(integer128)]
fn from_i128(n: i128) -> 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>;
#[cfg(integer128)]
fn from_u128(n: u128) -> Option<Self>;
}

macro_rules! impl_from_primitive_for_int {
Expand All @@ -60,6 +78,11 @@ macro_rules! impl_from_primitive_for_int {
fn from_i64(n: i64) -> Option<Self> {
int_to_int!($t, n)
}
#[cfg(integer128)]
#[inline]
fn from_i128(n: i128) -> Option<Self> {
int_to_int!($t, n)
}
#[inline]
fn from_u8(n: u8) -> Option<Self> {
uint_to!($t, n)
Expand All @@ -76,6 +99,11 @@ macro_rules! impl_from_primitive_for_int {
fn from_u64(n: u64) -> Option<Self> {
uint_to!($t, n)
}
#[cfg(integer128)]
#[inline]
fn from_u128(n: u128) -> Option<Self> {
uint_to!($t, n)
}
}
};
}
Expand All @@ -99,6 +127,11 @@ macro_rules! impl_from_primitive_for_uint {
fn from_i64(n: i64) -> Option<Self> {
int_to_uint!($t, n)
}
#[cfg(integer128)]
#[inline]
fn from_i128(n: i128) -> Option<Self> {
int_to_uint!($t, n)
}
#[inline]
fn from_u8(n: u8) -> Option<Self> {
uint_to!($t, n)
Expand All @@ -115,6 +148,11 @@ macro_rules! impl_from_primitive_for_uint {
fn from_u64(n: u64) -> Option<Self> {
uint_to!($t, n)
}
#[cfg(integer128)]
#[inline]
fn from_u128(n: u128) -> Option<Self> {
uint_to!($t, n)
}
}
};
}
Expand All @@ -138,6 +176,11 @@ macro_rules! impl_from_primitive_for_float {
fn from_i64(n: i64) -> Option<Self> {
Some(n as Self)
}
#[cfg(integer128)]
#[inline]
fn from_i128(n: i128) -> Option<Self> {
Some(n as Self)
}
#[inline]
fn from_u8(n: u8) -> Option<Self> {
Some(n as Self)
Expand All @@ -154,6 +197,11 @@ macro_rules! impl_from_primitive_for_float {
fn from_u64(n: u64) -> Option<Self> {
Some(n as Self)
}
#[cfg(integer128)]
#[inline]
fn from_u128(n: u128) -> Option<Self> {
Some(n as Self)
}
}
};
}
Expand All @@ -172,89 +220,6 @@ 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)
}
}
impl_from_primitive_for_int!(i128);
impl_from_primitive_for_uint!(u128);
}
120 changes: 26 additions & 94 deletions serde/src/de/impls.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -82,17 +82,25 @@ impl<'de> Deserialize<'de> for bool {
////////////////////////////////////////////////////////////////////////////////

macro_rules! visit_integer_method {
($src_ty:ident, $method:ident, $from_method:ident, $group:ident, $group_ty:ident) => {
($src_ty:ident, $method:ident, $from_method:ident, $group:ident $(, $err_msg:expr )*) => {
#[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)),
None => visit_integer_method!(ERR self, $group, v $(, $err_msg)*),
}
}
};

(ERR $this:ident, $group:ident, $v: ident, $msg:expr) => {
Err(Error::invalid_value(Unexpected::$group($msg), &$this))
};

(ERR $this:ident, $group:ident, $v:ident) => {
Err(Error::invalid_value(Unexpected::$group($v as _), &$this))
}
}

Expand Down Expand Up @@ -136,15 +144,20 @@ macro_rules! impl_deserialize_num {
};

(integer $ty:ident) => {
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);
visit_integer_method!(i8, visit_i8, from_i8, Signed);
visit_integer_method!(i16, visit_i16, from_i16, Signed);
visit_integer_method!(i32, visit_i32, from_i32, Signed);
visit_integer_method!(i64, visit_i64, from_i64, Signed);

visit_integer_method!(u8, visit_u8, from_u8, Unsigned);
visit_integer_method!(u16, visit_u16, from_u16, Unsigned);
visit_integer_method!(u32, visit_u32, from_u32, Unsigned);
visit_integer_method!(u64, visit_u64, from_u64, Unsigned);

serde_if_integer128! {
visit_integer_method!(i128, visit_i128, from_i128, Other, "`i128`");
visit_integer_method!(u128, visit_u128, from_u128, Other, "`u128`");
}
};

(float $ty:ident) => {
Expand All @@ -169,89 +182,8 @@ 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 {
#[inline]
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
struct PrimitiveVisitor;

impl<'de> Visitor<'de> for PrimitiveVisitor {
type Value = i128;

fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("i128")
}

impl_deserialize_num!(integer i128);

#[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))
}
}
}

deserializer.deserialize_i128(PrimitiveVisitor)
}
}

impl<'de> Deserialize<'de> for u128 {
#[inline]
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
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 u128);

#[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)
}
}

deserializer.deserialize_u128(PrimitiveVisitor)
}
}
impl_deserialize_num!(i128, deserialize_i128, integer);
impl_deserialize_num!(u128, deserialize_u128, integer);
}

////////////////////////////////////////////////////////////////////////////////
Expand Down
Loading