More compact bytes serialization and code re-use.

substrate/primitives/src/uint.rs

@@ -16,57 +16,30 @@
 
 //! An unsigned fixed-size integer.
 
-use std::fmt;
-use serde::{de, Serialize, Serializer, Deserialize, Deserializer};
+use serde::{Serialize, Serializer, Deserialize, Deserializer};
+
+use bytes;
 
 macro_rules! impl_serde {
 	($name: ident, $len: expr) => {
 		impl Serialize for $name {
 			fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
-				// TODO [ToDr] Use raw bytes if we switch to RLP / binencoding
-				// (serialize_bytes)
-				if self.is_zero() {
-					// TODO [ToDr] LowerHex of 0 is broken
-					serializer.serialize_str("0x0")
-				} else {
-					serializer.serialize_str(&format!("{:#x}", self))
-				}
+				let mut bytes = [0u8; $len * 8];
+				self.to_big_endian(&mut bytes);
+				bytes::serialize_compact(&bytes, serializer)
 			}
 		}
 
 		impl<'de> Deserialize<'de> for $name {
 			fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {
-				struct Visitor;
-				impl<'a> de::Visitor<'a> for Visitor {
-					type Value = $name;
-
-					fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-						write!(formatter, "a 0x-prefixed hex string")
+				bytes::deserialize_with_check(deserializer, |v: &str| {
+					// 0x + len
+					if v.len() > 2 + $len * 16 || v.len() == 2 {
+						Err(bytes::ErrorKind::InvalidLength(v.len() - 2))
+					} else {
+						Ok(())
 					}
-
-					fn visit_str<E: de::Error>(self, v: &str) -> Result<Self::Value, E> {
-						if v.len() < 3  || &v[0..2] != "0x" {
-							return Err(E::custom("prefix is missing"))
-						}
-
-						// 0x + len
-						if v.len() > 2 + $len * 16 {
-							return Err(E::invalid_length(v.len() - 2, &self));
-						}
-
-						let v = if v.len() % 2 == 0 { v[2..].to_owned() } else { format!("0{}", &v[2..]) };
-						let bytes = ::rustc_hex::FromHex::from_hex(v.as_str())
-							.map_err(|e| E::custom(&format!("invalid hex value: {:?}", e)))?;
-						Ok((&*bytes).into())
-					}
-
-					fn visit_string<E: de::Error>(self, v: String) -> Result<Self::Value, E> {
-						self.visit_str(&v)
-					}
-				}
-				// TODO [ToDr] Use raw bytes if we switch to RLP / binencoding
-				// (visit_bytes, visit_bytes_buf)
-				deserializer.deserialize_str(Visitor)
+				}).map(|bytes| (&*bytes).into())
 			}
 		}
 	}