issue/181 BinarySerializable does not return the len + Generics over Read+Write

1 files changed, 6 insertions, 11 deletions

diff --git a/src/common/bitpacker.rs b/src/common/bitpacker.rs
index b259bd3..f625e07 100644
--- a/src/common/bitpacker.rs
+++ b/src/common/bitpacker.rs
@@ -37,7 +37,6 @@ pub struct BitPacker {
     mini_buffer: u64,
     mini_buffer_written: usize,
     num_bits: usize,
-    written_size: usize,
 }
 
 impl BitPacker {
@@ -46,7 +45,6 @@ impl BitPacker {
             mini_buffer: 0u64,
             mini_buffer_written: 0,
             num_bits: num_bits,
-            written_size: 0,
         }
     }
 
@@ -54,14 +52,14 @@ impl BitPacker {
         let val_u64 = val as u64;
         if self.mini_buffer_written + self.num_bits > 64 {
             self.mini_buffer |= val_u64.wrapping_shl(self.mini_buffer_written as u32);
-            self.written_size += self.mini_buffer.serialize(output)?;
+            self.mini_buffer.serialize(output)?;
             self.mini_buffer = val_u64.wrapping_shr((64 - self.mini_buffer_written) as u32);
             self.mini_buffer_written = self.mini_buffer_written + (self.num_bits as usize) - 64;
         } else {
             self.mini_buffer |= val_u64 << self.mini_buffer_written;
             self.mini_buffer_written += self.num_bits;
             if self.mini_buffer_written == 64 {
-                self.written_size += self.mini_buffer.serialize(output)?;
+                self.mini_buffer.serialize(output)?;
                 self.mini_buffer_written = 0;
                 self.mini_buffer = 0u64;
             }
@@ -74,18 +72,16 @@ impl BitPacker {
             let num_bytes = (self.mini_buffer_written + 7) / 8;
             let arr: [u8; 8] = unsafe { mem::transmute::<u64, [u8; 8]>(self.mini_buffer) };
             output.write_all(&arr[..num_bytes])?;
-            self.written_size += num_bytes;
             self.mini_buffer_written = 0;
         }
         Ok(())
     }
 
-    pub fn close<TWrite: Write>(&mut self, output: &mut TWrite) -> io::Result<usize> {
+    pub fn close<TWrite: Write>(&mut self, output: &mut TWrite) -> io::Result<()> {
         self.flush(output)?;
         // Padding the write file to simplify reads.
         output.write_all(&[0u8; 7])?;
-        self.written_size += 7;
-        Ok(self.written_size)
+        Ok(())
     }
 }
 
@@ -163,9 +159,8 @@ mod test {
         for &val in &vals {
             bitpacker.write(val, &mut data).unwrap();
         }
-        let num_bytes = bitpacker.close(&mut data).unwrap();
-        assert_eq!(num_bytes, (num_bits * len + 7) / 8 + 7);
-        assert_eq!(data.len(), num_bytes);
+        bitpacker.close(&mut data).unwrap();
+        assert_eq!(data.len(), (num_bits * len + 7) / 8 + 7);
         let bitunpacker = BitUnpacker::new(data, num_bits);
         for (i, val) in vals.iter().enumerate() {
             assert_eq!(bitunpacker.get(i), *val);