Skip to content

Commit

Permalink
issue38 Slightly cleaner code.
Browse files Browse the repository at this point in the history
  • Loading branch information
@fulmicoton
fulmicoton committed Oct 24, 2016
1 parent 5b3a5ce commit e537163
Show file tree
Hide file tree
Showing 4 changed files with 46 additions and 60 deletions.
14 changes: 7 additions & 7 deletions src/datastruct/skip/mod.rs
View file
Expand Up @@ -19,7 +19,7 @@ mod tests {
let mut skip_list_builder: SkipListBuilder<u32> = SkipListBuilder::new(10);
skip_list_builder.insert(2, &3).unwrap();
skip_list_builder.write::<Vec<u8>>(&mut output).unwrap();
let mut skip_list: SkipList<u32> = SkipList::read(&mut output);
let mut skip_list: SkipList<u32> = SkipList::from(output.as_slice());
assert_eq!(skip_list.next(), Some((2, 3)));
}

Expand All @@ -28,7 +28,7 @@ mod tests {
let mut output: Vec<u8> = Vec::new();
let skip_list_builder: SkipListBuilder<u32> = SkipListBuilder::new(10);
skip_list_builder.write::<Vec<u8>>(&mut output).unwrap();
let mut skip_list: SkipList<u32> = SkipList::read(&mut output);
let mut skip_list: SkipList<u32> = SkipList::from(output.as_slice());
assert_eq!(skip_list.next(), None);
}

Expand All @@ -42,7 +42,7 @@ mod tests {
skip_list_builder.insert(7, &()).unwrap();
skip_list_builder.insert(9, &()).unwrap();
skip_list_builder.write::<Vec<u8>>(&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, ()));
Expand All @@ -61,7 +61,7 @@ mod tests {
skip_list_builder.insert(7, &()).unwrap();
skip_list_builder.insert(9, &()).unwrap();
skip_list_builder.write::<Vec<u8>>(&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, ()));
Expand All @@ -79,7 +79,7 @@ mod tests {
skip_list_builder.insert(5, &()).unwrap();
skip_list_builder.insert(6, &()).unwrap();
skip_list_builder.write::<Vec<u8>>(&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, ()));
Expand All @@ -96,7 +96,7 @@ mod tests {
skip_list_builder.insert(7, &()).unwrap();
skip_list_builder.insert(9, &()).unwrap();
skip_list_builder.write::<Vec<u8>>(&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);
Expand All @@ -111,7 +111,7 @@ mod tests {
}
skip_list_builder.insert(1004, &()).unwrap();
skip_list_builder.write::<Vec<u8>>(&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,()) );
Expand Down
72 changes: 31 additions & 41 deletions src/datastruct/skip/skiplist.rs
View file
@@ -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<T>,
}
Expand All @@ -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)
//
Expand Down Expand Up @@ -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);
}
Expand All @@ -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<u32> = 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<u32> = 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,
}
}

}
18 changes: 7 additions & 11 deletions src/datastruct/skip/skiplist_builder.rs
View file
Expand Up @@ -37,17 +37,13 @@ impl<T: BinarySerializable> LayerBuilder<T> {
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 })
}
}

Expand Down Expand Up @@ -97,13 +93,13 @@ impl<T: BinarySerializable> SkipListBuilder<T> {
let mut layer_sizes: Vec<u32> = 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(())
Expand Down
2 changes: 1 addition & 1 deletion src/store/reader.rs
View file
Expand Up @@ -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))
}
Expand Down

0 comments on commit e537163

Please sign in to comment.