From e537163b2a7886af278dc0ed41fe4000b157456a Mon Sep 17 00:00:00 2001 From: Paul Masurel Date: Mon, 24 Oct 2016 22:14:28 +0900 Subject: [PATCH] issue38 Slightly cleaner code. --- src/datastruct/skip/mod.rs | 14 ++--- src/datastruct/skip/skiplist.rs | 72 +++++++++++-------------- src/datastruct/skip/skiplist_builder.rs | 18 +++---- src/store/reader.rs | 2 +- 4 files changed, 46 insertions(+), 60 deletions(-) diff --git a/src/datastruct/skip/mod.rs b/src/datastruct/skip/mod.rs index 1aa47c9a63..9c27b62830 100644 --- a/src/datastruct/skip/mod.rs +++ b/src/datastruct/skip/mod.rs @@ -19,7 +19,7 @@ mod tests { let mut skip_list_builder: SkipListBuilder = SkipListBuilder::new(10); skip_list_builder.insert(2, &3).unwrap(); skip_list_builder.write::>(&mut output).unwrap(); - let mut skip_list: SkipList = SkipList::read(&mut output); + let mut skip_list: SkipList = SkipList::from(output.as_slice()); assert_eq!(skip_list.next(), Some((2, 3))); } @@ -28,7 +28,7 @@ mod tests { let mut output: Vec = Vec::new(); let skip_list_builder: SkipListBuilder = SkipListBuilder::new(10); skip_list_builder.write::>(&mut output).unwrap(); - let mut skip_list: SkipList = SkipList::read(&mut output); + let mut skip_list: SkipList = SkipList::from(output.as_slice()); assert_eq!(skip_list.next(), None); } @@ -42,7 +42,7 @@ mod tests { skip_list_builder.insert(7, &()).unwrap(); skip_list_builder.insert(9, &()).unwrap(); skip_list_builder.write::>(&mut output).unwrap(); - let mut skip_list: SkipList<()> = SkipList::read(&mut output); + let mut skip_list: SkipList<()> = SkipList::from(output.as_slice()); assert_eq!(skip_list.next().unwrap(), (2, ())); assert_eq!(skip_list.next().unwrap(), (3, ())); assert_eq!(skip_list.next().unwrap(), (5, ())); @@ -61,7 +61,7 @@ mod tests { skip_list_builder.insert(7, &()).unwrap(); skip_list_builder.insert(9, &()).unwrap(); skip_list_builder.write::>(&mut output).unwrap(); - let mut skip_list: SkipList<()> = SkipList::read(&mut output); + let mut skip_list: SkipList<()> = SkipList::from(output.as_slice()); assert_eq!(skip_list.next().unwrap(), (2, ())); skip_list.seek(5); assert_eq!(skip_list.next().unwrap(), (5, ())); @@ -79,7 +79,7 @@ mod tests { skip_list_builder.insert(5, &()).unwrap(); skip_list_builder.insert(6, &()).unwrap(); skip_list_builder.write::>(&mut output).unwrap(); - let mut skip_list: SkipList<()> = SkipList::read(&mut output); + let mut skip_list: SkipList<()> = SkipList::from(output.as_slice()); assert_eq!(skip_list.next().unwrap(), (2, ())); skip_list.seek(6); assert_eq!(skip_list.next().unwrap(), (6, ())); @@ -96,7 +96,7 @@ mod tests { skip_list_builder.insert(7, &()).unwrap(); skip_list_builder.insert(9, &()).unwrap(); skip_list_builder.write::>(&mut output).unwrap(); - let mut skip_list: SkipList<()> = SkipList::read(&mut output); + let mut skip_list: SkipList<()> = SkipList::from(output.as_slice()); assert_eq!(skip_list.next().unwrap(), (2, ())); skip_list.seek(10); assert_eq!(skip_list.next(), None); @@ -111,7 +111,7 @@ mod tests { } skip_list_builder.insert(1004, &()).unwrap(); skip_list_builder.write::>(&mut output).unwrap(); - let mut skip_list: SkipList<()> = SkipList::read(&mut output); + let mut skip_list: SkipList<()> = SkipList::from(output.as_slice()); assert_eq!(skip_list.next().unwrap(), (0, ())); skip_list.seek(431); assert_eq!(skip_list.next().unwrap(), (431,()) ); diff --git a/src/datastruct/skip/skiplist.rs b/src/datastruct/skip/skiplist.rs index a34dede890..62b394cea2 100644 --- a/src/datastruct/skip/skiplist.rs +++ b/src/datastruct/skip/skiplist.rs @@ -1,13 +1,12 @@ use common::BinarySerializable; -use std::io::Cursor; -use std::io::SeekFrom; -use std::io::Seek; use std::marker::PhantomData; use DocId; +static EMPTY: [u8; 0] = []; struct Layer<'a, T> { - cursor: Cursor<&'a [u8]>, + data: &'a [u8], + cursor: &'a [u8], next_id: DocId, _phantom_: PhantomData, } @@ -23,51 +22,41 @@ impl<'a, T: BinarySerializable> Iterator for Layer<'a, T> { else { let cur_val = T::deserialize(&mut self.cursor).unwrap(); let cur_id = self.next_id; - self.next_id = - match u32::deserialize(&mut self.cursor) { - Ok(val) => val, - Err(_) => u32::max_value() - }; + self.next_id = u32::deserialize(&mut self.cursor).unwrap_or(u32::max_value()); Some((cur_id, cur_val)) } } } - -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 u32::deserialize(&mut cursor) { - Ok(val) => val, - Err(_) => u32::max_value(), - }; +impl<'a, T: BinarySerializable> From<&'a [u8]> for Layer<'a, T> { + fn from(data: &'a [u8]) -> Layer<'a, T> { + let mut cursor = data; + let next_id = u32::deserialize(&mut cursor).unwrap_or(u32::max_value()); Layer { + data: data, cursor: cursor, next_id: next_id, _phantom_: PhantomData, } } +} + +impl<'a, T: BinarySerializable> Layer<'a, T> { fn empty() -> Layer<'a, T> { Layer { - cursor: Cursor::new(&EMPTY), + data: &EMPTY, + cursor: &EMPTY, next_id: DocId::max_value(), _phantom_: PhantomData, } } - fn seek_offset(&mut self, offset: usize) { - self.cursor.seek(SeekFrom::Start(offset as u64)).unwrap(); - self.next_id = match u32::deserialize(&mut self.cursor) { - Ok(val) => val, - Err(_) => u32::max_value(), - }; + self.cursor = &self.data[offset..]; + self.next_id = u32::deserialize(&mut self.cursor).unwrap_or(u32::max_value()); } - + // Returns the last element (key, val) // such that (key < doc_id) // @@ -104,8 +93,7 @@ impl<'a, T: BinarySerializable> SkipList<'a, T> { pub fn seek(&mut self, doc_id: DocId) -> Option<(DocId, T)> { let mut next_layer_skip: Option<(DocId, u32)> = None; - for skip_layer_id in 0..self.skip_layers.len() { - let mut skip_layer: &mut Layer<'a, u32> = &mut self.skip_layers[skip_layer_id]; + for skip_layer in &mut self.skip_layers { if let Some((_, offset)) = next_layer_skip { skip_layer.seek_offset(offset as usize); } @@ -117,37 +105,39 @@ impl<'a, T: BinarySerializable> SkipList<'a, T> { self.data_layer.seek(doc_id) } - pub fn read(data: &'a [u8]) -> SkipList<'a, T> { - let mut cursor = Cursor::new(data); - let offsets: Vec = Vec::deserialize(&mut cursor).unwrap(); + +} + + +impl<'a, T: BinarySerializable> From<&'a [u8]> for SkipList<'a, T> { + + fn from(mut data: &'a [u8]) -> SkipList<'a, T> { + let offsets: Vec = Vec::deserialize(&mut data).unwrap(); let num_layers = offsets.len(); - let start_position = cursor.position() as usize; - let layers_data: &[u8] = &data[start_position..data.len()]; + let layers_data: &[u8] = data; let data_layer: Layer<'a, T> = if num_layers == 0 { Layer::empty() } else { let first_layer_data: &[u8] = &layers_data[..offsets[0] as usize]; - let first_layer_cursor = Cursor::new(first_layer_data); - Layer::read(first_layer_cursor) + Layer::from(first_layer_data) }; - let mut skip_layers = + let skip_layers = if num_layers > 0 { offsets.iter() .zip(&offsets[1..]) .map(|(start, stop)| { let layer_data: &[u8] = &layers_data[*start as usize..*stop as usize]; - let cursor = Cursor::new(layer_data); - Layer::read(cursor) + Layer::from(layer_data) }) .collect() } else { Vec::new() }; - skip_layers.reverse(); SkipList { skip_layers: skip_layers, data_layer: data_layer, } } + } diff --git a/src/datastruct/skip/skiplist_builder.rs b/src/datastruct/skip/skiplist_builder.rs index e12444f110..b834060294 100644 --- a/src/datastruct/skip/skiplist_builder.rs +++ b/src/datastruct/skip/skiplist_builder.rs @@ -37,17 +37,13 @@ impl LayerBuilder { self.remaining -= 1; self.len += 1; let offset = self.written_size() as u32; // TODO not sure if we want after or here - let res = - if self.remaining == 0 { - self.remaining = self.period; - Some((doc_id, offset)) - } - else { - None - }; try!(doc_id.serialize(&mut self.buffer)); try!(value.serialize(&mut self.buffer)); - Ok(res) + Ok(if self.remaining == 0 { + self.remaining = self.period; + Some((doc_id, offset)) + } + else { None }) } } @@ -97,13 +93,13 @@ impl SkipListBuilder { let mut layer_sizes: Vec = Vec::new(); size += self.data_layer.buffer.len() as u32; layer_sizes.push(size); - for layer in &self.skip_layers { + for layer in self.skip_layers.iter().rev() { size += layer.buffer.len() as u32; layer_sizes.push(size); } try!(layer_sizes.serialize(output)); try!(self.data_layer.write(output)); - for layer in &self.skip_layers { + for layer in self.skip_layers.iter().rev() { try!(layer.write(output)); } Ok(()) diff --git a/src/store/reader.rs b/src/store/reader.rs index af522959f8..c8969bbb77 100644 --- a/src/store/reader.rs +++ b/src/store/reader.rs @@ -20,7 +20,7 @@ pub struct StoreReader { impl StoreReader { fn block_offset(&self, doc_id: DocId) -> (DocId, u64) { - SkipList::read(self.offset_index_source.as_slice()) + SkipList::from(self.offset_index_source.as_slice()) .seek(doc_id) .unwrap_or((0u32, 0u64)) }