Make it explicit that serialization is in u32

Add explicit type annotations to make sure we serialize `BigUint` like a
`Vec<u32>`.  If we ever change the internal representation, we still
need to remain compatible with serialized data.

Also, deserializing `BigUint` and `BigInt` now uses their normal
constructor methods, to make sure they are normalized.  We shouldn't
assume that all incoming data is already well-formed.

Author: cuviper

src/bigint.rs

@@ -73,6 +73,8 @@ impl serde::Serialize for Sign {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
         where S: serde::Serializer
     {
+        // Note: do not change the serialization format, or it may break
+        // forward and backward compatibility of serialized data!
         match *self {
             Sign::Minus => (-1i8).serialize(serializer),
             Sign::NoSign => 0i8.serialize(serializer),
@@ -1701,6 +1703,8 @@ impl serde::Serialize for BigInt {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
         where S: serde::Serializer
     {
+        // Note: do not change the serialization format, or it may break
+        // forward and backward compatibility of serialized data!
         (self.sign, &self.data).serialize(serializer)
     }
 }
@@ -1711,10 +1715,7 @@ impl<'de> serde::Deserialize<'de> for BigInt {
         where D: serde::Deserializer<'de>
     {
         let (sign, data) = serde::Deserialize::deserialize(deserializer)?;
-        Ok(BigInt {
-            sign: sign,
-            data: data,
-        })
+        Ok(BigInt::from_biguint(sign, data))
     }
 }
 

src/biguint.rs

@@ -1745,7 +1745,11 @@ impl serde::Serialize for BigUint {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
         where S: serde::Serializer
     {
-        self.data.serialize(serializer)
+        // Note: do not change the serialization format, or it may break forward
+        // and backward compatibility of serialized data!  If we ever change the
+        // internal representation, we should still serialize in base-`u32`.
+        let data: &Vec<u32> = &self.data;
+        data.serialize(serializer)
     }
 }
 
@@ -1754,8 +1758,8 @@ impl<'de> serde::Deserialize<'de> for BigUint {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
         where D: serde::Deserializer<'de>
     {
-        let data = try!(Vec::deserialize(deserializer));
-        Ok(BigUint { data: data })
+        let data: Vec<u32> = try!(Vec::deserialize(deserializer));
+        Ok(BigUint::new(data))
     }
 }