From de4a227a477216bc6a51c7c59a59951791b6282c Mon Sep 17 00:00:00 2001
From: debris <marek.kotewicz@gmail.com>
Date: Mon, 14 Dec 2015 11:56:11 +0100
Subject: [PATCH 1/2] decoding fixed sized arrays

---
 src/rlp/errors.rs        |  1 +
 src/rlp/tests.rs         |  8 ++++++++
 src/rlp/untrusted_rlp.rs | 35 +++++++++++++++++++++++++++++++++++
 3 files changed, 44 insertions(+)

diff --git a/src/rlp/errors.rs b/src/rlp/errors.rs
index ada3c2a47..4ee41a2ce 100644
--- a/src/rlp/errors.rs
+++ b/src/rlp/errors.rs
@@ -8,6 +8,7 @@ pub enum DecoderError {
 	RlpIsTooShort,
 	RlpExpectedToBeList,
 	RlpExpectedToBeData,
+	RlpIncorrectListLen
 }
 
 impl StdError for DecoderError {
diff --git a/src/rlp/tests.rs b/src/rlp/tests.rs
index e44953e07..b4a60a3de 100644
--- a/src/rlp/tests.rs
+++ b/src/rlp/tests.rs
@@ -343,3 +343,11 @@ fn test_rlp_json() {
 	});
 }
 
+#[test]
+fn test_decoding_array() {
+	let v = vec![5u16, 2u16];
+	let res = rlp::encode(&v);
+	let arr: [u16; 2] = rlp::decode(&res);
+	assert_eq!(arr[0], 5);
+	assert_eq!(arr[1], 2);
+}
diff --git a/src/rlp/untrusted_rlp.rs b/src/rlp/untrusted_rlp.rs
index ec68fce99..90bfef96c 100644
--- a/src/rlp/untrusted_rlp.rs
+++ b/src/rlp/untrusted_rlp.rs
@@ -352,3 +352,38 @@ impl<T> Decodable for Option<T> where T: Decodable {
 		})
 	}
 }
+
+macro_rules! impl_array_decodable {
+	($index_type:ty, $len:expr ) => (
+		impl<T> Decodable for [T; $len] where T: Decodable {
+			fn decode<D>(decoder: &D) -> Result<Self, DecoderError>  where D: Decoder {
+				decoder.read_list(| decoders | {
+					let mut result: [T; $len] = unsafe { ::std::mem::uninitialized() };
+					if decoders.len() != $len {
+						return Err(DecoderError::RlpIncorrectListLen);
+					}
+					
+					for i in 0..decoders.len() {
+						result[i] = try!(T::decode(&decoders[i]));
+					}
+
+					Ok(result)
+				})
+			}
+		}
+	)
+}
+
+macro_rules! impl_array_decodable_recursive {
+	($index_type:ty, ) => ();
+	($index_type:ty, $len:expr, $($more:expr,)*) => (
+		impl_array_decodable!($index_type, $len);
+		impl_array_decodable_recursive!($index_type, $($more,)*);
+	);
+}
+
+impl_array_decodable_recursive!(
+	u8, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+	16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
+	32, 40, 48, 56, 64, 72, 96, 128, 160, 192, 224,
+);

From 9231bc66221626c387b019659c84e1905e3f4f5a Mon Sep 17 00:00:00 2001
From: debris <marek.kotewicz@gmail.com>
Date: Mon, 14 Dec 2015 12:03:48 +0100
Subject: [PATCH 2/2] read_list -> as_list

---
 src/rlp/traits.rs        |  5 ++---
 src/rlp/untrusted_rlp.rs | 33 +++++++++++++++------------------
 2 files changed, 17 insertions(+), 21 deletions(-)

diff --git a/src/rlp/traits.rs b/src/rlp/traits.rs
index 4f9ad09e5..067c438bf 100644
--- a/src/rlp/traits.rs
+++ b/src/rlp/traits.rs
@@ -1,11 +1,10 @@
 use rlp::DecoderError;
 
-pub trait Decoder {
+pub trait Decoder: Sized {
 	fn read_value<T, F>(&self, f: F) -> Result<T, DecoderError>
 		where F: FnOnce(&[u8]) -> Result<T, DecoderError>;
 
-	fn read_list<T, F>(&self, f: F) -> Result<T, DecoderError>
-		where F: FnOnce(&[Self]) -> Result<T, DecoderError>;
+	fn as_list(&self) -> Result<Vec<Self>, DecoderError>;
 }
 
 pub trait Decodable: Sized {
diff --git a/src/rlp/untrusted_rlp.rs b/src/rlp/untrusted_rlp.rs
index 90bfef96c..a8cecf09f 100644
--- a/src/rlp/untrusted_rlp.rs
+++ b/src/rlp/untrusted_rlp.rs
@@ -305,13 +305,11 @@ impl<'a> Decoder for BasicDecoder<'a> {
 		}
 	}
 
-	fn read_list<T, F>(&self, f: F) -> Result<T, DecoderError>
-		where F: FnOnce(&[Self]) -> Result<T, DecoderError> {
-
+	fn as_list(&self) -> Result<Vec<Self>, DecoderError> {
 		let v: Vec<BasicDecoder<'a>> = self.rlp.iter()
 			.map(| i | BasicDecoder::new(i))
 			.collect();
-		f(&v)
+		Ok(v)
 	}
 }
 
@@ -325,9 +323,8 @@ impl<T> Decodable for T where T: FromBytes {
 
 impl<T> Decodable for Vec<T> where T: Decodable {
 	fn decode<D>(decoder: &D) -> Result<Self, DecoderError>  where D: Decoder {
-		decoder.read_list(| decoders | {
-			decoders.iter().map(|d| T::decode(d)).collect()
-		})
+		let decoders = try!(decoder.as_list());
+		decoders.iter().map(|d| T::decode(d)).collect()
 	}
 }
 
@@ -357,18 +354,18 @@ macro_rules! impl_array_decodable {
 	($index_type:ty, $len:expr ) => (
 		impl<T> Decodable for [T; $len] where T: Decodable {
 			fn decode<D>(decoder: &D) -> Result<Self, DecoderError>  where D: Decoder {
-				decoder.read_list(| decoders | {
-					let mut result: [T; $len] = unsafe { ::std::mem::uninitialized() };
-					if decoders.len() != $len {
-						return Err(DecoderError::RlpIncorrectListLen);
-					}
-					
-					for i in 0..decoders.len() {
-						result[i] = try!(T::decode(&decoders[i]));
-					}
+				let decoders = try!(decoder.as_list());
 
-					Ok(result)
-				})
+				let mut result: [T; $len] = unsafe { ::std::mem::uninitialized() };
+				if decoders.len() != $len {
+					return Err(DecoderError::RlpIncorrectListLen);
+				}
+				
+				for i in 0..decoders.len() {
+					result[i] = try!(T::decode(&decoders[i]));
+				}
+
+				Ok(result)
 			}
 		}
 	)