From 09e94072baa3fc9fa2bd80cc80a3ae8604a28ec4 Mon Sep 17 00:00:00 2001 From: Paul Masurel Date: Wed, 24 May 2017 10:33:36 +0900 Subject: [PATCH] Cargo fmt --- src/core/searcher.rs | 2 +- src/directory/shared_vec_slice.rs | 2 +- src/termdict/fstdict/mod.rs | 3 - src/termdict/fstdict/streamer.rs | 23 ++-- src/termdict/fstdict/termdict.rs | 24 +++-- src/termdict/merger.rs | 3 +- src/termdict/mod.rs | 94 ++++++++--------- src/termdict/streamdict/counting_writer.rs | 8 +- src/termdict/streamdict/mod.rs | 1 - src/termdict/streamdict/streamer.rs | 67 +++++++----- src/termdict/streamdict/termdict.rs | 117 +++++++++++---------- 11 files changed, 174 insertions(+), 170 deletions(-) diff --git a/src/core/searcher.rs b/src/core/searcher.rs index 6e7078b5f..8f6d36b82 100644 --- a/src/core/searcher.rs +++ b/src/core/searcher.rs @@ -34,7 +34,7 @@ impl Searcher { } /// Returns the overall number of documents in the index. - pub fn num_docs(&self) -> DocId { + pub fn num_docs(&self) -> DocId { self.segment_readers .iter() .map(|segment_reader| segment_reader.num_docs()) diff --git a/src/directory/shared_vec_slice.rs b/src/directory/shared_vec_slice.rs index ab5e04644..289d74721 100644 --- a/src/directory/shared_vec_slice.rs +++ b/src/directory/shared_vec_slice.rs @@ -40,4 +40,4 @@ impl From> for SharedVecSlice { fn from(data: Vec) -> SharedVecSlice { SharedVecSlice::new(Arc::new(data)) } -} \ No newline at end of file +} diff --git a/src/termdict/fstdict/mod.rs b/src/termdict/fstdict/mod.rs index 3f121752f..a244ac2b4 100644 --- a/src/termdict/fstdict/mod.rs +++ b/src/termdict/fstdict/mod.rs @@ -21,6 +21,3 @@ pub use self::termdict::TermDictionaryImpl; pub use self::termdict::TermDictionaryBuilderImpl; pub use self::streamer::TermStreamerImpl; pub use self::streamer::TermStreamerBuilderImpl; - - - diff --git a/src/termdict/fstdict/streamer.rs b/src/termdict/fstdict/streamer.rs index 6cf6e57db..0bfd548bc 100644 --- a/src/termdict/fstdict/streamer.rs +++ b/src/termdict/fstdict/streamer.rs @@ -12,9 +12,9 @@ pub struct TermStreamerBuilderImpl<'a, V> stream_builder: StreamBuilder<'a>, } -impl<'a, V> TermStreamerBuilderImpl<'a, V> - where V: 'a + BinarySerializable + Default { - +impl<'a, V> TermStreamerBuilderImpl<'a, V> + where V: 'a + BinarySerializable + Default +{ pub(crate) fn new(fst_map: &'a TermDictionaryImpl, stream_builder: StreamBuilder<'a>) -> Self { @@ -25,9 +25,9 @@ impl<'a, V> TermStreamerBuilderImpl<'a, V> } } -impl<'a, V> TermStreamerBuilder for TermStreamerBuilderImpl<'a, V> - where V: 'a + BinarySerializable + Default { - +impl<'a, V> TermStreamerBuilder for TermStreamerBuilderImpl<'a, V> + where V: 'a + BinarySerializable + Default +{ type Streamer = TermStreamerImpl<'a, V>; fn ge>(mut self, bound: T) -> Self { @@ -74,16 +74,17 @@ pub struct TermStreamerImpl<'a, V> } impl<'a, V> TermStreamer for TermStreamerImpl<'a, V> - where V: BinarySerializable + Default { - + where V: BinarySerializable + Default +{ fn advance(&mut self) -> bool { if let Some((term, offset)) = self.stream.next() { self.current_key.clear(); self.current_key.extend_from_slice(term); self.offset = offset; - self.current_value = self.fst_map - .read_value(self.offset) - .expect("Fst data is corrupted. Failed to deserialize a value."); + self.current_value = + self.fst_map + .read_value(self.offset) + .expect("Fst data is corrupted. Failed to deserialize a value."); true } else { false diff --git a/src/termdict/fstdict/termdict.rs b/src/termdict/fstdict/termdict.rs index 4a9f3c997..db14075d8 100644 --- a/src/termdict/fstdict/termdict.rs +++ b/src/termdict/fstdict/termdict.rs @@ -14,16 +14,18 @@ fn convert_fst_error(e: fst::Error) -> io::Error { /// See [TermDictionaryBuilder](./trait.TermDictionaryBuilder.html) pub struct TermDictionaryBuilderImpl - where W: Write, V: BinarySerializable + Default + where W: Write, + V: BinarySerializable + Default { fst_builder: fst::MapBuilder, data: Vec, _phantom_: PhantomData, } -impl TermDictionaryBuilderImpl - where W: Write, V: BinarySerializable + Default { - +impl TermDictionaryBuilderImpl + where W: Write, + V: BinarySerializable + Default +{ /// # Warning /// Horribly dangerous internal API /// @@ -45,12 +47,12 @@ impl TermDictionaryBuilderImpl value.serialize(&mut self.data)?; Ok(()) } - } impl TermDictionaryBuilder for TermDictionaryBuilderImpl - where W: Write, V: BinarySerializable + Default { - + where W: Write, + V: BinarySerializable + Default +{ fn new(w: W) -> io::Result { let fst_builder = fst::MapBuilder::new(w).map_err(convert_fst_error)?; Ok(TermDictionaryBuilderImpl { @@ -95,7 +97,7 @@ fn open_fst_index(source: ReadOnlySource) -> io::Result { /// See [TermDictionary](./trait.TermDictionary.html) pub struct TermDictionaryImpl where V: BinarySerializable + Default -{ +{ fst_index: fst::Map, values_mmap: ReadOnlySource, _phantom_: PhantomData, @@ -114,12 +116,12 @@ impl TermDictionaryImpl impl<'a, V> TermDictionary<'a, V> for TermDictionaryImpl - where V: BinarySerializable + Default + 'a { - + where V: BinarySerializable + Default + 'a +{ type Streamer = TermStreamerImpl<'a, V>; type StreamBuilder = TermStreamerBuilderImpl<'a, V>; - + fn from_source(source: ReadOnlySource) -> io::Result { let total_len = source.len(); let length_offset = total_len - 4; diff --git a/src/termdict/merger.rs b/src/termdict/merger.rs index d0c699695..77088cbb0 100644 --- a/src/termdict/merger.rs +++ b/src/termdict/merger.rs @@ -132,8 +132,7 @@ impl<'a, V> TermMerger<'a, V> -impl<'a> From<&'a [SegmentReader]> for TermMerger<'a, TermInfo> -{ +impl<'a> From<&'a [SegmentReader]> for TermMerger<'a, TermInfo> { fn from(segment_readers: &'a [SegmentReader]) -> TermMerger<'a, TermInfo> { TermMerger::new(segment_readers .iter() diff --git a/src/termdict/mod.rs b/src/termdict/mod.rs index 4c0ffc4b3..564b26e6e 100644 --- a/src/termdict/mod.rs +++ b/src/termdict/mod.rs @@ -85,13 +85,15 @@ pub use self::merger::TermMerger; #[cfg(not(feature="streamdict"))] mod fstdict; #[cfg(not(feature="streamdict"))] -pub use self::fstdict::{TermDictionaryImpl, TermDictionaryBuilderImpl, TermStreamerImpl, TermStreamerBuilderImpl}; +pub use self::fstdict::{TermDictionaryImpl, TermDictionaryBuilderImpl, TermStreamerImpl, + TermStreamerBuilderImpl}; #[cfg(feature="streamdict")] mod streamdict; #[cfg(feature="streamdict")] -pub use self::streamdict::{TermDictionaryImpl, TermDictionaryBuilderImpl, TermStreamerImpl, TermStreamerBuilderImpl}; +pub use self::streamdict::{TermDictionaryImpl, TermDictionaryBuilderImpl, TermStreamerImpl, + TermStreamerBuilderImpl}; mod merger; @@ -100,16 +102,17 @@ use std::io; /// Dictionary associating sorted `&[u8]` to values pub trait TermDictionary<'a, V> - where V: BinarySerializable + Default + 'a , Self: Sized { - + where V: BinarySerializable + Default + 'a, + Self: Sized +{ /// Streamer type associated to the term dictionary type Streamer: TermStreamer + 'a; /// StreamerBuilder type associated to the term dictionary - type StreamBuilder: TermStreamerBuilder + 'a; + type StreamBuilder: TermStreamerBuilder + 'a; /// Opens a `TermDictionary` given a data source. - fn from_source(source: ReadOnlySource) -> io::Result; + fn from_source(source: ReadOnlySource) -> io::Result; /// Lookups the value corresponding to the key. fn get>(&self, target_key: K) -> Option; @@ -138,8 +141,9 @@ pub trait TermDictionary<'a, V> /// /// Inserting must be done in the order of the `keys`. pub trait TermDictionaryBuilder: Sized - where W: io::Write, V: BinarySerializable + Default { - + where W: io::Write, + V: BinarySerializable + Default +{ /// Creates a new `TermDictionaryBuilder` fn new(write: W) -> io::Result; @@ -157,7 +161,6 @@ pub trait TermDictionaryBuilder: Sized /// `TermStreamer` acts as a cursor over a range of terms of a segment. /// Terms are guaranteed to be sorted. pub trait TermStreamer: Sized { - /// Advance position the stream on the next item. /// Before the first call to `.advance()`, the stream /// is an unitialized state. @@ -176,10 +179,10 @@ pub trait TermStreamer: Sized { fn key(&self) -> &[u8]; /// Accesses the current value. - /// + /// /// Calling `.value()` after the end of the stream will return the /// last `.value()` encounterred. - /// + /// /// # Panics /// /// Calling `.value()` before the first call to `.advance()` returns @@ -199,8 +202,9 @@ pub trait TermStreamer: Sized { /// `TermStreamerBuilder` is an helper object used to define /// a range of terms that should be streamed. -pub trait TermStreamerBuilder where V: BinarySerializable + Default { - +pub trait TermStreamerBuilder + where V: BinarySerializable + Default +{ /// Associated `TermStreamer` type that this builder is building. type Streamer: TermStreamer; @@ -215,7 +219,7 @@ pub trait TermStreamerBuilder where V: BinarySerializable + Default { /// Limit the range to terms lesser or equal to the bound fn le>(self, bound: T) -> Self; - + /// Creates the stream corresponding to the range /// of terms defined using the `TermStreamerBuilder`. fn into_stream(self) -> Self::Streamer; @@ -235,7 +239,7 @@ mod tests { use termdict::TermDictionary; use termdict::TermDictionaryBuilder; const BLOCK_SIZE: usize = 1_500; - + #[test] fn test_term_dictionary() { @@ -319,14 +323,15 @@ mod tests { .map(|i| (format!("doc{:0>6}", i), i)) .collect(); let buffer: Vec = { - let mut term_dictionary_builder = TermDictionaryBuilderImpl::new(vec!()).unwrap(); + let mut term_dictionary_builder = TermDictionaryBuilderImpl::new(vec![]).unwrap(); for &(ref id, ref i) in &ids { term_dictionary_builder.insert(id.as_bytes(), i).unwrap(); } term_dictionary_builder.finish().unwrap() }; let source = ReadOnlySource::from(buffer); - let term_dictionary: TermDictionaryImpl = TermDictionaryImpl::from_source(source).unwrap(); + let term_dictionary: TermDictionaryImpl = TermDictionaryImpl::from_source(source) + .unwrap(); { let mut streamer = term_dictionary.stream(); let mut i = 0; @@ -337,7 +342,7 @@ mod tests { i += 1; } } - + let &(ref key, ref _v) = &ids[2047]; term_dictionary.get(key.as_bytes()); } @@ -348,7 +353,7 @@ mod tests { .map(|i| (format!("doc{:0>6}", i), i)) .collect(); let buffer: Vec = { - let mut term_dictionary_builder = TermDictionaryBuilderImpl::new(vec!()).unwrap(); + let mut term_dictionary_builder = TermDictionaryBuilderImpl::new(vec![]).unwrap(); for &(ref id, ref i) in &ids { term_dictionary_builder.insert(id.as_bytes(), i).unwrap(); } @@ -356,8 +361,9 @@ mod tests { }; let source = ReadOnlySource::from(buffer); - - let term_dictionary: TermDictionaryImpl = TermDictionaryImpl::from_source(source).unwrap(); + + let term_dictionary: TermDictionaryImpl = TermDictionaryImpl::from_source(source) + .unwrap(); { for i in (0..20).chain(6000..8_000) { let &(ref target_key, _) = &ids[i]; @@ -415,7 +421,7 @@ mod tests { #[test] fn test_stream_range_boundaries() { let buffer: Vec = { - let mut term_dictionary_builder = TermDictionaryBuilderImpl::new(vec!()).unwrap(); + let mut term_dictionary_builder = TermDictionaryBuilderImpl::new(vec![]).unwrap(); for i in 0u8..10u8 { let number_arr = [i; 1]; term_dictionary_builder.insert(&number_arr, &i).unwrap(); @@ -423,50 +429,36 @@ mod tests { term_dictionary_builder.finish().unwrap() }; let source = ReadOnlySource::from(buffer); - let term_dictionary: TermDictionaryImpl = TermDictionaryImpl::from_source(source).unwrap(); - + let term_dictionary: TermDictionaryImpl = TermDictionaryImpl::from_source(source) + .unwrap(); + let value_list = |mut streamer: TermStreamerImpl| { - let mut res: Vec = vec!(); + let mut res: Vec = vec![]; while let Some((_, &v)) = streamer.next() { res.push(v); } res }; { - let range = term_dictionary - .range() - .ge([2u8]) - .into_stream(); - assert_eq!(value_list(range), vec!(2u8, 3u8, 4u8, 5u8, 6u8, 7u8, 8u8, 9u8)); + let range = term_dictionary.range().ge([2u8]).into_stream(); + assert_eq!(value_list(range), + vec![2u8, 3u8, 4u8, 5u8, 6u8, 7u8, 8u8, 9u8]); } { - let range = term_dictionary - .range() - .gt([2u8]) - .into_stream(); - assert_eq!(value_list(range), vec!(3u8, 4u8, 5u8, 6u8, 7u8, 8u8, 9u8)); + let range = term_dictionary.range().gt([2u8]).into_stream(); + assert_eq!(value_list(range), vec![3u8, 4u8, 5u8, 6u8, 7u8, 8u8, 9u8]); } { - let range = term_dictionary - .range() - .lt([6u8]) - .into_stream(); - assert_eq!(value_list(range), vec!(0u8, 1u8, 2u8, 3u8, 4u8, 5u8)); + let range = term_dictionary.range().lt([6u8]).into_stream(); + assert_eq!(value_list(range), vec![0u8, 1u8, 2u8, 3u8, 4u8, 5u8]); } { - let range = term_dictionary - .range() - .le([6u8]) - .into_stream(); - assert_eq!(value_list(range), vec!(0u8, 1u8, 2u8, 3u8, 4u8, 5u8, 6u8)); + let range = term_dictionary.range().le([6u8]).into_stream(); + assert_eq!(value_list(range), vec![0u8, 1u8, 2u8, 3u8, 4u8, 5u8, 6u8]); } { - let range = term_dictionary - .range() - .ge([0u8]) - .lt([5u8]) - .into_stream(); - assert_eq!(value_list(range), vec!(0u8, 1u8, 2u8, 3u8, 4u8)); + let range = term_dictionary.range().ge([0u8]).lt([5u8]).into_stream(); + assert_eq!(value_list(range), vec![0u8, 1u8, 2u8, 3u8, 4u8]); } } diff --git a/src/termdict/streamdict/counting_writer.rs b/src/termdict/streamdict/counting_writer.rs index e2bec7f2a..db13e368f 100644 --- a/src/termdict/streamdict/counting_writer.rs +++ b/src/termdict/streamdict/counting_writer.rs @@ -14,8 +14,8 @@ impl CountingWriter { written_bytes: 0, } } - - pub fn written_bytes(&self,) -> usize { + + pub fn written_bytes(&self) -> usize { self.written_bytes } @@ -47,7 +47,7 @@ mod test { #[test] fn test_counting_writer() { - let buffer: Vec = vec!(); + let buffer: Vec = vec![]; let mut counting_writer = CountingWriter::wrap(buffer); let bytes = (0u8..10u8).collect::>(); counting_writer.write_all(&bytes).unwrap(); @@ -55,4 +55,4 @@ mod test { assert_eq!(len, 10); assert_eq!(w.len(), 10); } -} \ No newline at end of file +} diff --git a/src/termdict/streamdict/mod.rs b/src/termdict/streamdict/mod.rs index c20668455..66c3eb97c 100644 --- a/src/termdict/streamdict/mod.rs +++ b/src/termdict/streamdict/mod.rs @@ -8,4 +8,3 @@ pub use self::termdict::TermDictionaryImpl; pub use self::termdict::TermDictionaryBuilderImpl; pub use self::streamer::TermStreamerImpl; pub use self::streamer::TermStreamerBuilderImpl; - diff --git a/src/termdict/streamdict/streamer.rs b/src/termdict/streamdict/streamer.rs index 50fb5bb9f..d29f91fb8 100644 --- a/src/termdict/streamdict/streamer.rs +++ b/src/termdict/streamdict/streamer.rs @@ -7,8 +7,11 @@ use common::BinarySerializable; use super::TermDictionaryImpl; use termdict::{TermStreamerBuilder, TermStreamer}; -pub(crate) fn stream_before<'a, V>(term_dictionary: &'a TermDictionaryImpl, target_key: &[u8]) -> TermStreamerImpl<'a, V> - where V: 'a + BinarySerializable + Default { +pub(crate) fn stream_before<'a, V>(term_dictionary: &'a TermDictionaryImpl, + target_key: &[u8]) + -> TermStreamerImpl<'a, V> + where V: 'a + BinarySerializable + Default +{ let (prev_key, offset) = term_dictionary.strictly_previous_key(target_key.as_ref()); let offset: usize = offset as usize; TermStreamerImpl { @@ -20,7 +23,8 @@ pub(crate) fn stream_before<'a, V>(term_dictionary: &'a TermDictionaryImpl, t /// See [TermStreamerBuilder](./trait.TermStreamerBuilder.html) pub struct TermStreamerBuilderImpl<'a, V> - where V: 'a + BinarySerializable + Default { + where V: 'a + BinarySerializable + Default +{ term_dictionary: &'a TermDictionaryImpl, origin: usize, offset_from: usize, @@ -28,16 +32,16 @@ pub struct TermStreamerBuilderImpl<'a, V> current_key: Vec, } -impl<'a, V> TermStreamerBuilder for TermStreamerBuilderImpl<'a, V> - where V: 'a + BinarySerializable + Default { - +impl<'a, V> TermStreamerBuilder for TermStreamerBuilderImpl<'a, V> + where V: 'a + BinarySerializable + Default +{ type Streamer = TermStreamerImpl<'a, V>; /// Limit the range to terms greater or equal to the bound fn ge>(mut self, bound: T) -> Self { let target_key = bound.as_ref(); let streamer = stream_before(&self.term_dictionary, target_key.as_ref()); - let smaller_than = |k: &[u8]| { k.lt(target_key) }; + let smaller_than = |k: &[u8]| k.lt(target_key); let (offset_before, current_key) = get_offset(smaller_than, streamer); self.current_key = current_key; self.offset_from = offset_before - self.origin; @@ -48,7 +52,7 @@ impl<'a, V> TermStreamerBuilder for TermStreamerBuilderImpl<'a, V> fn gt>(mut self, bound: T) -> Self { let target_key = bound.as_ref(); let streamer = stream_before(self.term_dictionary, target_key.as_ref()); - let smaller_than = |k: &[u8]| { k.le(target_key) }; + let smaller_than = |k: &[u8]| k.le(target_key); let (offset_before, current_key) = get_offset(smaller_than, streamer); self.current_key = current_key; self.offset_from = offset_before - self.origin; @@ -59,7 +63,7 @@ impl<'a, V> TermStreamerBuilder for TermStreamerBuilderImpl<'a, V> fn lt>(mut self, bound: T) -> Self { let target_key = bound.as_ref(); let streamer = stream_before(self.term_dictionary, target_key.as_ref()); - let smaller_than = |k: &[u8]| { k.lt(target_key) }; + let smaller_than = |k: &[u8]| k.lt(target_key); let (offset_before, _) = get_offset(smaller_than, streamer); self.offset_to = offset_before - self.origin; self @@ -69,7 +73,7 @@ impl<'a, V> TermStreamerBuilder for TermStreamerBuilderImpl<'a, V> fn le>(mut self, bound: T) -> Self { let target_key = bound.as_ref(); let streamer = stream_before(self.term_dictionary, target_key.as_ref()); - let smaller_than = |k: &[u8]| { k.le(target_key) }; + let smaller_than = |k: &[u8]| k.le(target_key); let (offset_before, _) = get_offset(smaller_than, streamer); self.offset_to = offset_before - self.origin; self @@ -88,16 +92,19 @@ impl<'a, V> TermStreamerBuilder for TermStreamerBuilderImpl<'a, V> } } -/// Returns offset information for the first +/// Returns offset information for the first /// key in the stream matching a given predicate. /// /// returns (start offset, the data required to load the value) -fn get_offset<'a, V, P: Fn(&[u8])->bool>(predicate: P, mut streamer: TermStreamerImpl) -> (usize, Vec) - where V: 'a + BinarySerializable + Default { +fn get_offset<'a, V, P: Fn(&[u8]) -> bool>(predicate: P, + mut streamer: TermStreamerImpl) + -> (usize, Vec) + where V: 'a + BinarySerializable + Default +{ let mut prev: &[u8] = streamer.cursor; - + let mut prev_data: Vec = streamer.current_key.clone(); - + while let Some((iter_key, _)) = streamer.next() { if !predicate(iter_key) { return (prev.as_ptr() as usize, prev_data); @@ -110,9 +117,8 @@ fn get_offset<'a, V, P: Fn(&[u8])->bool>(predicate: P, mut streamer: TermStreame } impl<'a, V> TermStreamerBuilderImpl<'a, V> - where V: 'a + BinarySerializable + Default { - - + where V: 'a + BinarySerializable + Default +{ pub(crate) fn new(term_dictionary: &'a TermDictionaryImpl) -> Self { let data = term_dictionary.stream_data(); let origin = data.as_ptr() as usize; @@ -121,43 +127,46 @@ impl<'a, V> TermStreamerBuilderImpl<'a, V> origin: origin, offset_from: 0, offset_to: data.len(), - current_key: vec!(), + current_key: vec![], } } } /// See [TermStreamer](./trait.TermStreamer.html) pub struct TermStreamerImpl<'a, V> - where V: 'a + BinarySerializable + Default { + where V: 'a + BinarySerializable + Default +{ cursor: &'a [u8], current_key: Vec, current_value: V, } -impl<'a, V: BinarySerializable> TermStreamerImpl<'a, V> - where V: 'a + BinarySerializable + Default { - - +impl<'a, V: BinarySerializable> TermStreamerImpl<'a, V> + where V: 'a + BinarySerializable + Default +{ pub(crate) fn extract_value(self) -> V { self.current_value } } impl<'a, V> TermStreamer for TermStreamerImpl<'a, V> - where V: BinarySerializable + Default { - + where V: BinarySerializable + Default +{ fn advance(&mut self) -> bool { if self.cursor.len() == 0 { return false; } let common_length: usize = VInt::deserialize(&mut self.cursor).unwrap().0 as usize; - let new_length: usize = common_length + VInt::deserialize(&mut self.cursor).unwrap().0 as usize; + let new_length: usize = common_length + + VInt::deserialize(&mut self.cursor).unwrap().0 as usize; self.current_key.reserve(new_length); unsafe { self.current_key.set_len(new_length); } - self.cursor.read_exact(&mut self.current_key[common_length..new_length]).unwrap(); + self.cursor + .read_exact(&mut self.current_key[common_length..new_length]) + .unwrap(); self.current_value = V::deserialize(&mut self.cursor).unwrap(); return true; } @@ -169,4 +178,4 @@ impl<'a, V> TermStreamer for TermStreamerImpl<'a, V> fn value(&self) -> &V { &self.current_value } -} \ No newline at end of file +} diff --git a/src/termdict/streamdict/termdict.rs b/src/termdict/streamdict/termdict.rs index 150765f88..55a5063de 100644 --- a/src/termdict/streamdict/termdict.rs +++ b/src/termdict/streamdict/termdict.rs @@ -22,8 +22,10 @@ fn convert_fst_error(e: fst::Error) -> io::Error { } /// See [TermDictionaryBuilder](./trait.TermDictionaryBuilder.html) -pub struct TermDictionaryBuilderImpl - where W: Write, V: BinarySerializable + Default { +pub struct TermDictionaryBuilderImpl + where W: Write, + V: BinarySerializable + Default +{ write: CountingWriter, block_index: fst::MapBuilder>, last_key: Vec, @@ -32,7 +34,8 @@ pub struct TermDictionaryBuilderImpl } fn common_prefix_length(left: &[u8], right: &[u8]) -> usize { - left.iter().cloned() + left.iter() + .cloned() .zip(right.iter().cloned()) .take_while(|&(b1, b2)| b1 == b2) .count() @@ -43,18 +46,20 @@ fn fill_last<'a>(fst: &'a Fst, mut node: Node<'a>, buffer: &mut Vec) { if let Some(transition) = node.transitions().last() { buffer.push(transition.inp); node = fst.node(transition.addr); - } - else { + } else { break; } } } impl TermDictionaryBuilderImpl - where W: Write, V: BinarySerializable + Default { - + where W: Write, + V: BinarySerializable + Default +{ fn add_index_entry(&mut self) { - self.block_index.insert(&self.last_key, self.write.written_bytes() as u64).unwrap(); + self.block_index + .insert(&self.last_key, self.write.written_bytes() as u64) + .unwrap(); } /// # Warning @@ -64,7 +69,7 @@ impl TermDictionaryBuilderImpl /// to insert_key and insert_value. /// /// Prefer using `.insert(key, value)` - pub(crate) fn insert_key(&mut self, key: &[u8]) -> io::Result<()>{ + pub(crate) fn insert_key(&mut self, key: &[u8]) -> io::Result<()> { if self.len % BLOCK_SIZE == 0 { self.add_index_entry(); } @@ -73,37 +78,38 @@ impl TermDictionaryBuilderImpl VInt(common_len as u64).serialize(&mut self.write)?; self.last_key.truncate(common_len); self.last_key.extend_from_slice(&key[common_len..]); - VInt((key.len() - common_len) as u64).serialize(&mut self.write)?; + VInt((key.len() - common_len) as u64) + .serialize(&mut self.write)?; self.write.write_all(&key[common_len..])?; Ok(()) } - pub(crate) fn insert_value(&mut self, value: &V) -> io::Result<()>{ + pub(crate) fn insert_value(&mut self, value: &V) -> io::Result<()> { value.serialize(&mut self.write)?; Ok(()) } } impl TermDictionaryBuilder for TermDictionaryBuilderImpl - where W: Write, V: BinarySerializable + Default { - + where W: Write, + V: BinarySerializable + Default +{ /// Creates a new `TermDictionaryBuilder` fn new(write: W) -> io::Result { - let buffer: Vec = vec!(); + let buffer: Vec = vec![]; Ok(TermDictionaryBuilderImpl { - write: CountingWriter::wrap(write), - block_index: fst::MapBuilder::new(buffer) - .expect("This cannot fail"), - last_key: Vec::with_capacity(128), - len: 0, - _phantom_: PhantomData, - }) + write: CountingWriter::wrap(write), + block_index: fst::MapBuilder::new(buffer).expect("This cannot fail"), + last_key: Vec::with_capacity(128), + len: 0, + _phantom_: PhantomData, + }) } /// Inserts a `(key, value)` pair in the term dictionary. /// /// *Keys have to be inserted in order.* - fn insert>(&mut self, key_ref: K, value: &V) -> io::Result<()>{ + fn insert>(&mut self, key_ref: K, value: &V) -> io::Result<()> { let key = key_ref.as_ref(); self.insert_key(key)?; self.insert_value(value) @@ -114,9 +120,7 @@ impl TermDictionaryBuilder for TermDictionaryBuilderImpl fn finish(mut self) -> io::Result { self.add_index_entry(); let (mut w, split_len) = self.write.finish()?; - let fst_write = self.block_index - .into_inner() - .map_err(convert_fst_error)?; + let fst_write = self.block_index.into_inner().map_err(convert_fst_error)?; w.write(&fst_write)?; (split_len as u64).serialize(&mut w)?; w.flush()?; @@ -127,44 +131,49 @@ impl TermDictionaryBuilder for TermDictionaryBuilderImpl fn open_fst_index(source: ReadOnlySource) -> io::Result { Ok(fst::Map::from(match source { - ReadOnlySource::Anonymous(data) => try!(Fst::from_shared_bytes(data.data, data.start, data.len).map_err(convert_fst_error)), - ReadOnlySource::Mmap(mmap_readonly) => try!(Fst::from_mmap(mmap_readonly).map_err(convert_fst_error)), - })) + ReadOnlySource::Anonymous(data) => { + try!(Fst::from_shared_bytes(data.data, data.start, data.len) + .map_err(convert_fst_error)) + } + ReadOnlySource::Mmap(mmap_readonly) => { + try!(Fst::from_mmap(mmap_readonly).map_err(convert_fst_error)) + } + })) } /// See [TermDictionary](./trait.TermDictionary.html) -pub struct TermDictionaryImpl where V: BinarySerializable + Default { +pub struct TermDictionaryImpl + where V: BinarySerializable + Default +{ stream_data: ReadOnlySource, fst_index: fst::Map, _phantom_: PhantomData, } impl TermDictionaryImpl - where V: BinarySerializable + Default { - + where V: BinarySerializable + Default +{ pub(crate) fn stream_data(&self) -> &[u8] { self.stream_data.as_slice() } pub(crate) fn strictly_previous_key(&self, key: &[u8]) -> (Vec, u64) { - let fst_map = &self.fst_index; + let fst_map = &self.fst_index; let fst = fst_map.as_fst(); let mut node = fst.root(); - let mut node_stack: Vec = vec!(node.clone()); + let mut node_stack: Vec = vec![node.clone()]; // first check the longest prefix. for &b in &key[..key.len() - 1] { node = match node.find_input(b) { None => { break; - }, - Some(i) => { - fst.node(node.transition_addr(i)) - }, + } + Some(i) => fst.node(node.transition_addr(i)), }; node_stack.push(node); } - + let len_node_stack = node_stack.len(); for i in (1..len_node_stack).rev() { let cur_node = &node_stack[i]; @@ -173,7 +182,7 @@ impl TermDictionaryImpl .transitions() .take_while(|transition| transition.inp < b) .last(); - + if let Some(last_transition) = last_transition_opt { let mut result_buffer = Vec::from(&key[..i]); result_buffer.push(last_transition.inp); @@ -183,8 +192,7 @@ impl TermDictionaryImpl fill_last(fst, fork_node, &mut result); let val = fst_map.get(&result).unwrap(); return (result, val); - } - else if cur_node.is_final() { + } else if cur_node.is_final() { // the previous key is a prefix let result_buffer = Vec::from(&key[..i]); let val = fst_map.get(&result_buffer).unwrap(); @@ -192,36 +200,35 @@ impl TermDictionaryImpl } } - return (vec!(), 0); + return (vec![], 0); } - } impl<'a, V> TermDictionary<'a, V> for TermDictionaryImpl - where V: BinarySerializable + Default + 'a { - + where V: BinarySerializable + Default + 'a +{ type Streamer = TermStreamerImpl<'a, V>; type StreamBuilder = TermStreamerBuilderImpl<'a, V>; /// Opens a `TermDictionary` given a data source. - fn from_source(source: ReadOnlySource) -> io::Result { + fn from_source(source: ReadOnlySource) -> io::Result { let total_len = source.len(); let length_offset = total_len - 8; let split_len: usize = { let mut split_len_buffer: &[u8] = &source.as_slice()[length_offset..]; - u64::deserialize(&mut split_len_buffer)? as usize + u64::deserialize(&mut split_len_buffer)? as usize }; let stream_data = source.slice(0, split_len); let fst_data = source.slice(split_len, length_offset); let fst_index = open_fst_index(fst_data)?; - + Ok(TermDictionaryImpl { - stream_data: stream_data, - fst_index: fst_index, - _phantom_: PhantomData - }) + stream_data: stream_data, + fst_index: fst_index, + _phantom_: PhantomData, + }) } /// Lookups the value corresponding to the key. @@ -231,9 +238,7 @@ impl<'a, V> TermDictionary<'a, V> for TermDictionaryImpl let position = streamer.key().cmp(target_key.as_ref()); match position { Ordering::Less => {} - Ordering::Equal => { - return Some(streamer.extract_value()) - } + Ordering::Equal => return Some(streamer.extract_value()), Ordering::Greater => { return None; } @@ -247,4 +252,4 @@ impl<'a, V> TermDictionary<'a, V> for TermDictionaryImpl fn range(&'a self) -> Self::StreamBuilder { Self::StreamBuilder::new(self) } -} \ No newline at end of file +}