From 4a390267f42e5bac42ee959adc4c318955d83f2a Mon Sep 17 00:00:00 2001 From: Ashley Mannix Date: Tue, 21 Aug 2018 13:12:24 +1000 Subject: [PATCH 1/2] add support for 128bit numbers --- Cargo.toml | 2 +- src/de.rs | 50 ++++++++++++++++++++++++++++++++++++++++++++++++++ src/lib.rs | 1 + src/ser.rs | 25 +++++++++++++++++++++++++ 4 files changed, 77 insertions(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index 19bff40..e5a6abb 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -10,7 +10,7 @@ keywords = ["serde", "erasure"] include = ["Cargo.toml", "src/**/*.rs", "LICENSE-*"] [dependencies] -serde = "1.0" +serde = "1.0.63" [dev-dependencies] serde_cbor = "0.8" diff --git a/src/de.rs b/src/de.rs index 9bb70af..f3557c0 100644 --- a/src/de.rs +++ b/src/de.rs @@ -98,6 +98,14 @@ pub trait Deserializer<'de> { fn erased_deserialize_i16(&mut self, &mut Visitor<'de>) -> Result; fn erased_deserialize_i32(&mut self, &mut Visitor<'de>) -> Result; fn erased_deserialize_i64(&mut self, &mut Visitor<'de>) -> Result; + serde_if_integer128! { + fn erased_deserialize_i128(&mut self, &mut Visitor<'de>) -> Result { + Err(::custom("erased I128 is not supported")) + } + fn erased_deserialize_u128(&mut self, &mut Visitor<'de>) -> Result { + Err(::custom("erased U128 is not supported")) + } + } fn erased_deserialize_f32(&mut self, &mut Visitor<'de>) -> Result; fn erased_deserialize_f64(&mut self, &mut Visitor<'de>) -> Result; fn erased_deserialize_char(&mut self, &mut Visitor<'de>) -> Result; @@ -131,6 +139,14 @@ pub trait Visitor<'de> { fn erased_visit_u16(&mut self, u16) -> Result; fn erased_visit_u32(&mut self, u32) -> Result; fn erased_visit_u64(&mut self, u64) -> Result; + serde_if_integer128! { + fn erased_visit_i128(&mut self, i128) -> Result { + Err(::custom("erased U128 is not supported")) + } + fn erased_visit_u128(&mut self, u128) -> Result { + Err(::custom("erased I128 is not supported")) + } + } fn erased_visit_f32(&mut self, f32) -> Result; fn erased_visit_f64(&mut self, f64) -> Result; fn erased_visit_char(&mut self, char) -> Result; @@ -327,6 +343,14 @@ impl<'de, T> Deserializer<'de> for erase::Deserializer where T: serde::Deseri fn erased_deserialize_i64(&mut self, visitor: &mut Visitor<'de>) -> Result { self.take().deserialize_i64(visitor).map_err(erase) } + serde_if_integer128! { + fn erased_deserialize_u128(&mut self, visitor: &mut Visitor<'de>) -> Result { + self.take().deserialize_u128(visitor).map_err(erase) + } + fn erased_deserialize_i128(&mut self, visitor: &mut Visitor<'de>) -> Result { + self.take().deserialize_i128(visitor).map_err(erase) + } + } fn erased_deserialize_f32(&mut self, visitor: &mut Visitor<'de>) -> Result { self.take().deserialize_f32(visitor).map_err(erase) } @@ -572,6 +596,16 @@ macro_rules! impl_deserializer_for_trait_object { let mut erased = erase::Visitor { state: Some(visitor) }; self.erased_deserialize_i64(&mut erased).map(Out::take) } + serde_if_integer128! { + fn deserialize_i128($($mut)* self, visitor: V) -> Result where V: serde::de::Visitor<'de> { + let mut erased = erase::Visitor { state: Some(visitor) }; + self.erased_deserialize_i128(&mut erased).map(Out::take) + } + fn deserialize_u128($($mut)* self, visitor: V) -> Result where V: serde::de::Visitor<'de> { + let mut erased = erase::Visitor { state: Some(visitor) }; + self.erased_deserialize_u128(&mut erased).map(Out::take) + } + } fn deserialize_f32($($mut)* self, visitor: V) -> Result where V: serde::de::Visitor<'de> { let mut erased = erase::Visitor { state: Some(visitor) }; self.erased_deserialize_f32(&mut erased).map(Out::take) @@ -696,6 +730,14 @@ impl<'de, 'a> serde::de::Visitor<'de> for &'a mut Visitor<'de> { fn visit_u64(self, v: u64) -> Result where E: serde::de::Error { self.erased_visit_u64(v).map_err(unerase) } + serde_if_integer128! { + fn visit_i128(self, v: i128) -> Result where E: serde::de::Error { + self.erased_visit_i128(v).map_err(unerase) + } + fn visit_u128(self, v: u128) -> Result where E: serde::de::Error { + self.erased_visit_u128(v).map_err(unerase) + } + } fn visit_f32(self, v: f32) -> Result where E: serde::de::Error { self.erased_visit_f32(v).map_err(unerase) } @@ -848,6 +890,14 @@ macro_rules! deref_erased_deserializer { fn erased_deserialize_i64(&mut self, visitor: &mut Visitor<'de>) -> Result { (**self).erased_deserialize_i64(visitor) } + serde_if_integer128! { + fn erased_deserialize_i128(&mut self, visitor: &mut Visitor<'de>) -> Result { + (**self).erased_deserialize_i128(visitor) + } + fn erased_deserialize_u128(&mut self, visitor: &mut Visitor<'de>) -> Result { + (**self).erased_deserialize_u128(visitor) + } + } fn erased_deserialize_f32(&mut self, visitor: &mut Visitor<'de>) -> Result { (**self).erased_deserialize_f32(visitor) } diff --git a/src/lib.rs b/src/lib.rs index 964c9e1..8e5a5cf 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -92,6 +92,7 @@ #![cfg_attr(feature = "unstable-debug", feature(core_intrinsics))] +#[macro_use] extern crate serde; #[cfg(test)] diff --git a/src/ser.rs b/src/ser.rs index 4f2a6f0..6c6c4b1 100644 --- a/src/ser.rs +++ b/src/ser.rs @@ -112,6 +112,15 @@ pub trait Serializer { fn erased_serialize_u16(&mut self, u16) -> Result; fn erased_serialize_u32(&mut self, u32) -> Result; fn erased_serialize_u64(&mut self, u64) -> Result; + serde_if_integer128! { + fn erased_serialize_i128(&mut self, i128) -> Result { + Err(::custom("erased I128 is not supported")) + } + + fn erased_serialize_u128(&mut self, u128) -> Result { + Err(::custom("erased U128 is not supported")) + } + } fn erased_serialize_f32(&mut self, f32) -> Result; fn erased_serialize_f64(&mut self, f64) -> Result; fn erased_serialize_char(&mut self, char) -> Result; @@ -261,6 +270,14 @@ impl Serializer for erase::Serializer where T: serde::Serializer { fn erased_serialize_u64(&mut self, v: u64) -> Result { self.take().serialize_u64(v).map(Ok::new).map_err(erase) } + serde_if_integer128! { + fn erased_serialize_i128(&mut self, v: i128) -> Result { + self.take().serialize_i128(v).map(Ok::new).map_err(erase) + } + fn erased_serialize_u128(&mut self, v: u128) -> Result { + self.take().serialize_u128(v).map(Ok::new).map_err(erase) + } + } fn erased_serialize_f32(&mut self, v: f32) -> Result { self.take().serialize_f32(v).map(Ok::new).map_err(erase) } @@ -411,6 +428,14 @@ macro_rules! impl_serializer_for_trait_object { fn serialize_u64(self, v: u64) -> Result { self.erased_serialize_u64(v) } + serde_if_integer128! { + fn serialize_i128(self, v: i128) -> Result { + self.erased_serialize_i128(v) + } + fn serialize_u128(self, v: u128) -> Result { + self.erased_serialize_u128(v) + } + } fn serialize_f32(self, v: f32) -> Result { self.erased_serialize_f32(v) } From ba36272aaec79c9b3673f7fe5ba80f470d41674e Mon Sep 17 00:00:00 2001 From: Ashley Mannix Date: Wed, 22 Aug 2018 12:05:04 +1000 Subject: [PATCH 2/2] don't provide default impls for 128bit methods --- src/de.rs | 30 +++++++++++++++--------------- src/ser.rs | 17 ++++++++++------- 2 files changed, 25 insertions(+), 22 deletions(-) diff --git a/src/de.rs b/src/de.rs index f3557c0..73231ab 100644 --- a/src/de.rs +++ b/src/de.rs @@ -99,12 +99,8 @@ pub trait Deserializer<'de> { fn erased_deserialize_i32(&mut self, &mut Visitor<'de>) -> Result; fn erased_deserialize_i64(&mut self, &mut Visitor<'de>) -> Result; serde_if_integer128! { - fn erased_deserialize_i128(&mut self, &mut Visitor<'de>) -> Result { - Err(::custom("erased I128 is not supported")) - } - fn erased_deserialize_u128(&mut self, &mut Visitor<'de>) -> Result { - Err(::custom("erased U128 is not supported")) - } + fn erased_deserialize_i128(&mut self, &mut Visitor<'de>) -> Result; + fn erased_deserialize_u128(&mut self, &mut Visitor<'de>) -> Result; } fn erased_deserialize_f32(&mut self, &mut Visitor<'de>) -> Result; fn erased_deserialize_f64(&mut self, &mut Visitor<'de>) -> Result; @@ -140,12 +136,8 @@ pub trait Visitor<'de> { fn erased_visit_u32(&mut self, u32) -> Result; fn erased_visit_u64(&mut self, u64) -> Result; serde_if_integer128! { - fn erased_visit_i128(&mut self, i128) -> Result { - Err(::custom("erased U128 is not supported")) - } - fn erased_visit_u128(&mut self, u128) -> Result { - Err(::custom("erased I128 is not supported")) - } + fn erased_visit_i128(&mut self, i128) -> Result; + fn erased_visit_u128(&mut self, u128) -> Result; } fn erased_visit_f32(&mut self, f32) -> Result; fn erased_visit_f64(&mut self, f64) -> Result; @@ -344,12 +336,12 @@ impl<'de, T> Deserializer<'de> for erase::Deserializer where T: serde::Deseri self.take().deserialize_i64(visitor).map_err(erase) } serde_if_integer128! { - fn erased_deserialize_u128(&mut self, visitor: &mut Visitor<'de>) -> Result { - self.take().deserialize_u128(visitor).map_err(erase) - } fn erased_deserialize_i128(&mut self, visitor: &mut Visitor<'de>) -> Result { self.take().deserialize_i128(visitor).map_err(erase) } + fn erased_deserialize_u128(&mut self, visitor: &mut Visitor<'de>) -> Result { + self.take().deserialize_u128(visitor).map_err(erase) + } } fn erased_deserialize_f32(&mut self, visitor: &mut Visitor<'de>) -> Result { self.take().deserialize_f32(visitor).map_err(erase) @@ -444,6 +436,14 @@ impl<'de, T> Visitor<'de> for erase::Visitor where T: serde::de::Visitor<'de> fn erased_visit_u64(&mut self, v: u64) -> Result { self.take().visit_u64(v).map(Out::new) } + serde_if_integer128! { + fn erased_visit_i128(&mut self, v: i128) -> Result { + self.take().visit_i128(v).map(Out::new) + } + fn erased_visit_u128(&mut self, v: u128) -> Result { + self.take().visit_u128(v).map(Out::new) + } + } fn erased_visit_f32(&mut self, v: f32) -> Result { self.take().visit_f32(v).map(Out::new) } diff --git a/src/ser.rs b/src/ser.rs index 6c6c4b1..4c7c5a8 100644 --- a/src/ser.rs +++ b/src/ser.rs @@ -113,13 +113,8 @@ pub trait Serializer { fn erased_serialize_u32(&mut self, u32) -> Result; fn erased_serialize_u64(&mut self, u64) -> Result; serde_if_integer128! { - fn erased_serialize_i128(&mut self, i128) -> Result { - Err(::custom("erased I128 is not supported")) - } - - fn erased_serialize_u128(&mut self, u128) -> Result { - Err(::custom("erased U128 is not supported")) - } + fn erased_serialize_i128(&mut self, i128) -> Result; + fn erased_serialize_u128(&mut self, u128) -> Result; } fn erased_serialize_f32(&mut self, f32) -> Result; fn erased_serialize_f64(&mut self, f64) -> Result; @@ -782,6 +777,14 @@ macro_rules! deref_erased_serializer { fn erased_serialize_u64(&mut self, v: u64) -> Result { (**self).erased_serialize_u64(v) } + serde_if_integer128! { + fn erased_serialize_i128(&mut self, v: i128) -> Result { + (**self).erased_serialize_i128(v) + } + fn erased_serialize_u128(&mut self, v: u128) -> Result { + (**self).erased_serialize_u128(v) + } + } fn erased_serialize_f32(&mut self, v: f32) -> Result { (**self).erased_serialize_f32(v) }