From 1d5464351ddc6dcdd41e815c36d8779ed1ed60de Mon Sep 17 00:00:00 2001
From: Paul Masurel <paul.masurel@gmail.com>
Date: Tue, 30 May 2017 16:03:09 +0900
Subject: [PATCH] generic read

---
 src/common/serialize.rs   | 18 +++++++++---------
 src/common/vint.rs        |  2 +-
 src/postings/term_info.rs |  2 +-
 src/schema/field.rs       |  2 +-
 src/schema/field_value.rs |  2 +-
 src/schema/value.rs       |  2 +-
 6 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/src/common/serialize.rs b/src/common/serialize.rs
index 471ac3a9c..ffd6982aa 100644
--- a/src/common/serialize.rs
+++ b/src/common/serialize.rs
@@ -8,14 +8,14 @@ use common::VInt;
 
 pub trait BinarySerializable: fmt::Debug + Sized {
     fn serialize(&self, writer: &mut Write) -> io::Result<usize>;
-    fn deserialize(reader: &mut Read) -> io::Result<Self>;
+    fn deserialize<R: Read>(reader: &mut R) -> io::Result<Self>;
 }
 
 impl BinarySerializable for () {
     fn serialize(&self, _: &mut Write) -> io::Result<usize> {
         Ok(0)
     }
-    fn deserialize(_: &mut Read) -> io::Result<Self> {
+    fn deserialize<R: Read>(_: &mut R) -> io::Result<Self> {
         Ok(())
     }
 }
@@ -28,7 +28,7 @@ impl<T: BinarySerializable> BinarySerializable for Vec<T> {
         }
         Ok(total_size)
     }
