blop

src/core/serialize.rs

@@ -6,6 +6,8 @@ use std::io::Result;
 use std::io;
 use byteorder;
 
+
+
 fn convert_byte_order_error(byteorder_error: byteorder::Error) -> io::Error {
     match byteorder_error {
         byteorder::Error::UnexpectedEOF => io::Error::new(io::ErrorKind::InvalidData, "Reached EOF unexpectedly"),
@@ -77,7 +79,7 @@ impl BinarySerializable for u64 {
 impl BinarySerializable for u8 {
     fn serialize(&self, writer: &mut Write) -> Result<usize> {
         // TODO error
-        writer.write_u8(self.clone());
+        try!(writer.write_u8(self.clone()).map_err(convert_byte_order_error));
         Ok(1)
     }
     fn deserialize(reader: &mut Read) -> Result<u8> {
@@ -92,7 +94,7 @@ impl BinarySerializable for String {
         let data: &[u8] = self.as_bytes();
         let mut size = try!((data.len() as u32).serialize(writer));
         size += data.len();
-        writer.write_all(data);
+        try!(writer.write_all(data));
         Ok(size)
     }
 

src/core/simdcompression.rs

@@ -105,33 +105,37 @@ impl Decoder {
     }
 }
 
-pub struct Intersector {
-    output_buffer: Vec<u32>,
-}
 
-impl Intersector {
-    fn new() -> Intersector {
-        Intersector::with_capacity(1_000_000)
-    }
-    fn with_capacity(capacity: usize) -> Intersector {
-        Intersector {
-            output_buffer: iter::repeat(0u32).take(capacity).collect()
-        }
-    }
-    fn intersection(&mut self, left: &[u32], right: &[u32]) -> &[u32] {
-        let max_intersection_length = min(left.len(), right.len());
-        if self.output_buffer.len() < max_intersection_length {
-            self.output_buffer.resize(max_intersection_length, 0);
-        }
-        unsafe {
-            let intersection_len = intersection_native(
-                left.as_ptr(), left.len() as size_t,
-                right.as_ptr(), right.len() as size_t,
-                self.output_buffer.as_mut_ptr());
-            return &self.output_buffer[0..intersection_len];
-        }
-    }
-}
+
+
+//
+// pub struct Intersector {
+//     output_buffer: Vec<u32>,
+// }
+//
+// impl Intersector {
+//     fn new() -> Intersector {
+//         Intersector::with_capacity(1_000_000)
+//     }
+//     fn with_capacity(capacity: usize) -> Intersector {
+//         Intersector {
+//             output_buffer: iter::repeat(0u32).take(capacity).collect()
+//         }
+//     }
+//     fn intersection(&mut self, left: &[u32], right: &[u32]) -> &[u32] {
+//         let max_intersection_length = min(left.len(), right.len());
+//         if self.output_buffer.len() < max_intersection_length {
+//             self.output_buffer.resize(max_intersection_length, 0);
+//         }
+//         unsafe {
+//             let intersection_len = intersection_native(
+//                 left.as_ptr(), left.len() as size_t,
+//                 right.as_ptr(), right.len() as size_t,
+//                 self.output_buffer.as_mut_ptr());
+//             return &self.output_buffer[0..intersection_len];
+//         }
+//     }
+// }
 
 
 #[cfg(test)]

src/core/skip.rs

@@ -106,7 +106,7 @@ impl<T: BinarySerializable> SkipListBuilder<T> {
             size += layer.buffer.len() as u32;
             layer_sizes.push(size);
         }
-        layer_sizes.serialize(output);
+        try!(layer_sizes.serialize(output));
         try!(self.data_layer.write(output));
         for layer in self.skip_layers.iter() {
             try!(layer.write(output));
@@ -145,10 +145,13 @@ impl<'a, T: BinarySerializable> Iterator for Layer<'a, T> {
 }
 
 
+
+
 static EMPTY: [u8; 0] = [];
 
 impl<'a, T: BinarySerializable> Layer<'a, T> {
 
+
     fn read(mut cursor: Cursor<&'a [u8]>) -> Layer<'a, T> {
         // TODO error handling?
         let next_id = match cursor.read_u32::<BigEndian>() {
@@ -171,8 +174,8 @@ impl<'a, T: BinarySerializable> Layer<'a, T> {
     }
 
 
-    fn seek_offset(&mut self, offset: usize) {
-        self.cursor.seek(SeekFrom::Start(offset as u64));
+    fn seek_offset(&mut self, offset: usize)  {
+        self.cursor.seek(SeekFrom::Start(offset as u64)).unwrap();
         self.next_id = match self.cursor.read_u32::<BigEndian>() {
             Ok(val) => val,
             Err(_) => u32::max_value(),
@@ -267,6 +270,7 @@ impl<'a, T: BinarySerializable> SkipList<'a, T> {
 
 
 
+
 #[test]
 fn test_skip_list_builder() {
     {

src/core/store.rs

@@ -8,7 +8,6 @@ use core::directory::ReadOnlySource;
 use std::io::Write;
 use std::io::Read;
 use std::io::Cursor;
-use std::io::Error as IOError;
 use std::io;
 use std::io::SeekFrom;
 use std::io::Seek;
@@ -69,32 +68,33 @@ impl StoreWriter {
         }
     }
 
-    fn write_and_compress_block(&mut self,) {
+    fn write_and_compress_block(&mut self,) -> io::Result<()> {
         // err handling
         self.intermediary_buffer.clear();
         {
             let mut encoder = lz4::EncoderBuilder::new()
                     .build(&mut self.intermediary_buffer)
                     .unwrap();
-            encoder.write_all(&self.current_block);
-            encoder.finish();
+            try!(encoder.write_all(&self.current_block));
+            let (_, encoder_result) = encoder.finish();
+            try!(encoder_result);
         }
         let compressed_block_size = self.intermediary_buffer.len() as u64;
-        self.written += (compressed_block_size as u32).serialize(&mut self.writer).unwrap() as u64;
-        self.writer.write_all(&self.intermediary_buffer);
+        self.written += try!((compressed_block_size as u32).serialize(&mut self.writer)) as u64;
+        try!(self.writer.write_all(&self.intermediary_buffer));
         self.written += compressed_block_size;
         self.offsets.push(OffsetIndex(self.doc, self.written));
         self.current_block.clear();
+        Ok(())
     }
 
-    pub fn close(&mut self,) -> Result<(), IOError> {
+    pub fn close(&mut self,) -> io::Result<()> {
         if self.current_block.len() > 0 {
             self.write_and_compress_block();
         }
         let header_offset: u64 = self.written;
-        //let writer_mutref: &mut Write = self.writer.deref_mut();
-        self.offsets.serialize(&mut self.writer);
-        header_offset.serialize(&mut self.writer);
+        try!(self.offsets.serialize(&mut self.writer));
+        try!(header_offset.serialize(&mut self.writer));
         self.writer.flush()
     }
 
@@ -116,9 +116,9 @@ impl StoreReader {
     fn read_header(data: &ReadOnlySource) -> Vec<OffsetIndex> {
         // todo err
         let mut cursor = Cursor::new(data.as_slice());
-        cursor.seek(SeekFrom::End(-8));
+        cursor.seek(SeekFrom::End(-8)).unwrap();
         let offset = u64::deserialize(&mut cursor).unwrap();
-        cursor.seek(SeekFrom::Start(offset));
+        cursor.seek(SeekFrom::Start(offset)).unwrap();
         Vec::deserialize(&mut cursor).unwrap()
     }