Remove trait constraits from Parcel

Author: dylanmckay

src/parcel.rs

@@ -1,8 +1,8 @@
 use std::io::prelude::*;
-use std::{fmt, io};
+use std::io;
 
 /// A value which can be read and written.
-pub trait Parcel : Clone + fmt::Debug + PartialEq
+pub trait Parcel : Sized + PartialEq
 {
     /// Reads a value from a stream.
     fn read(read: &mut Read) -> Result<Self, ::Error>;

src/primitives/array.rs

@@ -3,9 +3,6 @@ use {primitives, Parcel, Error};
 use std::io::prelude::*;
 use std;
 
-/// The integer type that we will use to send length prefixes.
-pub type SizeType = u32;
-
 /// An dynamic array type with a custom size prefix type.
 #[derive(Clone, Debug, PartialEq)]
 pub struct DynArray<S: primitives::Integer, T: Parcel>
@@ -24,26 +21,12 @@ impl<S: primitives::Integer, T: Parcel> DynArray<S,T>
 impl<S: primitives::Integer, T: Parcel> Parcel for DynArray<S, T>
 {
     fn read(read: &mut Read) -> Result<Self, Error> {
-        let size = S::read(read)?;
-        let size: usize = size.try_into()?;
-
-        let mut elements = Vec::new();
-
-        for _ in 0..size {
-            elements.push(T::read(read)?);
-        }
-
+        let elements = primitives::util::read_list_ext::<S,T>(read)?;
         Ok(Self::new(elements))
     }
 
     fn write(&self, write: &mut Write) -> Result<(), Error> {
-        S::try_from(self.elements.len())?.write(write)?;
-
-        for element in self.elements.iter() {
-            element.write(write)?;
-        }
-
-        Ok(())
+        primitives::util::write_list_ext::<S,T,_>(write, self.elements.iter())
     }
 }
 
@@ -113,11 +96,11 @@ impl_parcel_for_array!(32);
 impl<T: Parcel> Parcel for Vec<T>
 {
     fn read(read: &mut Read) -> Result<Self, Error> {
-        Ok(DynArray::<SizeType, T>::read(read)?.elements)
+        primitives::util::read_list(read)
     }
 
     fn write(&self, write: &mut Write) -> Result<(), Error> {
-        DynArray::<SizeType, T>::new(self.clone()).write(write)
+        primitives::util::write_list(write, self.iter())
     }
 }
 

src/primitives/collections/list.rs

@@ -4,14 +4,13 @@ macro_rules! impl_list_type {
             where T: $crate::Parcel $( + $ty_pred )*
         {
             fn read(read: &mut ::std::io::Read) -> Result<Self, $crate::Error> {
-                let elements: Vec<T> = Vec::read(read)?;
+                let elements = ::primitives::util::read_list(read)?;
                 Ok(elements.into_iter().collect())
             }
 
-            fn write(&self, write: &mut ::std::io::Write) -> Result<(), $crate::Error> {
-                let elements: Vec<_> = self.iter().cloned().collect();
-                elements.write(write)?;
-                Ok(())
+            fn write(&self, write: &mut ::std::io::Write)
+                -> Result<(), $crate::Error> {
+                ::primitives::util::write_list(write, self.iter())
             }
         }
 

src/primitives/mod.rs

@@ -17,3 +17,5 @@ pub mod smart_ptr;
 #[cfg(feature = "uuid")]
 pub mod uuid;
 
+mod util;
+

src/primitives/util.rs

@@ -0,0 +1,54 @@
+use {Parcel, Error};
+use primitives::Integer;
+
+use std::io::prelude::*;
+
+/// The integer type that we will use to send length prefixes.
+pub type SizeType = u32;
+
+/// Reads a length-prefixed list from a stream.
+pub fn read_list<T>(read: &mut Read)
+    -> Result<Vec<T>, Error>
+    where T: Parcel {
+    self::read_list_ext::<SizeType, T>(read)
+}
+
+/// Writes a length-prefixed list to a stream.
+pub fn write_list<'a,T,I>(write: &mut Write, elements: I)
+    -> Result<(), Error>
+    where T: Parcel+'a,
+          I: IntoIterator<Item=&'a T> {
+    self::write_list_ext::<SizeType, T, I>(write, elements)
+}
+
+pub fn read_list_ext<S,T>(read: &mut Read)
+    -> Result<Vec<T>, Error>
+    where S: Integer,
+          T: Parcel {
+    let size = S::read(read)?;
+    let size: usize = size.try_into()?;
+    let mut elements = Vec::with_capacity(size);
+
+    for _ in 0..size {
+        let element = T::read(read)?;
+        elements.push(element);
+    }
+    Ok(elements)
+}
+
+pub fn write_list_ext<'a,S,T,I>(write: &mut Write, elements: I)
+    -> Result<(), Error>
+    where S: Integer,
+          T: Parcel+'a,
+          I: IntoIterator<Item=&'a T> {
+    let elements: Vec<_> = elements.into_iter().collect();
+    let length = S::try_from(elements.len())?;
+    length.write(write)?;
+
+    for element in elements.into_iter() {
+        element.write(write)?;
+    }
+
+    Ok(())
+}
+