From c29de9eb90d76cea2da597389b3147f2f6785626 Mon Sep 17 00:00:00 2001 From: Paul Masurel Date: Mon, 7 Mar 2016 09:57:08 +0900 Subject: [PATCH] blop --- src/core/serialize.rs | 6 ++-- src/core/simdcompression.rs | 56 ++++++++++++++++++++----------------- src/core/skip.rs | 10 +++++-- src/core/store.rs | 24 ++++++++-------- 4 files changed, 53 insertions(+), 43 deletions(-) diff --git a/src/core/serialize.rs b/src/core/serialize.rs index 57952cd8c..f349976ea 100644 --- a/src/core/serialize.rs +++ b/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 { // 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 { @@ -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) } diff --git a/src/core/simdcompression.rs b/src/core/simdcompression.rs index 785ca835c..fefa80ed9 100644 --- a/src/core/simdcompression.rs +++ b/src/core/simdcompression.rs @@ -105,33 +105,37 @@ impl Decoder { } } -pub struct Intersector { - output_buffer: Vec, -} -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, +// } +// +// 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)] diff --git a/src/core/skip.rs b/src/core/skip.rs index c9eca81f4..f8cbdb45e 100644 --- a/src/core/skip.rs +++ b/src/core/skip.rs @@ -106,7 +106,7 @@ impl SkipListBuilder { 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::() { @@ -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::() { Ok(val) => val, Err(_) => u32::max_value(), @@ -267,6 +270,7 @@ impl<'a, T: BinarySerializable> SkipList<'a, T> { + #[test] fn test_skip_list_builder() { { diff --git a/src/core/store.rs b/src/core/store.rs index 14d1ace6a..4ccfb1483 100644 --- a/src/core/store.rs +++ b/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 { // 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() }