fix: add missing support for 128-bit integers serialization

Author: tyranron

src/de.rs

@@ -85,6 +85,15 @@ impl<'de> de::Deserializer<'de> for Value {
         visitor.visit_i64(num)
     }
 
+    #[inline]
+    fn deserialize_i128<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
+        let num = self.into_int128()?;
+        let num = num.try_into().map_err(|_| {
+            ConfigError::invalid_type(None, Unexpected::I128(num), "a signed 128 bit integer")
+        })?;
+        visitor.visit_i128(num)
+    }
+
     #[inline]
     fn deserialize_u8<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
         let num = try_convert_number!(unsigned, self, "8");
@@ -109,6 +118,15 @@ impl<'de> de::Deserializer<'de> for Value {
         visitor.visit_u64(num)
     }
 
+    #[inline]
+    fn deserialize_u128<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
+        let num = self.into_uint128()?;
+        let num = num.try_into().map_err(|_| {
+            ConfigError::invalid_type(None, Unexpected::U128(num), "an unsigned 128 bit integer")
+        })?;
+        visitor.visit_u128(num)
+    }
+
     #[inline]
     fn deserialize_f32<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
         visitor.visit_f32(self.into_float()? as f32)

src/ser.rs

@@ -108,6 +108,24 @@ impl<'a> ser::Serializer for &'a mut ConfigSerializer {
         self.serialize_primitive(v)
     }
 
+    fn serialize_i128(self, v: i128) -> Result<Self::Ok> {
+        if v > i64::MAX.into() {
+            Err(ConfigError::Message(format!(
+                "value {} is greater than the max {}",
+                v,
+                i64::MAX
+            )))
+        } else if v < i64::MIN.into() {
+            Err(ConfigError::Message(format!(
+                "value {} is less than the min {}",
+                v,
+                i64::MIN
+            )))
+        } else {
+            self.serialize_i64(v as i64)
+        }
+    }
+
     fn serialize_u8(self, v: u8) -> Result<Self::Ok> {
         self.serialize_u64(v.into())
     }
@@ -132,6 +150,18 @@ impl<'a> ser::Serializer for &'a mut ConfigSerializer {
         }
     }
 
+    fn serialize_u128(self, v: u128) -> Result<Self::Ok> {
+        if v > (i64::MAX as u128) {
+            Err(ConfigError::Message(format!(
+                "value {} is greater than the max {}",
+                v,
+                i64::MAX
+            )))
+        } else {
+            self.serialize_i64(v as i64)
+        }
+    }
+
     fn serialize_f32(self, v: f32) -> Result<Self::Ok> {
         self.serialize_f64(v.into())
     }

tests/testsuite/i128.rs

@@ -0,0 +1,36 @@
+#![cfg(feature = "preserve_order")]
+
+use serde::Deserialize;
+
+#[derive(Debug, Deserialize, Eq, PartialEq)]
+struct Container<T> {
+    inner: T,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq)]
+struct I128 {
+    val: i128,
+}
+
+impl From<I128> for config::ValueKind {
+    fn from(i: I128) -> Self {
+        let mut properties = indexmap::IndexMap::new();
+        properties.insert("val".to_owned(), config::Value::from(i.val));
+
+        Self::Table(properties)
+    }
+}
+
+#[test]
+fn test_deserialize_i128_min() {
+    let num = I128 { val: i128::MIN };
+    let container = Container { inner: num };
+    let built = config::Config::builder()
+        .set_default("inner", num)
+        .unwrap()
+        .build()
+        .unwrap();
+
+    let deserialized = built.clone().try_deserialize::<Container<I128>>().unwrap();
+    assert_eq!(deserialized, container);
+}

tests/testsuite/main.rs

@@ -16,11 +16,13 @@ pub mod file_ron;
 pub mod file_toml;
 pub mod file_yaml;
 pub mod get;
+pub mod i128;
 pub mod integer_range;
 pub mod log;
 pub mod merge;
 pub mod ron_enum;
 pub mod set;
+pub mod u128;
 pub mod unsigned_int;
 pub mod unsigned_int_hm;
 pub mod weird_keys;

tests/testsuite/u128.rs

@@ -0,0 +1,36 @@
+#![cfg(feature = "preserve_order")]
+
+use serde::Deserialize;
+
+#[derive(Debug, Deserialize, Eq, PartialEq)]
+struct Container<T> {
+    inner: T,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq)]
+struct U128 {
+    val: u128,
+}
+
+impl From<U128> for config::ValueKind {
+    fn from(i: U128) -> Self {
+        let mut properties = indexmap::IndexMap::new();
+        properties.insert("val".to_owned(), config::Value::from(i.val));
+
+        Self::Table(properties)
+    }
+}
+
+#[test]
+fn test_deserialize_u128_min() {
+    let num = U128 { val: u128::MIN };
+    let container = Container { inner: num };
+    let built = config::Config::builder()
+        .set_default("inner", num)
+        .unwrap()
+        .build()
+        .unwrap();
+
+    let deserialized = built.clone().try_deserialize::<Container<U128>>().unwrap();
+    assert_eq!(deserialized, container);
+}