-    fn deserialize(reader: &mut Read) -> io::Result<Vec<T>> {
+    fn deserialize<R: Read>(reader: &mut R) -> io::Result<Vec<T>> {
         let num_items = try!(VInt::deserialize(reader)).val();
         let mut items: Vec<T> = Vec::with_capacity(num_items as usize);
         for _ in 0..num_items {
@@ -44,7 +44,7 @@ impl<Left: BinarySerializable, Right: BinarySerializable> BinarySerializable for
     fn serialize(&self, write: &mut Write) -> io::Result<usize> {
         Ok(try!(self.0.serialize(write)) + try!(self.1.serialize(write)))
     }
-    fn deserialize(reader: &mut Read) -> io::Result<Self> {
+    fn deserialize<R: Read>(reader: &mut R) -> io::Result<Self> {
         Ok((try!(Left::deserialize(reader)), try!(Right::deserialize(reader))))
     }
 }
@@ -54,7 +54,7 @@ impl BinarySerializable for u32 {
         writer.write_u32::<Endianness>(*self).map(|_| 4)
     }
 
-    fn deserialize(reader: &mut Read) -> io::Result<u32> {
+    fn deserialize<R: Read>(reader: &mut R) -> io::Result<u32> {
         reader.read_u32::<Endianness>()
     }
 }
@@ -64,7 +64,7 @@ impl BinarySerializable for u64 {
     fn serialize(&self, writer: &mut Write) -> io::Result<usize> {
         writer.write_u64::<Endianness>(*self).map(|_| 8)
     }
-    fn deserialize(reader: &mut Read) -> io::Result<u64> {
+    fn deserialize<R: Read>(reader: &mut R) -> io::Result<u64> {
         reader.read_u64::<Endianness>()
     }
 }
@@ -73,7 +73,7 @@ impl BinarySerializable for i64 {
     fn serialize(&self, writer: &mut Write) -> io::Result<usize> {
         writer.write_i64::<Endianness>(*self).map(|_| 8)
     }
-    fn deserialize(reader: &mut Read) -> io::Result<i64> {
+    fn deserialize<R: Read>(reader: &mut R) -> io::Result<i64> {
         reader.read_i64::<Endianness>()
     }
 }
@@ -84,7 +84,7 @@ impl BinarySerializable for u8 {
         try!(writer.write_u8(*self));
         Ok(1)
     }
-    fn deserialize(reader: &mut Read) -> io::Result<u8> {
+    fn deserialize<R: Read>(reader: &mut R) -> io::Result<u8> {
         reader.read_u8()
     }
 }
@@ -98,7 +98,7 @@ impl BinarySerializable for String {
         Ok(size)
     }
 
-    fn deserialize(reader: &mut Read) -> io::Result<String> {
+    fn deserialize<R: Read>(reader: &mut R) -> io::Result<String> {
         let string_length = try!(VInt::deserialize(reader)).val() as usize;
         let mut result = String::with_capacity(string_length);
         try!(reader
diff --git a/src/common/vint.rs b/src/common/vint.rs
index 0563d8f8e..3201b8541 100644
--- a/src/common/vint.rs
+++ b/src/common/vint.rs
@@ -36,7 +36,7 @@ impl BinarySerializable for VInt {
         Ok(written)
     }
 
-    fn deserialize(reader: &mut Read) -> io::Result<Self> {
+    fn deserialize<R: Read>(reader: &mut R) -> io::Result<Self> {
         let mut bytes = reader.bytes();
         let mut result = 0u64;
         let mut shift = 0u64;
diff --git a/src/postings/term_info.rs b/src/postings/term_info.rs
index fbcf9e05a..90d9d02f4 100644
--- a/src/postings/term_info.rs
+++ b/src/postings/term_info.rs
@@ -28,7 +28,7 @@ impl BinarySerializable for TermInfo {
         Ok(try!(self.doc_freq.serialize(writer)) + try!(self.postings_offset.serialize(writer)) +
            try!(self.positions_offset.serialize(writer)))
     }
-    fn deserialize(reader: &mut io::Read) -> io::Result<Self> {
+    fn deserialize<R: io::Read>(reader: &mut R) -> io::Result<Self> {
         let doc_freq = try!(u32::deserialize(reader));
         let postings_offset = try!(u32::deserialize(reader));
         let positions_offset = try!(u32::deserialize(reader));
diff --git a/src/schema/field.rs b/src/schema/field.rs
index d73a66b34..e5489adf6 100644
--- a/src/schema/field.rs
+++ b/src/schema/field.rs
@@ -18,7 +18,7 @@ impl BinarySerializable for Field {
         self.0.serialize(writer)
     }
 
-    fn deserialize(reader: &mut Read) -> io::Result<Field> {
+    fn deserialize<R: Read>(reader: &mut R) -> io::Result<Field> {
         u32::deserialize(reader).map(Field)
     }
 }
diff --git a/src/schema/field_value.rs b/src/schema/field_value.rs
index 8202cc5ca..b6cd5469b 100644
--- a/src/schema/field_value.rs
+++ b/src/schema/field_value.rs
@@ -38,7 +38,7 @@ impl BinarySerializable for FieldValue {
         Ok(self.field.serialize(writer)? + self.value.serialize(writer)?)
     }
 
-    fn deserialize(reader: &mut Read) -> io::Result<Self> {
+    fn deserialize<R: Read>(reader: &mut R) -> io::Result<Self> {
         let field = Field::deserialize(reader)?;
         let value = Value::deserialize(reader)?;
         Ok(FieldValue::new(field, value))
diff --git a/src/schema/value.rs b/src/schema/value.rs
index 8e5ee4153..139e23f13 100644
--- a/src/schema/value.rs
+++ b/src/schema/value.rs
@@ -148,7 +148,7 @@ mod binary_serialize {
             }
             Ok(written_size)
         }
-        fn deserialize(reader: &mut Read) -> io::Result<Self> {
+        fn deserialize<R: Read>(reader: &mut R) -> io::Result<Self> {
             let type_code = try!(u8::deserialize(reader));
             match type_code {
                 TEXT_CODE => {