Various changes. Need to cherrypick some of them and put them into master

Conflicts:
	src/analyzer/mod.rs
	src/schema/index_record_option.rs
	src/tokenizer/lower_caser.rs
	src/tokenizer/tokenizer.rs

.travis.yml

@@ -26,8 +26,7 @@ script:
   - |
     travis-cargo build &&
     travis-cargo test &&
-    travis-cargo bench &&
-    travis-cargo doc
+    travis-cargo bench
   - cargo run --example simple_search
 after_success:
   - bash ./script/build-doc.sh

CHANGELOG.md

@@ -1,3 +1,22 @@
+
+Tantivy 0.4.3
+==========================
+
+- Bugfix race condition when deleting files. (#198)
+
+
+Tantivy 0.4.2
+==========================
+
+- Prevent usage of AVX2 instructions (#201)
+
+
+Tantivy 0.4.1
+==========================
+
+- Bugfix for non-indexed fields. (#199)
+
+
 Tantivy 0.4.0
 ==========================
 

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tantivy"
-version = "0.4.0"
+version = "0.5.0-dev"
 authors = ["Paul Masurel <paul.masurel@gmail.com>"]
 build = "build.rs"
 license = "MIT"
@@ -16,6 +16,7 @@ keywords = ["search", "information", "retrieval"]
 byteorder = "1.0"
 memmap = "0.4"
 lazy_static = "0.2.1"
+tinysegmenter = "0.1.0"
 regex = "0.2"
 fst = "0.1.37"
 atomicwrites = "0.1.3"
@@ -36,12 +37,13 @@ time = "0.1"
 uuid = { version = "0.5", features = ["v4", "serde"] }
 chan = "0.1"
 version = "2"
-crossbeam = "0.2"
+crossbeam = "0.3"
 futures = "0.1"
 futures-cpupool = "0.1"
 error-chain = "0.8"
 owning_ref = "0.3"
 stable_deref_trait = "1.0.0"
+rust-stemmers = "0.1.0"
 
 [target.'cfg(windows)'.dependencies]
 winapi = "0.2"
@@ -51,7 +53,7 @@ rand = "0.3"
 env_logger = "0.4"
 
 [build-dependencies]
-gcc = {version = "0.3", optional=true}
+cc = {version = "1.0.0", optional=true}
 
 [profile.release]
 opt-level = 3
@@ -62,7 +64,7 @@ debug-assertions = false
 
 [features]
 default = ["simdcompression"]
-simdcompression = ["libc", "gcc"]
+simdcompression = ["libc", "cc"]
 streamdict = []
 
 

README.md

@@ -38,12 +38,10 @@ It will walk you through getting a wikipedia search engine up and running in a f
     - [For the last released version](https://docs.rs/tantivy/)
     - [For the last master branch](https://tantivy-search.github.io/tantivy/tantivy/index.html)
 
-# Compiling 
+# Compiling
 
 Tantivy requires Rust Nightly because it uses requires the features [`box_syntax`](https://doc.rust-lang.org/stable/book/box-syntax-and-patterns.html), [`optin_builtin_traits`](https://github.com/rust-lang/rfcs/blob/master/text/0019-opt-in-builtin-traits.md), and [`conservative_impl_trait`](https://github.com/rust-lang/rfcs/blob/master/text/1522-conservative-impl-trait.md).
-By default, `tantivy` uses a git submodule called `simdcomp`.
-After cloning the repository, you will need to initialize and update
-the submodules. The project can then be built using `cargo`.
+The project can then be built using `cargo`.
 
     git clone git@github.com:tantivy-search/tantivy.git
     cd tantivy
@@ -54,9 +52,9 @@ Alternatively, if you are trying to compile `tantivy` without simd compression,
 you can disable this functionality. In this case, this submodule is not required
 and you can compile tantivy by using the `--no-default-features` flag.
 
-    cargo build --no-default-features 
+    cargo build --no-default-features
 
 
 # Contribute
 
-Send me an email (paul.masurel at gmail.com) if you want to contribute to tantivy. 
+Send me an email (paul.masurel at gmail.com) if you want to contribute to tantivy.

build.rs

@@ -1,9 +1,9 @@
 #[cfg(feature = "simdcompression")]
 mod build {
-    extern crate gcc;
+    extern crate cc;
 
     pub fn build() {
-        let mut config = gcc::Config::new();
+        let mut config = cc::Build::new();
         config
             .include("./cpp/simdcomp/include")
             .file("cpp/simdcomp/src/avxbitpacking.c")

examples/html/simple_search.html

@@ -30,10 +30,12 @@
               
             </div>
             
-            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">extern</span> <span class="hljs-keyword">crate</span> rustc_serialize;
-<span class="hljs-keyword">extern</span> <span class="hljs-keyword">crate</span> tantivy;
+            <div class="content"><div class='highlight'><pre><span class="hljs-keyword">extern</span> <span class="hljs-keyword">crate</span> tantivy;
 <span class="hljs-keyword">extern</span> <span class="hljs-keyword">crate</span> tempdir;
 
+<span class="hljs-meta">#[macro_use]</span>
+<span class="hljs-keyword">extern</span> <span class="hljs-keyword">crate</span> serde_json;
+
 <span class="hljs-keyword">use</span> std::path::Path;
 <span class="hljs-keyword">use</span> tempdir::TempDir;
 <span class="hljs-keyword">use</span> tantivy::Index;
@@ -108,8 +110,8 @@ be indexed”.</p>
                 <a class="pilcrow" href="#section-5">&#182;</a>
               </div>
               <p>Our first field is title.
-We want full-text search for it, and we want to be able
-to retrieve the document after the search.</p>
+We want full-text search for it, and we also want 
+to be able to retrieve the document after the search.</p>
 <p>TEXT | STORED is some syntactic sugar to describe
 that.</p>
 <p><code>TEXT</code> means the field should be tokenized and indexed,
@@ -132,9 +134,12 @@ documents that were selected during the search phase.</p>
               <div class="pilwrap ">
                 <a class="pilcrow" href="#section-6">&#182;</a>
               </div>
-              <p>Our first field is body.
-We want full-text search for it, and we want to be able
-to retrieve the body after the search.</p>
+              <p>Our second field is body.
+We want full-text search for it, but we do not 
+need to be able to be able to retrieve it
+for our application. </p>
+<p>We can make our index lighter and 
+by omitting <code>STORED</code> flag.</p>
 
             </div>
             
@@ -158,7 +163,7 @@ with our schema in the directory.</p>
 
             </div>
             
-            <div class="content"><div class='highlight'><pre>    <span class="hljs-keyword">let</span> index = <span class="hljs-built_in">try!</span>(Index::create(index_path, schema.clone()));</pre></div></div>
+            <div class="content"><div class='highlight'><pre>    <span class="hljs-keyword">let</span> index = Index::create(index_path, schema.clone())?;</pre></div></div>
             
         </li>
         
@@ -178,7 +183,7 @@ heap for the indexer can increase its throughput.</p>
 
             </div>
             
-            <div class="content"><div class='highlight'><pre>    <span class="hljs-keyword">let</span> <span class="hljs-keyword">mut</span> index_writer = <span class="hljs-built_in">try!</span>(index.writer(<span class="hljs-number">50_000_000</span>));</pre></div></div>
+            <div class="content"><div class='highlight'><pre>    <span class="hljs-keyword">let</span> <span class="hljs-keyword">mut</span> index_writer = index.writer(<span class="hljs-number">50_000_000</span>)?;</pre></div></div>
             
         </li>
         
@@ -214,9 +219,11 @@ one by one in a Document object.</p>
 
     <span class="hljs-keyword">let</span> <span class="hljs-keyword">mut</span> old_man_doc = Document::<span class="hljs-keyword">default</span>();
     old_man_doc.add_text(title, <span class="hljs-string">"The Old Man and the Sea"</span>);
-    old_man_doc.add_text(body,
-                         <span class="hljs-string">"He was an old man who fished alone in a skiff in the Gulf Stream and \
-                          he had gone eighty-four days now without taking a fish."</span>);</pre></div></div>
+    old_man_doc.add_text(
+        body,
+        <span class="hljs-string">"He was an old man who fished alone in a skiff in the Gulf Stream and \
+                          he had gone eighty-four days now without taking a fish."</span>,
+    );</pre></div></div>
             
         </li>
         
@@ -243,16 +250,25 @@ one by one in a Document object.</p>
                 <a class="pilcrow" href="#section-12">&#182;</a>
               </div>
               <h3 id="create-a-document-directly-from-json-">Create a document directly from json.</h3>
-<p>Alternatively, we can use our schema to parse
-a document object directly from json.</p>
+<p>Alternatively, we can use our schema to parse a
+document object directly from json.
+The document is a string, but we use the <code>json</code> macro
+from <code>serde_json</code> for the convenience of multi-line support.</p>
 
             </div>
             
-            <div class="content"><div class='highlight'><pre>
-    <span class="hljs-keyword">let</span> mice_and_men_doc = <span class="hljs-built_in">try!</span>(schema.parse_document(r#<span class="hljs-string">"{
-       "</span>title<span class="hljs-string">": "</span>Of Mice and Men<span class="hljs-string">",
-       "</span>body<span class="hljs-string">": "</span>few miles south of Soledad, the Salinas River drops <span class="hljs-keyword">in</span> close to the hillside bank and runs deep and green. The water is warm too, <span class="hljs-keyword">for</span> it has slipped twinkling over the yellow sands <span class="hljs-keyword">in</span> the sunlight before reaching the narrow pool. On one side of the river the golden foothill slopes curve up to the strong and rocky Gabilan Mountains, but on the valley side the water is lined with trees—willows fresh and green with every spring, carrying <span class="hljs-keyword">in</span> their lower leaf junctures the debris of the winter’s flooding; and sycamores with mottled, white,recumbent limbs and branches that arch over the pool<span class="hljs-string">"  
-    }"</span>#));
+            <div class="content"><div class='highlight'><pre>    <span class="hljs-keyword">let</span> json = json!({
+       <span class="hljs-string">"title"</span>: <span class="hljs-string">"Of Mice and Men"</span>,
+       <span class="hljs-string">"body"</span>: <span class="hljs-string">"A few miles south of Soledad, the Salinas River drops in close to the hillside \
+                bank and runs deep and green. The water is warm too, for it has slipped twinkling \
+                over the yellow sands in the sunlight before reaching the narrow pool. On one \
+                side of the river the golden foothill slopes curve up to the strong and rocky \
+                Gabilan Mountains, but on the valley side the water is lined with trees—willows \
+                fresh and green with every spring, carrying in their lower leaf junctures the \
+                debris of the winter’s flooding; and sycamores with mottled, white, recumbent \
+                limbs and branches that arch over the pool"</span>
+    });
+    <span class="hljs-keyword">let</span> mice_and_men_doc = schema.parse_document(&amp;json.to_string())?;
 
     index_writer.add_document(mice_and_men_doc);</pre></div></div>
             
@@ -271,10 +287,15 @@ The following document has two titles.</p>
 
             </div>
             
-            <div class="content"><div class='highlight'><pre>    <span class="hljs-keyword">let</span> frankenstein_doc = <span class="hljs-built_in">try!</span>(schema.parse_document(r#<span class="hljs-string">"{
-       "</span>title<span class="hljs-string">": ["</span>Frankenstein<span class="hljs-string">", "</span>The Modern Promotheus<span class="hljs-string">"],
-       "</span>body<span class="hljs-string">": "</span>You will rejoice to hear that no disaster has accompanied the commencement of an enterprise which you have regarded with such evil forebodings.  I arrived here yesterday, and my first task is to assure my dear sister of my welfare and increasing confidence <span class="hljs-keyword">in</span> the success of my undertaking.<span class="hljs-string">"  
-    }"</span>#));
+            <div class="content"><div class='highlight'><pre>    <span class="hljs-keyword">let</span> json = json!({
+       <span class="hljs-string">"title"</span>: [<span class="hljs-string">"Frankenstein"</span>, <span class="hljs-string">"The Modern Prometheus"</span>],
+       <span class="hljs-string">"body"</span>: <span class="hljs-string">"You will rejoice to hear that no disaster has accompanied the commencement of an \
+                enterprise which you have regarded with such evil forebodings.  I arrived here \
+                yesterday, and my first task is to assure my dear sister of my welfare and \
+                increasing confidence in the success of my undertaking."</span>
+    });
+    <span class="hljs-keyword">let</span> frankenstein_doc = schema.parse_document(&amp;json.to_string())?;
+
     index_writer.add_document(frankenstein_doc);</pre></div></div>
             
         </li>
@@ -313,7 +334,7 @@ the existence of new documents.</p>
 
             </div>
             
-            <div class="content"><div class='highlight'><pre>    <span class="hljs-built_in">try!</span>(index_writer.commit());</pre></div></div>
+            <div class="content"><div class='highlight'><pre>    index_writer.commit()?;</pre></div></div>
             
         </li>
         
@@ -349,7 +370,7 @@ after every commit().</p>
 
             </div>
             
-            <div class="content"><div class='highlight'><pre>    <span class="hljs-built_in">try!</span>(index.load_searchers());</pre></div></div>
+            <div class="content"><div class='highlight'><pre>    index.load_searchers()?;</pre></div></div>
             
         </li>
         
@@ -384,7 +405,7 @@ in both title and body.</p>
 
             </div>
             
-            <div class="content"><div class='highlight'><pre>    <span class="hljs-keyword">let</span> query_parser = QueryParser::new(index.schema(), <span class="hljs-built_in">vec!</span>[title, body]);</pre></div></div>
+            <div class="content"><div class='highlight'><pre>    <span class="hljs-keyword">let</span> <span class="hljs-keyword">mut</span> query_parser = QueryParser::for_index(index, <span class="hljs-built_in">vec!</span>[title, body]);</pre></div></div>
             
         </li>
         
@@ -401,7 +422,7 @@ A ticket has been opened regarding this problem.</p>
 
             </div>
             
-            <div class="content"><div class='highlight'><pre>    <span class="hljs-keyword">let</span> query = <span class="hljs-built_in">try!</span>(query_parser.parse_query(<span class="hljs-string">"sea whale"</span>));</pre></div></div>
+            <div class="content"><div class='highlight'><pre>    <span class="hljs-keyword">let</span> query = query_parser.parse_query(<span class="hljs-string">"sea whale"</span>)?;</pre></div></div>
             
         </li>
         
@@ -451,7 +472,7 @@ is the role of the TopCollector.</p>
 
             </div>
             
-            <div class="content"><div class='highlight'><pre>    <span class="hljs-built_in">try!</span>(searcher.search(&amp;*query, &amp;<span class="hljs-keyword">mut</span> top_collector));</pre></div></div>
+            <div class="content"><div class='highlight'><pre>    searcher.search(&amp;*query, &amp;<span class="hljs-keyword">mut</span> top_collector)?;</pre></div></div>
             
         </li>
         
@@ -488,9 +509,27 @@ a title.</p>
             
             <div class="content"><div class='highlight'><pre>
     <span class="hljs-keyword">for</span> doc_address <span class="hljs-keyword">in</span> doc_addresses {
-        <span class="hljs-keyword">let</span> retrieved_doc = <span class="hljs-built_in">try!</span>(searcher.doc(&amp;doc_address));
+        <span class="hljs-keyword">let</span> retrieved_doc = searcher.doc(&amp;doc_address)?;
         <span class="hljs-built_in">println!</span>(<span class="hljs-string">"{}"</span>, schema.to_json(&amp;retrieved_doc));
-    }
+    }</pre></div></div>
+            
+        </li>
+        
+        
+        <li id="section-26">
+            <div class="annotation">
+              
+              <div class="pilwrap ">
+                <a class="pilcrow" href="#section-26">&#182;</a>
+              </div>
+              <p>Wait for indexing and merging threads to shut down.
+Usually this isn’t needed, but in <code>main</code> we try to
+delete the temporary directory and that fails on
+Windows if the files are still open.</p>
+
+            </div>
+            
+            <div class="content"><div class='highlight'><pre>    index_writer.wait_merging_threads()?;
 
     <span class="hljs-literal">Ok</span>(())
 }</pre></div></div>

examples/simple_search.rs

@@ -36,8 +36,8 @@ fn run_example(index_path: &Path) -> tantivy::Result<()> {
     let mut schema_builder = SchemaBuilder::default();
 
     // Our first field is title.
-    // We want full-text search for it, and we want to be able
-    // to retrieve the document after the search.
+    // We want full-text search for it, and we also want
+    // to be able to retrieve the document after the search.
     //
     // TEXT | STORED is some syntactic sugar to describe
     // that.
@@ -51,9 +51,13 @@ fn run_example(index_path: &Path) -> tantivy::Result<()> {
     // documents that were selected during the search phase.
     schema_builder.add_text_field("title", TEXT | STORED);
 
-    // Our first field is body.
-    // We want full-text search for it, and we want to be able
-    // to retrieve the body after the search.
+    // Our second field is body.
+    // We want full-text search for it, but we do not
+    // need to be able to be able to retrieve it
+    // for our application.
+    //
+    // We can make our index lighter and
+    // by omitting `STORED` flag.
     schema_builder.add_text_field("body", TEXT);
 
     let schema = schema_builder.build();
@@ -91,9 +95,11 @@ fn run_example(index_path: &Path) -> tantivy::Result<()> {
 
     let mut old_man_doc = Document::default();
     old_man_doc.add_text(title, "The Old Man and the Sea");
-    old_man_doc.add_text(body,
-                         "He was an old man who fished alone in a skiff in the Gulf Stream and \
-                          he had gone eighty-four days now without taking a fish.");
+    old_man_doc.add_text(
+        body,
+        "He was an old man who fished alone in a skiff in the Gulf Stream and \
+                          he had gone eighty-four days now without taking a fish.",
+    );
 
     // ... and add it to the `IndexWriter`.
     index_writer.add_document(old_man_doc);
@@ -179,7 +185,7 @@ fn run_example(index_path: &Path) -> tantivy::Result<()> {
     // Here, if the user does not specify which
     // field they want to search, tantivy will search
     // in both title and body.
-    let query_parser = QueryParser::new(index.schema(), vec![title, body]);
+    let query_parser = QueryParser::for_index(&index, vec![title, body]);
 
     // QueryParser may fail if the query is not in the right
     // format. For user facing applications, this can be a problem.

src/analyzer/mod.rs

@@ -1,84 +0,0 @@
-extern crate regex;
-
-use std::str::Chars;
-use std::ascii::AsciiExt;
-
-pub struct TokenIter<'a> {
-    chars: Chars<'a>,
-    term_buffer: String,
-}
-
-fn append_char_lowercase(c: char, term_buffer: &mut String) {
-    term_buffer.push(c.to_ascii_lowercase());
-}
-
-pub trait StreamingIterator<'a, T> {
-    fn next(&'a mut self) -> Option<T>;
-}
-
-impl<'a, 'b> TokenIter<'b> {
-    fn consume_token(&'a mut self) -> Option<&'a str> {
-        for c in &mut self.chars {
-            if c.is_alphanumeric() {
-                append_char_lowercase(c, &mut self.term_buffer);
-            } else {
-                break;
-            }
-        }
-        Some(&self.term_buffer)
-    }
-}
-
-
-impl<'a, 'b> StreamingIterator<'a, &'a str> for TokenIter<'b> {
-    #[inline]
-    fn next(&'a mut self) -> Option<&'a str> {
-        self.term_buffer.clear();
-        // skipping non-letter characters.
-        loop {
-            match self.chars.next() {
-                Some(c) => {
-                    if c.is_alphanumeric() {
-                        append_char_lowercase(c, &mut self.term_buffer);
-                        return self.consume_token();
-                    }
-                }
-                None => {
-                    return None;
-                }
-            }
-        }
-    }
-}
-
-pub struct SimpleTokenizer;
-
-
-impl SimpleTokenizer {
-    pub fn tokenize<'a>(&self, text: &'a str) -> TokenIter<'a> {
-        TokenIter {
-            term_buffer: String::new(),
-            chars: text.chars(),
-        }
-    }
-}
-
-
-#[test]
-fn test_tokenizer() {
-    let simple_tokenizer = SimpleTokenizer;
-    let mut term_reader = simple_tokenizer.tokenize("hello, happy tax payer!");
-    assert_eq!(term_reader.next().unwrap(), "hello");
-    assert_eq!(term_reader.next().unwrap(), "happy");
-    assert_eq!(term_reader.next().unwrap(), "tax");
-    assert_eq!(term_reader.next().unwrap(), "payer");
-    assert_eq!(term_reader.next(), None);
-}
-
-
-#[test]
-fn test_tokenizer_empty() {
-    let simple_tokenizer = SimpleTokenizer;
-    let mut term_reader = simple_tokenizer.tokenize("");
-    assert_eq!(term_reader.next(), None);
-}

src/collector/chained_collector.rs

@@ -5,7 +5,6 @@ use SegmentReader;
 use DocId;
 use Score;
 
-
 /// Collector that does nothing.
 /// This is used in the chain Collector and will hopefully
 /// be optimized away by the compiler.
@@ -38,10 +37,11 @@ impl<Left: Collector, Right: Collector> ChainedCollector<Left, Right> {
 }
 
 impl<Left: Collector, Right: Collector> Collector for ChainedCollector<Left, Right> {
-    fn set_segment(&mut self,
-                   segment_local_id: SegmentLocalId,
-                   segment: &SegmentReader)
-                   -> Result<()> {
+    fn set_segment(
+        &mut self,
+        segment_local_id: SegmentLocalId,
+        segment: &SegmentReader,
+    ) -> Result<()> {
         try!(self.left.set_segment(segment_local_id, segment));
         try!(self.right.set_segment(segment_local_id, segment));
         Ok(())
@@ -61,7 +61,6 @@ pub fn chain() -> ChainedCollector<DoNothingCollector, DoNothingCollector> {
     }
 }
 
-
 #[cfg(test)]
 mod tests {
 

src/collector/count_collector.rs

@@ -45,11 +45,11 @@ mod tests {
     #[bench]
     fn build_collector(b: &mut Bencher) {
         b.iter(|| {
-                   let mut count_collector = CountCollector::default();
-                   for doc in 0..1_000_000 {
-                       count_collector.collect(doc, 1f32);
-                   }
-                   count_collector.count()
-               });
+            let mut count_collector = CountCollector::default();
+            for doc in 0..1_000_000 {
+                count_collector.collect(doc, 1f32);
+            }
+            count_collector.count()
+        });
     }
 }

src/collector/facet_collector.rs

@@ -12,21 +12,21 @@ use Score;
 use SegmentReader;
 use SegmentLocalId;
 
-
 /// Facet collector  for i64/u64 fast field
 pub struct FacetCollector<T>
-    where T: FastFieldReader,
-          T::ValueType: Eq + Hash
+where
+    T: FastFieldReader,
+    T::ValueType: Eq + Hash,
 {
     counters: HashMap<T::ValueType, u64>,
     field: Field,
     ff_reader: Option<T>,
 }
 
-
 impl<T> FacetCollector<T>
-    where T: FastFieldReader,
-          T::ValueType: Eq + Hash
+where
+    T: FastFieldReader,
+    T::ValueType: Eq + Hash,
 {
     /// Creates a new facet collector for aggregating a given field.
     pub fn new(field: Field) -> FacetCollector<T> {
@@ -38,10 +38,10 @@ impl<T> FacetCollector<T>
     }
 }
 
-
 impl<T> Collector for FacetCollector<T>
-    where T: FastFieldReader,
-          T::ValueType: Eq + Hash
+where
+    T: FastFieldReader,
+    T::ValueType: Eq + Hash,
 {
     fn set_segment(&mut self, _: SegmentLocalId, reader: &SegmentReader) -> Result<()> {
         self.ff_reader = Some(reader.get_fast_field_reader(self.field)?);
@@ -57,8 +57,6 @@ impl<T> Collector for FacetCollector<T>
     }
 }
 
-
-
 #[cfg(test)]
 mod tests {
 
@@ -72,7 +70,6 @@ mod tests {
     // create 10 documents, set num field value to 0 or 1 for even/odd ones
     // make sure we have facet counters correctly filled
     fn test_facet_collector_results() {
-
         let mut schema_builder = schema::SchemaBuilder::new();
         let num_field_i64 = schema_builder.add_i64_field("num_i64", FAST);
         let num_field_u64 = schema_builder.add_u64_field("num_u64", FAST);
@@ -103,7 +100,7 @@ mod tests {
         {
             // perform the query
             let mut facet_collectors = chain().push(&mut ffvf_i64).push(&mut ffvf_u64);
-            let query_parser = QueryParser::new(schema, vec![text_field]);
+            let query_parser = QueryParser::for_index(&index, vec![text_field]);
             let query = query_parser.parse_query("text:text").unwrap();
             query.search(&searcher, &mut facet_collectors).unwrap();
         }
@@ -112,6 +109,5 @@ mod tests {
         assert_eq!(ffvf_u64.counters[&1], 5);
         assert_eq!(ffvf_i64.counters[&0], 4);
         assert_eq!(ffvf_i64.counters[&1], 3);
-
     }
 }

src/collector/mod.rs

@@ -1,3 +1,7 @@
+/*!
+Defines how the documents matching a search query should be processed.
+*/
+
 use SegmentReader;
 use SegmentLocalId;
 use DocId;
@@ -51,20 +55,21 @@ pub use self::chained_collector::chain;
 pub trait Collector {
     /// `set_segment` is called before beginning to enumerate
     /// on this segment.
-    fn set_segment(&mut self,
-                   segment_local_id: SegmentLocalId,
-                   segment: &SegmentReader)
-                   -> Result<()>;
+    fn set_segment(
+        &mut self,
+        segment_local_id: SegmentLocalId,
+        segment: &SegmentReader,
+    ) -> Result<()>;
     /// The query pushes the scored document to the collector via this method.
     fn collect(&mut self, doc: DocId, score: Score);
 }
 
-
 impl<'a, C: Collector> Collector for &'a mut C {
-    fn set_segment(&mut self,
-                   segment_local_id: SegmentLocalId,
-                   segment: &SegmentReader)
-                   -> Result<()> {
+    fn set_segment(
+        &mut self,
+        segment_local_id: SegmentLocalId,
+        segment: &SegmentReader,
+    ) -> Result<()> {
         (*self).set_segment(segment_local_id, segment)
     }
     /// The query pushes the scored document to the collector via this method.
@@ -73,7 +78,6 @@ impl<'a, C: Collector> Collector for &'a mut C {
     }
 }
 
-
 #[cfg(test)]
 pub mod tests {
 
@@ -126,9 +130,6 @@ pub mod tests {
         }
     }
 
-
-
-
     /// Collects in order all of the fast fields for all of the
     /// doc in the `DocSet`
     ///
@@ -165,16 +166,15 @@ pub mod tests {
         }
     }
 
-
     #[bench]
     fn build_collector(b: &mut Bencher) {
         b.iter(|| {
-                   let mut count_collector = CountCollector::default();
-                   let docs: Vec<u32> = (0..1_000_000).collect();
-                   for doc in docs {
-                       count_collector.collect(doc, 1f32);
-                   }
-                   count_collector.count()
-               });
+            let mut count_collector = CountCollector::default();
+            let docs: Vec<u32> = (0..1_000_000).collect();
+            for doc in docs {
+                count_collector.collect(doc, 1f32);
+            }
+            count_collector.count()
+        });
     }
 }

src/collector/multi_collector.rs

@@ -5,7 +5,6 @@ use Result;
 use SegmentReader;
 use SegmentLocalId;
 
-
 /// Multicollector makes it possible to collect on more than one collector.
 /// It should only be used for use cases where the Collector types is unknown
 /// at compile time.
@@ -17,16 +16,18 @@ pub struct MultiCollector<'a> {
 impl<'a> MultiCollector<'a> {
     /// Constructor
     pub fn from(collectors: Vec<&'a mut Collector>) -> MultiCollector {
-        MultiCollector { collectors: collectors }
+        MultiCollector {
+            collectors: collectors,
+        }
     }
 }
 
-
 impl<'a> Collector for MultiCollector<'a> {
-    fn set_segment(&mut self,
-                   segment_local_id: SegmentLocalId,
-                   segment: &SegmentReader)
-                   -> Result<()> {
+    fn set_segment(
+        &mut self,
+        segment_local_id: SegmentLocalId,
+        segment: &SegmentReader,
+    ) -> Result<()> {
         for collector in &mut self.collectors {
             try!(collector.set_segment(segment_local_id, segment));
         }
@@ -40,8 +41,6 @@ impl<'a> Collector for MultiCollector<'a> {
     }
 }
 
-
-
 #[cfg(test)]
 mod tests {
 
@@ -53,8 +52,8 @@ mod tests {
         let mut top_collector = TopCollector::with_limit(2);
         let mut count_collector = CountCollector::default();
         {
-            let mut collectors = MultiCollector::from(vec![&mut top_collector,
-                                                           &mut count_collector]);
+            let mut collectors =
+                MultiCollector::from(vec![&mut top_collector, &mut count_collector]);
             collectors.collect(1, 0.2);
             collectors.collect(2, 0.1);
             collectors.collect(3, 0.5);

src/collector/top_collector.rs

@@ -39,7 +39,6 @@ impl PartialEq for GlobalScoredDoc {
 
 impl Eq for GlobalScoredDoc {}
 
-
 /// The Top Collector keeps track of the K documents
 /// with the best scores.
 ///
@@ -108,10 +107,9 @@ impl Collector for TopCollector {
     fn collect(&mut self, doc: DocId, score: Score) {
         if self.at_capacity() {
             // It's ok to unwrap as long as a limit of 0 is forbidden.
-            let limit_doc: GlobalScoredDoc =
-                *self.heap
-                     .peek()
-                     .expect("Top collector with size 0 is forbidden");
+            let limit_doc: GlobalScoredDoc = *self.heap
+                .peek()
+                .expect("Top collector with size 0 is forbidden");
             if limit_doc.score < score {
                 let mut mut_head = self.heap
                     .peek_mut()
@@ -126,11 +124,9 @@ impl Collector for TopCollector {
             };
             self.heap.push(wrapped_doc);
         }
-
     }
 }
 
-
 #[cfg(test)]
 mod tests {
 
@@ -179,8 +175,6 @@ mod tests {
                 .collect();
             assert_eq!(docs, vec![7, 1, 5, 3]);
         }
-
-
     }
 
     #[test]

src/common/bitpacker.rs

@@ -15,7 +15,7 @@ use std::ops::Deref;
 /// reasons, we want to ensure that a value spawns over at most 8 bytes
 /// of aligns bytes.
 ///
-/// Spawning over 9 bytes is possible for instance, if we do
+/// Spanning over 9 bytes is possible for instance, if we do
 /// bitpacking with an amplitude of 63 bits.
 /// In this case, the second int will start on bit
 /// 63 (which belongs to byte 7) and ends at byte 15;
@@ -30,7 +30,11 @@ use std::ops::Deref;
 /// number of bits.
 pub fn compute_num_bits(amplitude: u64) -> u8 {
     let amplitude = (64u32 - amplitude.leading_zeros()) as u8;
-    if amplitude <= 64 - 8 { amplitude } else { 64 }
+    if amplitude <= 64 - 8 {
+        amplitude
+    } else {
+        64
+    }
 }
 
 pub struct BitPacker {
@@ -44,7 +48,7 @@ impl BitPacker {
         BitPacker {
             mini_buffer: 0u64,
             mini_buffer_written: 0,
-            num_bits: num_bits,
+            num_bits,
         }
     }
 
@@ -67,7 +71,7 @@ impl BitPacker {
         Ok(())
     }
 
-    fn flush<TWrite: Write>(&mut self, output: &mut TWrite) -> io::Result<()> {
+    pub(crate) fn flush<TWrite: Write>(&mut self, output: &mut TWrite) -> io::Result<()> {
         if self.mini_buffer_written > 0 {
             let num_bytes = (self.mini_buffer_written + 7) / 8;
             let arr: [u8; 8] = unsafe { mem::transmute::<u64, [u8; 8]>(self.mini_buffer) };
@@ -85,10 +89,9 @@ impl BitPacker {
     }
 }
 
-
-
 pub struct BitUnpacker<Data>
-    where Data: Deref<Target = [u8]>
+where
+    Data: Deref<Target = [u8]>,
 {
     num_bits: usize,
     mask: u64,
@@ -96,7 +99,8 @@ pub struct BitUnpacker<Data>
 }
 
 impl<Data> BitUnpacker<Data>
-    where Data: Deref<Target = [u8]>
+where
+    Data: Deref<Target = [u8]>,
 {
     pub fn new(data: Data, num_bits: usize) -> BitUnpacker<Data> {
         let mask: u64 = if num_bits == 64 {
@@ -105,9 +109,9 @@ impl<Data> BitUnpacker<Data>
             (1u64 << num_bits) - 1u64
         };
         BitUnpacker {
-            num_bits: num_bits,
-            mask: mask,
-            data: data,
+            num_bits,
+            mask,
+            data,
         }
     }
 
@@ -121,11 +125,31 @@ impl<Data> BitUnpacker<Data>
         let addr_in_bits = idx * num_bits;
         let addr = addr_in_bits >> 3;
         let bit_shift = addr_in_bits & 7;
-        debug_assert!(addr + 8 <= data.len(),
-                      "The fast field field should have been padded with 7 bytes.");
-        let val_unshifted_unmasked: u64 = unsafe { *(data[addr..].as_ptr() as *const u64) };
-        let val_shifted = (val_unshifted_unmasked >> bit_shift) as u64;
-        (val_shifted & mask)
+        if cfg!(feature = "simdcompression") {
+            // for simdcompression,
+            // the bitpacker is only used for fastfields,
+            // and we expect them to be always padded.
+            debug_assert!(
+                addr + 8 <= data.len(),
+                "The fast field field should have been padded with 7 bytes."
+            );
+            let val_unshifted_unmasked: u64 =
+                unsafe { *(data[addr..].as_ptr() as *const u64) };
+            let val_shifted = (val_unshifted_unmasked >> bit_shift) as u64;
+            (val_shifted & mask)
+        } else {
+            let val_unshifted_unmasked: u64 = if addr + 8 <= data.len() {
+                unsafe { *(data[addr..].as_ptr() as *const u64) }
+            } else {
+                let mut buffer = [0u8; 8];
+                for i in addr..data.len() {
+                    buffer[i - addr] += data[i];
+                }
+                unsafe { *(buffer[..].as_ptr() as *const u64) }
+            };
+            let val_shifted = (val_unshifted_unmasked >> bit_shift) as u64;
+            (val_shifted & mask)
+        }
     }
 
     pub fn get_range(&self, start: u32, output: &mut [u64]) {
@@ -141,22 +165,19 @@ impl<Data> BitUnpacker<Data>
             for output_val in output.iter_mut() {
                 let addr = addr_in_bits >> 3;
                 let bit_shift = addr_in_bits & 7;
-                let val_unshifted_unmasked: u64 = unsafe { *(data[addr..].as_ptr() as *const u64) };
+                let val_unshifted_unmasked: u64 =
+                    unsafe { *(data[addr..].as_ptr() as *const u64) };
                 let val_shifted = (val_unshifted_unmasked >> bit_shift) as u64;
                 *output_val = val_shifted & mask;
                 addr_in_bits += num_bits;
             }
         }
-
     }
 }
 
-
-
-
 #[cfg(test)]
 mod test {
-    use super::{BitPacker, BitUnpacker, compute_num_bits};
+    use super::{compute_num_bits, BitPacker, BitUnpacker};
 
     #[test]
     fn test_compute_num_bits() {

src/common/composite_file.rs

@@ -0,0 +1,184 @@
+use std::io::Write;
+use common::CountingWriter;
+use std::collections::HashMap;
+use schema::Field;
+use common::VInt;
+use directory::WritePtr;
+use std::io;
+use directory::ReadOnlySource;
+use common::BinarySerializable;
+
+/// A `CompositeWrite` is used to write a `CompositeFile`.
+pub struct CompositeWrite<W = WritePtr> {
+    write: CountingWriter<W>,
+    offsets: HashMap<Field, usize>,
+}
+
+impl<W: Write> CompositeWrite<W> {
+    /// Crate a new API writer that writes a composite file
+    /// in a given write.
+    pub fn wrap(w: W) -> CompositeWrite<W> {
+        CompositeWrite {
+            write: CountingWriter::wrap(w),
+            offsets: HashMap::new(),
+        }
+    }
+
+    /// Start writing a new field.
+    pub fn for_field(&mut self, field: Field) -> &mut CountingWriter<W> {
+        let offset = self.write.written_bytes();
+        assert!(!self.offsets.contains_key(&field));
+        self.offsets.insert(field, offset);
+        &mut self.write
+    }
+
+    /// Close the composite file.
+    ///
+    /// An index of the different field offsets
+    /// will be written as a footer.
+    pub fn close(mut self) -> io::Result<()> {
+        let footer_offset = self.write.written_bytes();
+        VInt(self.offsets.len() as u64).serialize(&mut self.write)?;
+
+        let mut offset_fields: Vec<_> = self.offsets
+            .iter()
+            .map(|(field, offset)| (offset, field))
+            .collect();
+
+        offset_fields.sort();
+
+        let mut prev_offset = 0;
+        for (offset, field) in offset_fields {
+            VInt((offset - prev_offset) as u64).serialize(&mut self.write)?;
+            field.serialize(&mut self.write)?;
+            prev_offset = *offset;
+        }
+
+        let footer_len = (self.write.written_bytes() - footer_offset) as u32;
+        footer_len.serialize(&mut self.write)?;
+        self.write.flush()?;
+        Ok(())
+    }
+}
+
+/// A composite file is an abstraction to store a
+/// file partitioned by field.
+///
+/// The file needs to be written field by field.
+/// A footer describes the start and stop offsets
+/// for each field.
+#[derive(Clone)]
+pub struct CompositeFile {
+    data: ReadOnlySource,
+    offsets_index: HashMap<Field, (usize, usize)>,
+}
+
+impl CompositeFile {
+    /// Opens a composite file stored in a given
+    /// `ReadOnlySource`.
+    pub fn open(data: &ReadOnlySource) -> io::Result<CompositeFile> {
+        let end = data.len();
+        let footer_len_data = data.slice_from(end - 4);
+        let footer_len = u32::deserialize(&mut footer_len_data.as_slice())? as usize;
+
+        let footer_start = end - 4 - footer_len;
+        let footer_data = data.slice(footer_start, footer_start + footer_len);
+        let mut footer_buffer = footer_data.as_slice();
+        let num_fields = VInt::deserialize(&mut footer_buffer)?.0 as usize;
+
+        let mut fields = vec![];
+        let mut offsets = vec![];
+
+        let mut field_index = HashMap::new();
+
+        let mut offset = 0;
+        for _ in 0..num_fields {
+            offset += VInt::deserialize(&mut footer_buffer)?.0 as usize;
+            let field = Field::deserialize(&mut footer_buffer)?;
+            offsets.push(offset);
+            fields.push(field);
+        }
+        offsets.push(footer_start);
+        for i in 0..num_fields {
+            let field = fields[i];
+            let start_offset = offsets[i];
+            let end_offset = offsets[i + 1];
+            field_index.insert(field, (start_offset, end_offset));
+        }
+
+        Ok(CompositeFile {
+            data: data.slice_to(footer_start),
+            offsets_index: field_index,
+        })
+    }
+
+    /// Returns a composite file that stores
+    /// no fields.
+    pub fn empty() -> CompositeFile {
+        CompositeFile {
+            offsets_index: HashMap::new(),
+            data: ReadOnlySource::empty(),
+        }
+    }
+
+    /// Returns the `ReadOnlySource` associated
+    /// to a given `Field` and stored in a `CompositeFile`.
+    pub fn open_read(&self, field: Field) -> Option<ReadOnlySource> {
+        self.offsets_index
+            .get(&field)
+            .map(|&(from, to)| self.data.slice(from, to))
+    }
+}
+
+#[cfg(test)]
+mod test {
+
+    use std::io::Write;
+    use super::{CompositeFile, CompositeWrite};
+    use directory::{Directory, RAMDirectory};
+    use schema::Field;
+    use common::VInt;
+    use common::BinarySerializable;
+    use std::path::Path;
+
+    #[test]
+    fn test_composite_file() {
+        let path = Path::new("test_path");
+        let mut directory = RAMDirectory::create();
+        {
+            let w = directory.open_write(path).unwrap();
+            let mut composite_write = CompositeWrite::wrap(w);
+            {
+                let mut write_0 = composite_write.for_field(Field(0u32));
+                VInt(32431123u64).serialize(&mut write_0).unwrap();
+                write_0.flush().unwrap();
+            }
+
+            {
+                let mut write_4 = composite_write.for_field(Field(4u32));
+                VInt(2).serialize(&mut write_4).unwrap();
+                write_4.flush().unwrap();
+            }
+            composite_write.close().unwrap();
+        }
+        {
+            let r = directory.open_read(path).unwrap();
+            let composite_file = CompositeFile::open(&r).unwrap();
+            {
+                let file0 = composite_file.open_read(Field(0u32)).unwrap();
+                let mut file0_buf = file0.as_slice();
+                let payload_0 = VInt::deserialize(&mut file0_buf).unwrap().0;
+                assert_eq!(file0_buf.len(), 0);
+                assert_eq!(payload_0, 32431123u64);
+            }
+            {
+                let file4 = composite_file.open_read(Field(4u32)).unwrap();
+                let mut file4_buf = file4.as_slice();
+                let payload_4 = VInt::deserialize(&mut file4_buf).unwrap().0;
+                assert_eq!(file4_buf.len(), 0);
+                assert_eq!(payload_4, 2u64);
+            }
+        }
+    }
+
+}

src/common/counting_writer.rs

@@ -1,8 +1,7 @@
 use std::io::Write;
 use std::io;
 
-
-pub struct CountingWriter<W: Write> {
+pub struct CountingWriter<W> {
     underlying: W,
     written_bytes: usize,
 }
@@ -10,7 +9,7 @@ pub struct CountingWriter<W: Write> {
 impl<W: Write> CountingWriter<W> {
     pub fn wrap(underlying: W) -> CountingWriter<W> {
         CountingWriter {
-            underlying: underlying,
+            underlying,
             written_bytes: 0,
         }
     }
@@ -37,8 +36,6 @@ impl<W: Write> Write for CountingWriter<W> {
     }
 }
 
-
-
 #[cfg(test)]
 mod test {
 

src/common/mod.rs

@@ -2,8 +2,10 @@ mod serialize;
 mod timer;
 mod vint;
 mod counting_writer;
+mod composite_file;
 pub mod bitpacker;
 
+pub(crate) use self::composite_file::{CompositeFile, CompositeWrite};
 pub use self::serialize::BinarySerializable;
 pub use self::timer::Timing;
 pub use self::timer::TimerTree;
@@ -18,7 +20,6 @@ pub fn make_io_err(msg: String) -> io::Error {
     io::Error::new(io::ErrorKind::Other, msg)
 }
 
-
 /// Has length trait
 pub trait HasLen {
     /// Return length
@@ -32,7 +33,6 @@ pub trait HasLen {
 
 const HIGHEST_BIT: u64 = 1 << 63;
 
-
 /// Maps a `i64` to `u64`
 ///
 /// For simplicity, tantivy internally handles `i64` as `u64`.
@@ -64,7 +64,6 @@ pub fn u64_to_i64(val: u64) -> i64 {
     (val ^ HIGHEST_BIT) as i64
 }
 
-
 #[cfg(test)]
 mod test {
 

src/common/serialize.rs

@@ -6,8 +6,6 @@ use std::io::Read;
 use std::io;
 use common::VInt;
 
-
-
 pub trait BinarySerializable: fmt::Debug + Sized {
     fn serialize<W: Write>(&self, writer: &mut W) -> io::Result<()>;
     fn deserialize<R: Read>(reader: &mut R) -> io::Result<Self>;
@@ -41,7 +39,6 @@ impl<T: BinarySerializable> BinarySerializable for Vec<T> {
     }
 }
 
-
 impl<Left: BinarySerializable, Right: BinarySerializable> BinarySerializable for (Left, Right) {
     fn serialize<W: Write>(&self, write: &mut W) -> io::Result<()> {
         self.0.serialize(write)?;
@@ -62,7 +59,6 @@ impl BinarySerializable for u32 {
     }
 }
 
-
 impl BinarySerializable for u64 {
     fn serialize<W: Write>(&self, writer: &mut W) -> io::Result<()> {
         writer.write_u64::<Endianness>(*self)
@@ -81,7 +77,6 @@ impl BinarySerializable for i64 {
     }
 }
 
-
 impl BinarySerializable for u8 {
     fn serialize<W: Write>(&self, writer: &mut W) -> io::Result<()> {
         writer.write_u8(*self)
@@ -108,7 +103,6 @@ impl BinarySerializable for String {
     }
 }
 
-
 #[cfg(test)]
 mod test {
 

src/common/timer.rs

@@ -24,16 +24,14 @@ impl<'a> OpenTimer<'a> {
 
 impl<'a> Drop for OpenTimer<'a> {
     fn drop(&mut self) {
-        self.timer_tree
-            .timings
-            .push(Timing {
-                      name: self.name,
-                      duration: self.start
-                          .to(PreciseTime::now())
-                          .num_microseconds()
-                          .unwrap(),
-                      depth: self.depth,
-                  });
+        self.timer_tree.timings.push(Timing {
+            name: self.name,
+            duration: self.start
+                .to(PreciseTime::now())
+                .num_microseconds()
+                .unwrap(),
+            depth: self.depth,
+        });
     }
 }
 
@@ -70,11 +68,12 @@ impl TimerTree {
 
 impl Default for TimerTree {
     fn default() -> TimerTree {
-        TimerTree { timings: Vec::new() }
+        TimerTree {
+            timings: Vec::new(),
+        }
     }
 }
 
-
 #[cfg(test)]
 mod tests {
 

src/common/vint.rs

@@ -3,8 +3,6 @@ use std::io;
 use std::io::Write;
 use std::io::Read;
 
-
-
 ///   Wrapper over a `u64` that serializes as a variable int.
 #[derive(Debug, Eq, PartialEq)]
 pub struct VInt(pub u64);
@@ -31,7 +29,6 @@ impl BinarySerializable for VInt {
             }
             i += 1;
         }
-
     }
 
     fn deserialize<R: Read>(reader: &mut R) -> io::Result<Self> {
@@ -41,13 +38,18 @@ impl BinarySerializable for VInt {
         loop {
             match bytes.next() {
                 Some(Ok(b)) => {
-                    result += ((b % 128u8) as u64) << shift;
+                    result += u64::from(b % 128u8) << shift;
                     if b & 128u8 != 0u8 {
                         break;
                     }
                     shift += 7;
                 }
-                _ => return Err(io::Error::new(io::ErrorKind::InvalidData, "Reach end of buffer")),
+                _ => {
+                    return Err(io::Error::new(
+                        io::ErrorKind::InvalidData,
+                        "Reach end of buffer",
+                    ))
+                }
             }
         }
         Ok(VInt(result))

src/compression/composite.rs

@@ -1,170 +0,0 @@
-use super::{BlockEncoder, BlockDecoder};
-use super::NUM_DOCS_PER_BLOCK;
-use compression::{VIntEncoder, VIntDecoder};
-
-pub struct CompositeEncoder {
-    block_encoder: BlockEncoder,
-    output: Vec<u8>,
-}
-
-impl CompositeEncoder {
-    pub fn new() -> CompositeEncoder {
-        CompositeEncoder {
-            block_encoder: BlockEncoder::new(),
-            output: Vec::with_capacity(500_000),
-        }
-    }
-
-    pub fn compress_sorted(&mut self, vals: &[u32]) -> &[u8] {
-        self.output.clear();
-        let num_blocks = vals.len() / NUM_DOCS_PER_BLOCK;
-        let mut offset = 0u32;
-        for i in 0..num_blocks {
-            let vals_slice = &vals[i * NUM_DOCS_PER_BLOCK..(i + 1) * NUM_DOCS_PER_BLOCK];
-            let block_compressed = self.block_encoder.compress_block_sorted(vals_slice, offset);
-            offset = vals_slice[NUM_DOCS_PER_BLOCK - 1];
-            self.output.extend_from_slice(block_compressed);
-        }
-        let vint_compressed =
-            self.block_encoder
-                .compress_vint_sorted(&vals[num_blocks * NUM_DOCS_PER_BLOCK..], offset);
-        self.output.extend_from_slice(vint_compressed);
-        &self.output
-    }
-
-    pub fn compress_unsorted(&mut self, vals: &[u32]) -> &[u8] {
-        self.output.clear();
-        let num_blocks = vals.len() / NUM_DOCS_PER_BLOCK;
-        for i in 0..num_blocks {
-            let vals_slice = &vals[i * NUM_DOCS_PER_BLOCK..(i + 1) * NUM_DOCS_PER_BLOCK];
-            let block_compressed = self.block_encoder.compress_block_unsorted(vals_slice);
-            self.output.extend_from_slice(block_compressed);
-        }
-        let vint_compressed = self.block_encoder
-            .compress_vint_unsorted(&vals[num_blocks * NUM_DOCS_PER_BLOCK..]);
-        self.output.extend_from_slice(vint_compressed);
-        &self.output
-    }
-}
-
-
-pub struct CompositeDecoder {
-    block_decoder: BlockDecoder,
-    vals: Vec<u32>,
-}
-
-
-impl CompositeDecoder {
-    pub fn new() -> CompositeDecoder {
-        CompositeDecoder {
-            block_decoder: BlockDecoder::new(),
-            vals: Vec::with_capacity(500_000),
-        }
-    }
-
-    pub fn uncompress_sorted(&mut self,
-                             mut compressed_data: &[u8],
-                             uncompressed_len: usize)
-                             -> &[u32] {
-        if uncompressed_len > self.vals.capacity() {
-            let extra_capacity = uncompressed_len - self.vals.capacity();
-            self.vals.reserve(extra_capacity);
-        }
-        let mut offset = 0u32;
-        self.vals.clear();
-        let num_blocks = uncompressed_len / NUM_DOCS_PER_BLOCK;
-        for _ in 0..num_blocks {
-            compressed_data = self.block_decoder
-                .uncompress_block_sorted(compressed_data, offset);
-            offset = self.block_decoder.output(NUM_DOCS_PER_BLOCK - 1);
-            self.vals
-                .extend_from_slice(self.block_decoder.output_array());
-        }
-        self.block_decoder
-            .uncompress_vint_sorted(compressed_data,
-                                    offset,
-                                    uncompressed_len % NUM_DOCS_PER_BLOCK);
-        self.vals
-            .extend_from_slice(self.block_decoder.output_array());
-        &self.vals
-    }
-
-    pub fn uncompress_unsorted(&mut self,
-                               mut compressed_data: &[u8],
-                               uncompressed_len: usize)
-                               -> &[u32] {
-        self.vals.clear();
-        let num_blocks = uncompressed_len / NUM_DOCS_PER_BLOCK;
-        for _ in 0..num_blocks {
-            compressed_data = self.block_decoder
-                .uncompress_block_unsorted(compressed_data);
-            self.vals
-                .extend_from_slice(self.block_decoder.output_array());
-        }
-        self.block_decoder
-            .uncompress_vint_unsorted(compressed_data, uncompressed_len % NUM_DOCS_PER_BLOCK);
-        self.vals
-            .extend_from_slice(self.block_decoder.output_array());
-        &self.vals
-    }
-}
-
-impl Into<Vec<u32>> for CompositeDecoder {
-    fn into(self) -> Vec<u32> {
-        self.vals
-    }
-}
-
-
-#[cfg(test)]
-pub mod tests {
-
-    use test::Bencher;
-    use super::*;
-    use tests;
-
-    #[test]
-    fn test_composite_unsorted() {
-        let data = tests::generate_array(10_000, 0.1);
-        let mut encoder = CompositeEncoder::new();
-        let compressed = encoder.compress_unsorted(&data);
-        assert!(compressed.len() <= 19_794);
-        let mut decoder = CompositeDecoder::new();
-        let result = decoder.uncompress_unsorted(&compressed, data.len());
-        for i in 0..data.len() {
-            assert_eq!(data[i], result[i]);
-        }
-    }
-
-    #[test]
-    fn test_composite_sorted() {
-        let data = tests::generate_array(10_000, 0.1);
-        let mut encoder = CompositeEncoder::new();
-        let compressed = encoder.compress_sorted(&data);
-        assert!(compressed.len() <= 7_826);
-        let mut decoder = CompositeDecoder::new();
-        let result = decoder.uncompress_sorted(&compressed, data.len());
-        for i in 0..data.len() {
-            assert_eq!(data[i], result[i]);
-        }
-    }
-
-
-    const BENCH_NUM_INTS: usize = 99_968;
-
-    #[bench]
-    fn bench_compress(b: &mut Bencher) {
-        let mut encoder = CompositeEncoder::new();
-        let data = tests::generate_array(BENCH_NUM_INTS, 0.1);
-        b.iter(|| { encoder.compress_sorted(&data); });
-    }
-
-    #[bench]
-    fn bench_uncompress(b: &mut Bencher) {
-        let mut encoder = CompositeEncoder::new();
-        let data = tests::generate_array(BENCH_NUM_INTS, 0.1);
-        let compressed = encoder.compress_sorted(&data);
-        let mut decoder = CompositeDecoder::new();
-        b.iter(|| { decoder.uncompress_sorted(compressed, BENCH_NUM_INTS); });
-    }
-}

src/compression/mod.rs

@@ -1,52 +1,88 @@
 #![allow(dead_code)]
 
 
-mod composite;
-pub use self::composite::{CompositeEncoder, CompositeDecoder};
+mod stream;
 
+pub use self::stream::CompressedIntStream;
 
-#[cfg(not(feature="simdcompression"))]
+#[cfg(not(feature = "simdcompression"))]
 mod pack {
     mod compression_pack_nosimd;
-    pub use self::compression_pack_nosimd::*;
+    pub use self::compression_pack_nosimd::{BlockDecoder, BlockEncoder};
 }
 
-#[cfg(feature="simdcompression")]
+#[cfg(feature = "simdcompression")]
 mod pack {
     mod compression_pack_simd;
-    pub use self::compression_pack_simd::*;
+    pub use self::compression_pack_simd::{BlockDecoder, BlockEncoder};
 }
 
-pub use self::pack::{BlockEncoder, BlockDecoder};
+pub use self::pack::{BlockDecoder, BlockEncoder};
 
-#[cfg( any(not(feature="simdcompression"), target_env="msvc") )]
+#[cfg(any(not(feature = "simdcompression"), target_env = "msvc"))]
 mod vint {
     mod compression_vint_nosimd;
-    pub use self::compression_vint_nosimd::*;
+    pub(crate) use self::compression_vint_nosimd::*;
 }
 
-#[cfg( all(feature="simdcompression", not(target_env="msvc")) )]
+#[cfg(all(feature = "simdcompression", not(target_env = "msvc")))]
 mod vint {
     mod compression_vint_simd;
-    pub use self::compression_vint_simd::*;
+    pub(crate) use self::compression_vint_simd::*;
 }
 
+/// Returns the size in bytes of a compressed block, given `num_bits`.
+pub fn compressed_block_size(num_bits: u8) -> usize {
+    1 + (num_bits as usize) * 16
+}
 
 pub trait VIntEncoder {
+    /// Compresses an array of `u32` integers,
+    /// using [delta-encoding](https://en.wikipedia.org/wiki/Delta_encoding)
+    /// and variable bytes encoding.
+    ///
+    /// The method takes an array of ints to compress, and returns
+    /// a `&[u8]` representing the compressed data.
+    ///
+    /// The method also takes an offset to give the value of the
+    /// hypothetical previous element in the delta-encoding.
     fn compress_vint_sorted(&mut self, input: &[u32], offset: u32) -> &[u8];
+
+    /// Compresses an array of `u32` integers,
+    /// using variable bytes encoding.
+    ///
+    /// The method takes an array of ints to compress, and returns
+    /// a `&[u8]` representing the compressed data.
     fn compress_vint_unsorted(&mut self, input: &[u32]) -> &[u8];
 }
 
 pub trait VIntDecoder {
-    fn uncompress_vint_sorted<'a>(&mut self,
-                                  compressed_data: &'a [u8],
-                                  offset: u32,
-                                  num_els: usize)
-                                  -> &'a [u8];
-    fn uncompress_vint_unsorted<'a>(&mut self,
-                                    compressed_data: &'a [u8],
-                                    num_els: usize)
-                                    -> &'a [u8];
+    /// Uncompress an array of `u32` integers,
+    /// that were compressed using [delta-encoding](https://en.wikipedia.org/wiki/Delta_encoding)
+    /// and variable bytes encoding.
+    ///
+    /// The method takes a number of int to decompress, and returns
+    /// the amount of bytes that were read to decompress them.
+    ///
+    /// The method also takes an offset to give the value of the
+    /// hypothetical previous element in the delta-encoding.
+    ///
+    /// For instance, if delta encoded are `1, 3, 9`, and the
+    /// `offset` is 5, then the output will be:
+    /// `5 + 1 = 6, 6 + 3= 9, 9 + 9 = 18`
+    fn uncompress_vint_sorted<'a>(
+        &mut self,
+        compressed_data: &'a [u8],
+        offset: u32,
+        num_els: usize,
+    ) -> usize;
+
+    /// Uncompress an array of `u32s`, compressed using variable
+    /// byte encoding.
+    ///
+    /// The method takes a number of int to decompress, and returns
+    /// the amount of bytes that were read to decompress them.
+    fn uncompress_vint_unsorted<'a>(&mut self, compressed_data: &'a [u8], num_els: usize) -> usize;
 }
 
 impl VIntEncoder for BlockEncoder {
@@ -60,26 +96,23 @@ impl VIntEncoder for BlockEncoder {
 }
 
 impl VIntDecoder for BlockDecoder {
-    fn uncompress_vint_sorted<'a>(&mut self,
-                                  compressed_data: &'a [u8],
-                                  offset: u32,
-                                  num_els: usize)
-                                  -> &'a [u8] {
+    fn uncompress_vint_sorted<'a>(
+        &mut self,
+        compressed_data: &'a [u8],
+        offset: u32,
+        num_els: usize,
+    ) -> usize {
         self.output_len = num_els;
         vint::uncompress_sorted(compressed_data, &mut self.output[..num_els], offset)
     }
 
-    fn uncompress_vint_unsorted<'a>(&mut self,
-                                    compressed_data: &'a [u8],
-                                    num_els: usize)
-                                    -> &'a [u8] {
+    fn uncompress_vint_unsorted<'a>(&mut self, compressed_data: &'a [u8], num_els: usize) -> usize {
         self.output_len = num_els;
         vint::uncompress_unsorted(compressed_data, &mut self.output[..num_els])
     }
 }
 
-
-pub const NUM_DOCS_PER_BLOCK: usize = 128; //< should be a power of 2 to let the compiler optimize.
+pub const COMPRESSION_BLOCK_SIZE: usize = 128;
 
 #[cfg(test)]
 pub mod tests {
@@ -95,8 +128,8 @@ pub mod tests {
         let compressed_data = encoder.compress_block_sorted(&vals, 0);
         let mut decoder = BlockDecoder::new();
         {
-            let remaining_data = decoder.uncompress_block_sorted(compressed_data, 0);
-            assert_eq!(remaining_data.len(), 0);
+            let consumed_num_bytes = decoder.uncompress_block_sorted(compressed_data, 0);
+            assert_eq!(consumed_num_bytes, compressed_data.len());
         }
         for i in 0..128 {
             assert_eq!(vals[i], decoder.output(i));
@@ -110,8 +143,8 @@ pub mod tests {
         let compressed_data = encoder.compress_block_sorted(&vals, 10);
         let mut decoder = BlockDecoder::new();
         {
-            let remaining_data = decoder.uncompress_block_sorted(compressed_data, 10);
-            assert_eq!(remaining_data.len(), 0);
+            let consumed_num_bytes = decoder.uncompress_block_sorted(compressed_data, 10);
+            assert_eq!(consumed_num_bytes, compressed_data.len());
         }
         for i in 0..128 {
             assert_eq!(vals[i], decoder.output(i));
@@ -129,9 +162,9 @@ pub mod tests {
         compressed.push(173u8);
         let mut decoder = BlockDecoder::new();
         {
-            let remaining_data = decoder.uncompress_block_sorted(&compressed, 10);
-            assert_eq!(remaining_data.len(), 1);
-            assert_eq!(remaining_data[0], 173u8);
+            let consumed_num_bytes = decoder.uncompress_block_sorted(&compressed, 10);
+            assert_eq!(consumed_num_bytes, compressed.len() - 1);
+            assert_eq!(compressed[consumed_num_bytes], 173u8);
         }
         for i in 0..n {
             assert_eq!(vals[i], decoder.output(i));
@@ -149,16 +182,15 @@ pub mod tests {
         compressed.push(173u8);
         let mut decoder = BlockDecoder::new();
         {
-            let remaining_data = decoder.uncompress_block_unsorted(&compressed);
-            assert_eq!(remaining_data.len(), 1);
-            assert_eq!(remaining_data[0], 173u8);
+            let consumed_num_bytes = decoder.uncompress_block_unsorted(&compressed);
+            assert_eq!(consumed_num_bytes + 1, compressed.len());
+            assert_eq!(compressed[consumed_num_bytes], 173u8);
         }
         for i in 0..n {
             assert_eq!(vals[i], decoder.output(i));
         }
     }
 
-
     #[test]
     fn test_encode_vint() {
         {
@@ -169,31 +201,47 @@ pub mod tests {
                 let encoded_data = encoder.compress_vint_sorted(&input, *offset);
                 assert!(encoded_data.len() <= expected_length);
                 let mut decoder = BlockDecoder::new();
-                let remaining_data =
+                let consumed_num_bytes =
                     decoder.uncompress_vint_sorted(&encoded_data, *offset, input.len());
-                assert_eq!(0, remaining_data.len());
+                assert_eq!(consumed_num_bytes, encoded_data.len());
                 assert_eq!(input, decoder.output_array());
             }
         }
     }
 
-
     #[bench]
     fn bench_compress(b: &mut Bencher) {
         let mut encoder = BlockEncoder::new();
-        let data = tests::generate_array(NUM_DOCS_PER_BLOCK, 0.1);
-        b.iter(|| { encoder.compress_block_sorted(&data, 0u32); });
+        let data = tests::generate_array(COMPRESSION_BLOCK_SIZE, 0.1);
+        b.iter(|| {
+            encoder.compress_block_sorted(&data, 0u32);
+        });
     }
 
     #[bench]
     fn bench_uncompress(b: &mut Bencher) {
         let mut encoder = BlockEncoder::new();
-        let data = tests::generate_array(NUM_DOCS_PER_BLOCK, 0.1);
+        let data = tests::generate_array(COMPRESSION_BLOCK_SIZE, 0.1);
         let compressed = encoder.compress_block_sorted(&data, 0u32);
         let mut decoder = BlockDecoder::new();
-        b.iter(|| { decoder.uncompress_block_sorted(compressed, 0u32); });
+        b.iter(|| {
+            decoder.uncompress_block_sorted(compressed, 0u32);
+        });
     }
 
+    #[test]
+    fn test_all_docs_compression_numbits() {
+        for num_bits in 0..33 {
+            let mut data = [0u32; 128];
+            if num_bits > 0 {
+                data[0] = 1 << (num_bits - 1);
+            }
+            let mut encoder = BlockEncoder::new();
+            let compressed = encoder.compress_block_unsorted(&data);
+            assert_eq!(compressed[0] as usize, num_bits);
+            assert_eq!(compressed.len(), compressed_block_size(compressed[0]));
+        }
+    }
 
     const NUM_INTS_BENCH_VINT: usize = 10;
 
@@ -201,7 +249,9 @@ pub mod tests {
     fn bench_compress_vint(b: &mut Bencher) {
         let mut encoder = BlockEncoder::new();
         let data = tests::generate_array(NUM_INTS_BENCH_VINT, 0.001);
-        b.iter(|| { encoder.compress_vint_sorted(&data, 0u32); });
+        b.iter(|| {
+            encoder.compress_vint_sorted(&data, 0u32);
+        });
     }
 
     #[bench]
@@ -210,7 +260,9 @@ pub mod tests {
         let data = tests::generate_array(NUM_INTS_BENCH_VINT, 0.001);
         let compressed = encoder.compress_vint_sorted(&data, 0u32);
         let mut decoder = BlockDecoder::new();
-        b.iter(|| { decoder.uncompress_vint_sorted(compressed, 0u32, NUM_INTS_BENCH_VINT); });
+        b.iter(|| {
+            decoder.uncompress_vint_sorted(compressed, 0u32, NUM_INTS_BENCH_VINT);
+        });
     }
 
 }

src/compression/pack/compression_pack_nosimd.rs

@@ -1,16 +1,17 @@
 use common::bitpacker::compute_num_bits;
 use common::bitpacker::{BitPacker, BitUnpacker};
+use common::CountingWriter;
 use std::cmp;
 use std::io::Write;
-use super::super::NUM_DOCS_PER_BLOCK;
+use super::super::COMPRESSION_BLOCK_SIZE;
 
-const COMPRESSED_BLOCK_MAX_SIZE: usize = NUM_DOCS_PER_BLOCK * 4 + 1;
+const COMPRESSED_BLOCK_MAX_SIZE: usize = COMPRESSION_BLOCK_SIZE * 4 + 1;
 
-pub fn compress_sorted(vals: &mut [u32], mut output: &mut [u8], offset: u32) -> usize {
+pub fn compress_sorted(vals: &mut [u32], output: &mut [u8], offset: u32) -> usize {
     let mut max_delta = 0;
     {
         let mut local_offset = offset;
-        for i in 0..NUM_DOCS_PER_BLOCK {
+        for i in 0..COMPRESSION_BLOCK_SIZE {
             let val = vals[i];
             let delta = val - local_offset;
             max_delta = cmp::max(max_delta, delta);
@@ -18,24 +19,21 @@ pub fn compress_sorted(vals: &mut [u32], mut output: &mut [u8], offset: u32) ->
             local_offset = val;
         }
     }
-    let num_bits = compute_num_bits(max_delta);
-    output.write_all(&[num_bits]).unwrap();
+    let mut counting_writer = CountingWriter::wrap(output);
+    let num_bits = compute_num_bits(max_delta as u64);
+    counting_writer.write_all(&[num_bits]).unwrap();
+
     let mut bit_packer = BitPacker::new(num_bits as usize);
     for val in vals {
-        bit_packer.write(*val, &mut output).unwrap();
+        bit_packer.write(*val as u64, &mut counting_writer).unwrap();
     }
-    1 +
-    bit_packer
-        .close(&mut output)
-        .expect("packing in memory should never fail")
+    counting_writer.written_bytes()
 }
 
-
-
 pub struct BlockEncoder {
     pub output: [u8; COMPRESSED_BLOCK_MAX_SIZE],
     pub output_len: usize,
-    input_buffer: [u32; NUM_DOCS_PER_BLOCK],
+    input_buffer: [u32; COMPRESSION_BLOCK_SIZE],
 }
 
 impl BlockEncoder {
@@ -43,7 +41,7 @@ impl BlockEncoder {
         BlockEncoder {
             output: [0u8; COMPRESSED_BLOCK_MAX_SIZE],
             output_len: 0,
-            input_buffer: [0u32; NUM_DOCS_PER_BLOCK],
+            input_buffer: [0u32; COMPRESSION_BLOCK_SIZE],
         }
     }
 
@@ -54,22 +52,31 @@ impl BlockEncoder {
     }
 
     pub fn compress_block_unsorted(&mut self, vals: &[u32]) -> &[u8] {
-        let compressed_size: usize = {
-            let mut output: &mut [u8] = &mut self.output;
+        let compressed_size = {
+            let output: &mut [u8] = &mut self.output;
             let max = vals.iter()
                 .cloned()
                 .max()
                 .expect("compress unsorted called with an empty array");
-            let num_bits = compute_num_bits(max);
-            output.write_all(&[num_bits]).unwrap();
+            let num_bits = compute_num_bits(max as u64);
+            let mut counting_writer = CountingWriter::wrap(output);
+            counting_writer.write_all(&[num_bits]).unwrap();
             let mut bit_packer = BitPacker::new(num_bits as usize);
             for val in vals {
-                bit_packer.write(*val, &mut output).unwrap();
+                bit_packer.write(*val as u64, &mut counting_writer).unwrap();
             }
-            1 +
-            bit_packer
-                .close(&mut output)
-                .expect("packing in memory should never fail")
+            for _ in vals.len()..COMPRESSION_BLOCK_SIZE {
+                bit_packer
+                    .write(vals[0] as u64, &mut counting_writer)
+                    .unwrap();
+            }
+            bit_packer.flush(&mut counting_writer).expect(
+                "Flushing the bitpacking \
+                 in an in RAM buffer should never fail",
+            );
+            // we avoid writing "closing", because we
+            // do not want 7 bytes of padding here.
+            counting_writer.written_bytes()
         };
         &self.output[..compressed_size]
     }
@@ -80,7 +87,6 @@ pub struct BlockDecoder {
     pub output_len: usize,
 }
 
-
 impl BlockDecoder {
     pub fn new() -> BlockDecoder {
         BlockDecoder::with_val(0u32)
@@ -93,34 +99,35 @@ impl BlockDecoder {
         }
     }
 
-    pub fn uncompress_block_sorted<'a>(&mut self,
-                                       compressed_data: &'a [u8],
-                                       mut offset: u32)
-                                       -> &'a [u8] {
+    pub fn uncompress_block_sorted<'a>(
+        &mut self,
+        compressed_data: &'a [u8],
+        mut offset: u32,
+    ) -> usize {
         let consumed_size = {
             let num_bits = compressed_data[0];
             let bit_unpacker = BitUnpacker::new(&compressed_data[1..], num_bits as usize);
-            for i in 0..NUM_DOCS_PER_BLOCK {
+            for i in 0..COMPRESSION_BLOCK_SIZE {
                 let delta = bit_unpacker.get(i);
-                let val = offset + delta;
+                let val = offset + delta as u32;
                 self.output[i] = val;
                 offset = val;
             }
-            1 + (num_bits as usize * NUM_DOCS_PER_BLOCK + 7) / 8
+            1 + (num_bits as usize * COMPRESSION_BLOCK_SIZE + 7) / 8
         };
-        self.output_len = NUM_DOCS_PER_BLOCK;
-        &compressed_data[consumed_size..]
+        self.output_len = COMPRESSION_BLOCK_SIZE;
+        consumed_size
     }
 
-    pub fn uncompress_block_unsorted<'a>(&mut self, compressed_data: &'a [u8]) -> &'a [u8] {
+    pub fn uncompress_block_unsorted<'a>(&mut self, compressed_data: &'a [u8]) -> usize {
         let num_bits = compressed_data[0];
         let bit_unpacker = BitUnpacker::new(&compressed_data[1..], num_bits as usize);
-        for i in 0..NUM_DOCS_PER_BLOCK {
-            self.output[i] = bit_unpacker.get(i);
+        for i in 0..COMPRESSION_BLOCK_SIZE {
+            self.output[i] = bit_unpacker.get(i) as u32;
         }
-        let consumed_size = 1 + (num_bits as usize * NUM_DOCS_PER_BLOCK + 7) / 8;
-        self.output_len = NUM_DOCS_PER_BLOCK;
-        &compressed_data[consumed_size..]
+        let consumed_size = 1 + (num_bits as usize * COMPRESSION_BLOCK_SIZE + 7) / 8;
+        self.output_len = COMPRESSION_BLOCK_SIZE;
+        consumed_size
     }
 
     #[inline]

src/compression/pack/compression_pack_simd.rs

@@ -1,6 +1,6 @@
-use super::super::NUM_DOCS_PER_BLOCK;
+use super::super::COMPRESSION_BLOCK_SIZE;
 
-const COMPRESSED_BLOCK_MAX_SIZE: usize = NUM_DOCS_PER_BLOCK * 4 + 1;
+const COMPRESSED_BLOCK_MAX_SIZE: usize = COMPRESSION_BLOCK_SIZE * 4 + 1;
 
 mod simdcomp {
     use libc::size_t;
@@ -8,10 +8,11 @@ mod simdcomp {
     extern "C" {
         pub fn compress_sorted(data: *const u32, output: *mut u8, offset: u32) -> size_t;
 
-        pub fn uncompress_sorted(compressed_data: *const u8,
-                                 output: *mut u32,
-                                 offset: u32)
-                                 -> size_t;
+        pub fn uncompress_sorted(
+            compressed_data: *const u8,
+            output: *mut u32,
+            offset: u32,
+        ) -> size_t;
 
         pub fn compress_unsorted(data: *const u32, output: *mut u8) -> size_t;
 
@@ -24,7 +25,9 @@ fn compress_sorted(vals: &[u32], output: &mut [u8], offset: u32) -> usize {
 }
 
 fn uncompress_sorted(compressed_data: &[u8], output: &mut [u32], offset: u32) -> usize {
-    unsafe { simdcomp::uncompress_sorted(compressed_data.as_ptr(), output.as_mut_ptr(), offset) }
+    unsafe {
+        simdcomp::uncompress_sorted(compressed_data.as_ptr(), output.as_mut_ptr(), offset)
+    }
 }
 
 fn compress_unsorted(vals: &[u32], output: &mut [u8]) -> usize {
@@ -35,7 +38,6 @@ fn uncompress_unsorted(compressed_data: &[u8], output: &mut [u32]) -> usize {
     unsafe { simdcomp::uncompress_unsorted(compressed_data.as_ptr(), output.as_mut_ptr()) }
 }
 
-
 pub struct BlockEncoder {
     pub output: [u8; COMPRESSED_BLOCK_MAX_SIZE],
     pub output_len: usize,
@@ -65,7 +67,6 @@ pub struct BlockDecoder {
     pub output_len: usize,
 }
 
-
 impl BlockDecoder {
     pub fn new() -> BlockDecoder {
         BlockDecoder::with_val(0u32)
@@ -78,19 +79,16 @@ impl BlockDecoder {
         }
     }
 
-    pub fn uncompress_block_sorted<'a>(&mut self,
-                                       compressed_data: &'a [u8],
-                                       offset: u32)
-                                       -> &'a [u8] {
+    pub fn uncompress_block_sorted(&mut self, compressed_data: &[u8], offset: u32) -> usize {
         let consumed_size = uncompress_sorted(compressed_data, &mut self.output, offset);
-        self.output_len = NUM_DOCS_PER_BLOCK;
-        &compressed_data[consumed_size..]
+        self.output_len = COMPRESSION_BLOCK_SIZE;
+        consumed_size
     }
 
-    pub fn uncompress_block_unsorted<'a>(&mut self, compressed_data: &'a [u8]) -> &'a [u8] {
+    pub fn uncompress_block_unsorted<'a>(&mut self, compressed_data: &'a [u8]) -> usize {
         let consumed_size = uncompress_unsorted(compressed_data, &mut self.output);
-        self.output_len = NUM_DOCS_PER_BLOCK;
-        &compressed_data[consumed_size..]
+        self.output_len = COMPRESSION_BLOCK_SIZE;
+        consumed_size
     }
 
     #[inline]
@@ -104,7 +102,6 @@ impl BlockDecoder {
     }
 }
 
-
 #[cfg(test)]
 mod tests {
 
@@ -117,4 +114,5 @@ mod tests {
         let compressed = encoder.compress_block_sorted(&data, 0u32);
         assert_eq!(compressed.len(), 17);
     }
+
 }

src/compression/stream.rs

@@ -0,0 +1,130 @@
+use compression::BlockDecoder;
+use compression::COMPRESSION_BLOCK_SIZE;
+use compression::compressed_block_size;
+use directory::{ReadOnlySource, SourceRead};
+
+/// Reads a stream of compressed ints.
+///
+/// Tantivy uses `CompressedIntStream` to read
+/// the position file.
+/// The `.skip(...)` makes it possible to avoid
+/// decompressing blocks that are not required.
+pub struct CompressedIntStream {
+    buffer: SourceRead,
+    block_decoder: BlockDecoder,
+    inner_offset: usize,
+}
+
+impl CompressedIntStream {
+    /// Opens a compressed int stream.
+    pub(crate) fn wrap(source: ReadOnlySource) -> CompressedIntStream {
+        CompressedIntStream {
+            buffer: SourceRead::from(source),
+            block_decoder: BlockDecoder::new(),
+            inner_offset: COMPRESSION_BLOCK_SIZE,
+        }
+    }
+
+    /// Fills a buffer with the next `output.len()` integers,
+    /// and advance the stream by that many els.
+    pub fn read(&mut self, output: &mut [u32]) {
+        let mut num_els: usize = output.len();
+        let mut start: usize = 0;
+        loop {
+            let available = COMPRESSION_BLOCK_SIZE - self.inner_offset;
+            if num_els >= available {
+                if available > 0 {
+                    let uncompressed_block =
+                        &self.block_decoder.output_array()[self.inner_offset..];
+                    output[start..][..available].clone_from_slice(uncompressed_block);
+                }
+                num_els -= available;
+                start += available;
+                let num_consumed_bytes = self.block_decoder
+                    .uncompress_block_unsorted(self.buffer.as_ref());
+                self.buffer.advance(num_consumed_bytes);
+                self.inner_offset = 0;
+            } else {
+                let uncompressed_block = &self.block_decoder.output_array()
+                    [self.inner_offset..self.inner_offset + num_els];
+                output[start..][..num_els].clone_from_slice(uncompressed_block);
+                self.inner_offset += num_els;
+                break;
+            }
+        }
+    }
+
+    /// Skip the next `skip_len` integer.
+    ///
+    /// If a full block is skipped, calling
+    /// `.skip(...)` will avoid decompressing it.
+    pub fn skip(&mut self, mut skip_len: usize) {
+        let available = COMPRESSION_BLOCK_SIZE - self.inner_offset;
+        if available >= skip_len {
+            self.inner_offset += skip_len;
+        } else {
+            skip_len -= available;
+            // entirely skip decompressing some blocks.
+            while skip_len >= COMPRESSION_BLOCK_SIZE {
+                skip_len -= COMPRESSION_BLOCK_SIZE;
+                let num_bits: u8 = self.buffer.as_ref()[0];
+                let block_len = compressed_block_size(num_bits);
+                self.buffer.advance(block_len);
+            }
+            let num_consumed_bytes = self.block_decoder
+                .uncompress_block_unsorted(self.buffer.as_ref());
+            self.buffer.advance(num_consumed_bytes);
+            self.inner_offset = skip_len;
+        }
+    }
+}
+
+#[cfg(test)]
+pub mod tests {
+
+    use super::CompressedIntStream;
+    use compression::compressed_block_size;
+    use compression::COMPRESSION_BLOCK_SIZE;
+    use compression::BlockEncoder;
+    use directory::ReadOnlySource;
+
+    fn create_stream_buffer() -> ReadOnlySource {
+        let mut buffer: Vec<u8> = vec![];
+        let mut encoder = BlockEncoder::new();
+        let vals: Vec<u32> = (0u32..1_025u32).collect();
+        for chunk in vals.chunks(COMPRESSION_BLOCK_SIZE) {
+            let compressed_block = encoder.compress_block_unsorted(chunk);
+            let num_bits = compressed_block[0];
+            assert_eq!(compressed_block_size(num_bits), compressed_block.len());
+            buffer.extend_from_slice(compressed_block);
+        }
+        if cfg!(simd) {
+            buffer.extend_from_slice(&[0u8; 7]);
+        }
+        ReadOnlySource::from(buffer)
+    }
+
+    #[test]
+    fn test_compressed_int_stream() {
+        let buffer = create_stream_buffer();
+        let mut stream = CompressedIntStream::wrap(buffer);
+        let mut block: [u32; COMPRESSION_BLOCK_SIZE] = [0u32; COMPRESSION_BLOCK_SIZE];
+
+        stream.read(&mut block[0..2]);
+        assert_eq!(block[0], 0);
+        assert_eq!(block[1], 1);
+        stream.skip(5);
+        stream.read(&mut block[0..3]);
+        assert_eq!(block[0], 7);
+        assert_eq!(block[1], 8);
+        assert_eq!(block[2], 9);
+        stream.skip(500);
+        stream.read(&mut block[0..3]);
+        assert_eq!(block[0], 510);
+        assert_eq!(block[1], 511);
+        assert_eq!(block[2], 512);
+        stream.skip(511);
+        stream.read(&mut block[..1]);
+        assert_eq!(block[0], 1024);
+    }
+}

src/compression/vint/compression_vint_nosimd.rs

@@ -1,6 +1,9 @@
-
 #[inline(always)]
-pub fn compress_sorted<'a>(input: &[u32], output: &'a mut [u8], mut offset: u32) -> &'a [u8] {
+pub(crate) fn compress_sorted<'a>(
+    input: &[u32],
+    output: &'a mut [u8],
+    mut offset: u32,
+) -> &'a [u8] {
     let mut byte_written = 0;
     for &v in input {
         let mut to_encode: u32 = v - offset;
@@ -22,7 +25,7 @@ pub fn compress_sorted<'a>(input: &[u32], output: &'a mut [u8], mut offset: u32)
 }
 
 #[inline(always)]
-pub fn compress_unsorted<'a>(input: &[u32], output: &'a mut [u8]) -> &'a [u8] {
+pub(crate) fn compress_unsorted<'a>(input: &[u32], output: &'a mut [u8]) -> &'a [u8] {
     let mut byte_written = 0;
     for &v in input {
         let mut to_encode: u32 = v;
@@ -43,10 +46,11 @@ pub fn compress_unsorted<'a>(input: &[u32], output: &'a mut [u8]) -> &'a [u8] {
 }
 
 #[inline(always)]
-pub fn uncompress_sorted<'a>(compressed_data: &'a [u8],
-                             output: &mut [u32],
-                             offset: u32)
-                             -> &'a [u8] {
+pub(crate) fn uncompress_sorted<'a>(
+    compressed_data: &'a [u8],
+    output: &mut [u32],
+    offset: u32,
+) -> usize {
     let mut read_byte = 0;
     let mut result = offset;
     let num_els = output.len();
@@ -63,11 +67,11 @@ pub fn uncompress_sorted<'a>(compressed_data: &'a [u8],
         }
         output[i] = result;
     }
-    &compressed_data[read_byte..]
+    read_byte
 }
 
 #[inline(always)]
-pub fn uncompress_unsorted<'a>(compressed_data: &'a [u8], output: &mut [u32]) -> &'a [u8] {
+pub(crate) fn uncompress_unsorted<'a>(compressed_data: &'a [u8], output: &mut [u32]) -> usize {
     let mut read_byte = 0;
     let num_els = output.len();
     for i in 0..num_els {
@@ -84,5 +88,5 @@ pub fn uncompress_unsorted<'a>(compressed_data: &'a [u8], output: &mut [u32]) ->
         }
         output[i] = result;
     }
-    &compressed_data[read_byte..]
+    read_byte
 }

src/compression/vint/compression_vint_simd.rs

@@ -1,44 +1,47 @@
-
 mod streamvbyte {
 
     use libc::size_t;
 
     extern "C" {
-        pub fn streamvbyte_delta_encode(data: *const u32,
-                                        num_els: u32,
-                                        output: *mut u8,
-                                        offset: u32)
-                                        -> size_t;
+        pub fn streamvbyte_delta_encode(
+            data: *const u32,
+            num_els: u32,
+            output: *mut u8,
+            offset: u32,
+        ) -> size_t;
 
-        pub fn streamvbyte_delta_decode(compressed_data: *const u8,
-                                        output: *mut u32,
-                                        num_els: u32,
-                                        offset: u32)
-                                        -> size_t;
+        pub fn streamvbyte_delta_decode(
+            compressed_data: *const u8,
+            output: *mut u32,
+            num_els: u32,
+            offset: u32,
+        ) -> size_t;
 
         pub fn streamvbyte_encode(data: *const u32, num_els: u32, output: *mut u8) -> size_t;
 
-        pub fn streamvbyte_decode(compressed_data: *const u8,
-                                  output: *mut u32,
-                                  num_els: usize)
-                                  -> size_t;
+        pub fn streamvbyte_decode(
+            compressed_data: *const u8,
+            output: *mut u32,
+            num_els: usize,
+        ) -> size_t;
     }
 }
 
-
 #[inline(always)]
-pub fn compress_sorted<'a>(input: &[u32], output: &'a mut [u8], offset: u32) -> &'a [u8] {
+pub(crate) fn compress_sorted<'a>(input: &[u32], output: &'a mut [u8], offset: u32) -> &'a [u8] {
     let compress_length = unsafe {
-        streamvbyte::streamvbyte_delta_encode(input.as_ptr(),
-                                              input.len() as u32,
-                                              output.as_mut_ptr(),
-                                              offset)
+        streamvbyte::streamvbyte_delta_encode(
+            input.as_ptr(),
+            input.len() as u32,
+            output.as_mut_ptr(),
+            offset,
+        )
     };
     &output[..compress_length]
 }
 
 #[inline(always)]
-pub fn compress_unsorted<'a>(input: &[u32], output: &'a mut [u8]) -> &'a [u8] {
+pub(crate) fn compress_unsorted<'a>(input: &[u32], output: &'a mut [u8]) -> &'a [u8] {
     let compress_length = unsafe {
         streamvbyte::streamvbyte_encode(input.as_ptr(), input.len() as u32, output.as_mut_ptr())
     };
@@ -46,23 +49,24 @@ pub fn compress_unsorted<'a>(input: &[u32], output: &'a mut [u8]) -> &'a [u8] {
 }
 
 #[inline(always)]
-pub fn uncompress_sorted<'a>(compressed_data: &'a [u8],
-                             output: &mut [u32],
-                             offset: u32)
-                             -> &'a [u8] {
-    let consumed_bytes = unsafe {
-        streamvbyte::streamvbyte_delta_decode(compressed_data.as_ptr(),
-                                              output.as_mut_ptr(),
-                                              output.len() as u32,
-                                              offset)
-    };
-    &compressed_data[consumed_bytes..]
+pub(crate) fn uncompress_sorted<'a>(
+    compressed_data: &'a [u8],
+    output: &mut [u32],
+    offset: u32,
+) -> usize {
+    unsafe {
+        streamvbyte::streamvbyte_delta_decode(
+            compressed_data.as_ptr(),
+            output.as_mut_ptr(),
+            output.len() as u32,
+            offset,
+        )
+    }
 }
 
 #[inline(always)]
-pub fn uncompress_unsorted<'a>(compressed_data: &'a [u8], output: &mut [u32]) -> &'a [u8] {
-    let consumed_bytes = unsafe {
+pub(crate) fn uncompress_unsorted<'a>(compressed_data: &'a [u8], output: &mut [u32]) -> usize {
+    unsafe {
         streamvbyte::streamvbyte_decode(compressed_data.as_ptr(), output.as_mut_ptr(), output.len())
-    };
-    &compressed_data[consumed_bytes..]
+    }
 }

src/core/index.rs

@@ -23,6 +23,7 @@ use directory::ManagedDirectory;
 use core::META_FILEPATH;
 use super::segment::create_segment;
 use indexer::segment_updater::save_new_metas;
+use tokenizer::TokenizerManager;
 
 const NUM_SEARCHERS: usize = 12;
 
@@ -32,14 +33,14 @@ fn load_metas(directory: &Directory) -> Result<IndexMeta> {
     serde_json::from_str(&meta_string).chain_err(|| ErrorKind::CorruptedFile(META_FILEPATH.clone()))
 }
 
-/// Tantivy's Search Index
+/// Search Index
 pub struct Index {
     directory: ManagedDirectory,
     schema: Schema,
     searcher_pool: Arc<Pool<Searcher>>,
+    tokenizers: TokenizerManager,
 }
 
-
 impl Index {
     /// Creates a new index using the `RAMDirectory`.
     ///
@@ -48,9 +49,10 @@ impl Index {
     pub fn create_in_ram(schema: Schema) -> Index {
         let ram_directory = RAMDirectory::create();
         // unwrap is ok here
-        let directory = ManagedDirectory::new(ram_directory)
-            .expect("Creating a managed directory from a brand new RAM directory \
-                     should never fail.");
+        let directory = ManagedDirectory::new(ram_directory).expect(
+            "Creating a managed directory from a brand new RAM directory \
+             should never fail.",
+        );
         Index::from_directory(directory, schema).expect("Creating a RAMDirectory should never fail")
     }
 
@@ -58,12 +60,17 @@ impl Index {
     /// The index will use the `MMapDirectory`.
     ///
     /// If a previous index was in this directory, then its meta file will be destroyed.
-    pub fn create(directory_path: &Path, schema: Schema) -> Result<Index> {
+    pub fn create<P: AsRef<Path>>(directory_path: P, schema: Schema) -> Result<Index> {
         let mmap_directory = MmapDirectory::open(directory_path)?;
         let directory = ManagedDirectory::new(mmap_directory)?;
         Index::from_directory(directory, schema)
     }
 
+    /// Accessor for the tokenizer manager.
+    pub fn tokenizers(&self) -> &TokenizerManager {
+        &self.tokenizers
+    }
+
     /// Creates a new index in a temp directory.
     ///
     /// The index will use the `MMapDirectory` in a newly created directory.
@@ -79,29 +86,31 @@ impl Index {
     }
 
     /// Creates a new index given a directory and an `IndexMeta`.
-    fn create_from_metas(directory: ManagedDirectory, metas: IndexMeta) -> Result<Index> {
+    fn create_from_metas(directory: ManagedDirectory, metas: &IndexMeta) -> Result<Index> {
         let schema = metas.schema.clone();
         let index = Index {
-            directory: directory,
-            schema: schema,
+            directory,
+            schema,
             searcher_pool: Arc::new(Pool::new()),
+            tokenizers: TokenizerManager::default(),
         };
-        try!(index.load_searchers());
+        index.load_searchers()?;
         Ok(index)
     }
 
     /// Create a new index from a directory.
     pub fn from_directory(mut directory: ManagedDirectory, schema: Schema) -> Result<Index> {
         save_new_metas(schema.clone(), 0, directory.borrow_mut())?;
-        Index::create_from_metas(directory, IndexMeta::with_schema(schema))
+        let metas = IndexMeta::with_schema(schema);
+        Index::create_from_metas(directory, &metas)
     }
 
     /// Opens a new directory from an index path.
-    pub fn open(directory_path: &Path) -> Result<Index> {
+    pub fn open<P: AsRef<Path>>(directory_path: P) -> Result<Index> {
         let mmap_directory = MmapDirectory::open(directory_path)?;
         let directory = ManagedDirectory::new(mmap_directory)?;
-        let metas = try!(load_metas(&directory));
-        Index::create_from_metas(directory, metas)
+        let metas = load_metas(&directory)?;
+        Index::create_from_metas(directory, &metas)
     }
 
     /// Returns the index opstamp.
@@ -127,14 +136,14 @@ impl Index {
     /// If the lockfile already exists, returns `Error::FileAlreadyExists`.
     /// # Panics
     /// If the heap size per thread is too small, panics.
-    pub fn writer_with_num_threads(&self,
-                                   num_threads: usize,
-                                   heap_size_in_bytes: usize)
-                                   -> Result<IndexWriter> {
+    pub fn writer_with_num_threads(
+        &self,
+        num_threads: usize,
+        heap_size_in_bytes: usize,
+    ) -> Result<IndexWriter> {
         open_index_writer(self, num_threads, heap_size_in_bytes)
     }
 
-
     /// Creates a multithreaded writer
     /// It just calls `writer_with_num_threads` with the number of cores as `num_threads`
     ///
@@ -156,9 +165,9 @@ impl Index {
     /// Returns the list of segments that are searchable
     pub fn searchable_segments(&self) -> Result<Vec<Segment>> {
         Ok(self.searchable_segment_metas()?
-               .into_iter()
-               .map(|segment_meta| self.segment(segment_meta))
-               .collect())
+            .into_iter()
+            .map(|segment_meta| self.segment(segment_meta))
+            .collect())
     }
 
     #[doc(hidden)]
@@ -191,22 +200,23 @@ impl Index {
     /// Returns the list of segment ids that are searchable.
     pub fn searchable_segment_ids(&self) -> Result<Vec<SegmentId>> {
         Ok(self.searchable_segment_metas()?
-               .iter()
-               .map(|segment_meta| segment_meta.id())
-               .collect())
+            .iter()
+            .map(|segment_meta| segment_meta.id())
+            .collect())
     }
 
     /// Creates a new generation of searchers after
+
     /// a change of the set of searchable indexes.
     ///
     /// This needs to be called when a new segment has been
     /// published or after a merge.
     pub fn load_searchers(&self) -> Result<()> {
         let searchable_segments = self.searchable_segments()?;
-        let segment_readers: Vec<SegmentReader> = try!(searchable_segments
-                                                           .into_iter()
-                                                           .map(SegmentReader::open)
-                                                           .collect());
+        let segment_readers: Vec<SegmentReader> = searchable_segments
+            .iter()
+            .map(SegmentReader::open)
+            .collect::<Result<_>>()?;
         let searchers = (0..NUM_SEARCHERS)
             .map(|_| Searcher::from(segment_readers.clone()))
             .collect();
@@ -229,7 +239,6 @@ impl Index {
     }
 }
 
-
 impl fmt::Debug for Index {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "Index({:?})", self.directory)
@@ -241,7 +250,8 @@ impl Clone for Index {
         Index {
             directory: self.directory.clone(),
             schema: self.schema.clone(),
-            searcher_pool: self.searcher_pool.clone(),
+            searcher_pool: Arc::clone(&self.searcher_pool),
+            tokenizers: self.tokenizers.clone(),
         }
     }
 }

src/core/index_meta.rs

@@ -6,10 +6,10 @@ use core::SegmentMeta;
 /// This object is serialized on disk in the `meta.json` file.
 /// It keeps information about
 /// * the searchable segments,
-/// * the index docstamp
+/// * the index `docstamp`
 /// * the schema
 ///
-#[derive(Clone,Debug,Serialize, Deserialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct IndexMeta {
     pub segments: Vec<SegmentMeta>,
     pub schema: Schema,
@@ -20,7 +20,7 @@ impl IndexMeta {
     pub fn with_schema(schema: Schema) -> IndexMeta {
         IndexMeta {
             segments: vec![],
-            schema: schema,
+            schema,
             opstamp: 0u64,
         }
     }

src/core/inverted_index_reader.rs

@@ -0,0 +1,152 @@
+use directory::{ReadOnlySource, SourceRead};
+use termdict::{TermDictionary, TermDictionaryImpl};
+use postings::{BlockSegmentPostings, SegmentPostings};
+use postings::TermInfo;
+use schema::IndexRecordOption;
+use schema::Term;
+use std::cmp;
+use fastfield::DeleteBitSet;
+use schema::Schema;
+use compression::CompressedIntStream;
+
+/// The inverted index reader is in charge of accessing
+/// the inverted index associated to a specific field.
+///
+/// # Note
+///
+/// It is safe to delete the segment associated to
+/// an `InvertedIndexReader`. As long as it is open,
+/// the `ReadOnlySource` it is relying on should
+/// stay available.
+///
+///
+/// `InvertedIndexReader` are created by calling
+/// the `SegmentReader`'s [`.inverted_index(...)`] method
+pub struct InvertedIndexReader {
+    termdict: TermDictionaryImpl,
+    postings_source: ReadOnlySource,
+    positions_source: ReadOnlySource,
+    delete_bitset: DeleteBitSet,
+    schema: Schema,
+}
+
+impl InvertedIndexReader {
+    pub(crate) fn new(
+        termdict_source: ReadOnlySource,
+        postings_source: ReadOnlySource,
+        positions_source: ReadOnlySource,
+        delete_bitset: DeleteBitSet,
+        schema: Schema,
+    ) -> InvertedIndexReader {
+        InvertedIndexReader {
+            termdict: TermDictionaryImpl::from_source(termdict_source),
+            postings_source,
+            positions_source,
+            delete_bitset,
+            schema,
+        }
+    }
+
+    /// Returns the term info associated with the term.
+    pub fn get_term_info(&self, term: &Term) -> Option<TermInfo> {
+        self.termdict.get(term.as_slice())
+    }
+
+    /// Return the term dictionary datastructure.
+    pub fn terms(&self) -> &TermDictionaryImpl {
+        &self.termdict
+    }
+
+    /// Resets the block segment to another position of the postings
+    /// file.
+    ///
+    /// This is useful for enumerating through a list of terms,
+    /// and consuming the associated posting lists while avoiding
+    /// reallocating a `BlockSegmentPostings`.
+    ///
+    /// # Warning
+    ///
+    /// This does not reset the positions list.
+    pub fn reset_block_postings_from_terminfo(
+        &self,
+        term_info: &TermInfo,
+        block_postings: &mut BlockSegmentPostings,
+    ) {
+        let offset = term_info.postings_offset as usize;
+        let end_source = self.postings_source.len();
+        let postings_slice = self.postings_source.slice(offset, end_source);
+        let postings_reader = SourceRead::from(postings_slice);
+        block_postings.reset(term_info.doc_freq as usize, postings_reader);
+    }
+
+    /// Returns a block postings given a `term_info`.
+    /// This method is for an advanced usage only.
+    ///
+    /// Most user should prefer using `read_postings` instead.
+    pub fn read_block_postings_from_terminfo(
+        &self,
+        term_info: &TermInfo,
+        option: IndexRecordOption,
+    ) -> BlockSegmentPostings {
+        let offset = term_info.postings_offset as usize;
+        let postings_data = self.postings_source.slice_from(offset);
+        let has_freq = option.has_freq();
+        BlockSegmentPostings::from_data(
+            term_info.doc_freq as usize,
+            SourceRead::from(postings_data),
+            has_freq,
+        )
+    }
+
+    /// Returns a posting object given a `term_info`.
+    /// This method is for an advanced usage only.
+    ///
+    /// Most user should prefer using `read_postings` instead.
+    pub fn read_postings_from_terminfo(
+        &self,
+        term_info: &TermInfo,
+        option: IndexRecordOption,
+    ) -> SegmentPostings {
+        let block_postings = self.read_block_postings_from_terminfo(term_info, option);
+        let delete_bitset = self.delete_bitset.clone();
+        let position_stream = {
+            if option.has_positions() {
+                let position_offset = term_info.positions_offset;
+                let positions_source = self.positions_source.slice_from(position_offset as usize);
+                let mut stream = CompressedIntStream::wrap(positions_source);
+                stream.skip(term_info.positions_inner_offset as usize);
+                Some(stream)
+            } else {
+                None
+            }
+        };
+        SegmentPostings::from_block_postings(block_postings, delete_bitset, position_stream)
+    }
+
+    /// Returns the segment postings associated with the term, and with the given option,
+    /// or `None` if the term has never been encountered and indexed.
+    ///
+    /// If the field was not indexed with the indexing options that cover
+    /// the requested options, the returned `SegmentPostings` the method does not fail
+    /// and returns a `SegmentPostings` with as much information as possible.
+    ///
+    /// For instance, requesting `IndexRecordOption::Freq` for a
+    /// `TextIndexingOptions` that does not index position will return a `SegmentPostings`
+    /// with `DocId`s and frequencies.
+    pub fn read_postings(&self, term: &Term, option: IndexRecordOption) -> Option<SegmentPostings> {
+        let field = term.field();
+        let field_entry = self.schema.get_field_entry(field);
+        let term_info = get!(self.get_term_info(term));
+        let maximum_option = get!(field_entry.field_type().get_index_record_option());
+        let best_effort_option = cmp::min(maximum_option, option);
+        Some(self.read_postings_from_terminfo(&term_info, best_effort_option))
+    }
+
+    /// Returns the number of documents containing the term.
+    pub fn doc_freq(&self, term: &Term) -> u32 {
+        match self.get_term_info(term) {
+            Some(term_info) => term_info.doc_freq,
+            None => 0,
+        }
+    }
+}

src/core/mod.rs

@@ -7,7 +7,9 @@ mod segment;
 mod index_meta;
 mod pool;
 mod segment_meta;
+mod inverted_index_reader;
 
+pub use self::inverted_index_reader::InvertedIndexReader;
 pub use self::searcher::Searcher;
 pub use self::segment_component::SegmentComponent;
 pub use self::segment_id::SegmentId;
@@ -18,7 +20,6 @@ pub use self::index::Index;
 pub use self::segment_meta::SegmentMeta;
 pub use self::index_meta::IndexMeta;
 
-
 use std::path::PathBuf;
 
 lazy_static! {

src/core/pool.rs

@@ -10,44 +10,17 @@ pub struct GenerationItem<T> {
     item: T,
 }
 
-
-// See https://github.com/crossbeam-rs/crossbeam/issues/91
-struct NonLeakingMsQueue<T> {
-    underlying_queue: MsQueue<T>,
-}
-
-impl<T> Default for NonLeakingMsQueue<T> {
-    fn default() -> NonLeakingMsQueue<T> {
-        NonLeakingMsQueue { underlying_queue: MsQueue::new() }
-    }
-}
-
-impl<T> NonLeakingMsQueue<T> {
-    fn pop(&self) -> T {
-        self.underlying_queue.pop()
-    }
-
-    fn push(&self, el: T) {
-        self.underlying_queue.push(el);
-    }
-}
-
-impl<T> Drop for NonLeakingMsQueue<T> {
-    fn drop(&mut self) {
-        while let Some(_popped_item_to_be_dropped) = self.underlying_queue.try_pop() {}
-    }
-}
-
 pub struct Pool<T> {
-    queue: Arc<NonLeakingMsQueue<GenerationItem<T>>>,
+    queue: Arc<MsQueue<GenerationItem<T>>>,
     freshest_generation: AtomicUsize,
     next_generation: AtomicUsize,
 }
 
 impl<T> Pool<T> {
     pub fn new() -> Pool<T> {
+        let queue = Arc::new(MsQueue::new());
         Pool {
-            queue: Arc::default(),
+            queue,
             freshest_generation: AtomicUsize::default(),
             next_generation: AtomicUsize::default(),
         }
@@ -57,7 +30,7 @@ impl<T> Pool<T> {
         let next_generation = self.next_generation.fetch_add(1, Ordering::SeqCst) + 1;
         for item in items {
             let gen_item = GenerationItem {
-                item: item,
+                item,
                 generation: next_generation,
             };
             self.queue.push(gen_item);
@@ -68,7 +41,7 @@ impl<T> Pool<T> {
     /// At the exit of this method,
     /// - freshest_generation has a value greater or equal than generation
     /// - freshest_generation has a value that has been advertised
-    /// - freshest_generation has
+    /// - freshest_generation has)
     fn advertise_generation(&self, generation: usize) {
         // not optimal at all but the easiest to read proof.
         loop {
@@ -76,8 +49,11 @@ impl<T> Pool<T> {
             if former_generation >= generation {
                 break;
             }
-            self.freshest_generation
-                .compare_and_swap(former_generation, generation, Ordering::SeqCst);
+            self.freshest_generation.compare_and_swap(
+                former_generation,
+                generation,
+                Ordering::SeqCst,
+            );
         }
     }
 
@@ -91,21 +67,20 @@ impl<T> Pool<T> {
             let gen_item = self.queue.pop();
             if gen_item.generation >= generation {
                 return LeasedItem {
-                           gen_item: Some(gen_item),
-                           recycle_queue: self.queue.clone(),
-                       };
+                    gen_item: Some(gen_item),
+                    recycle_queue: Arc::clone(&self.queue),
+                };
             } else {
                 // this searcher is obsolete,
                 // removing it from the pool.
             }
         }
-
     }
 }
 
 pub struct LeasedItem<T> {
     gen_item: Option<GenerationItem<T>>,
-    recycle_queue: Arc<NonLeakingMsQueue<GenerationItem<T>>>,
+    recycle_queue: Arc<MsQueue<GenerationItem<T>>>,
 }
 
 impl<T> Deref for LeasedItem<T> {
@@ -113,18 +88,18 @@ impl<T> Deref for LeasedItem<T> {
 
     fn deref(&self) -> &T {
         &self.gen_item
-             .as_ref()
-             .expect("Unwrapping a leased item should never fail")
-             .item // unwrap is safe here
+            .as_ref()
+            .expect("Unwrapping a leased item should never fail")
+            .item // unwrap is safe here
     }
 }
 
 impl<T> DerefMut for LeasedItem<T> {
     fn deref_mut(&mut self) -> &mut T {
         &mut self.gen_item
-                 .as_mut()
-                 .expect("Unwrapping a mut leased item should never fail")
-                 .item // unwrap is safe here
+            .as_mut()
+            .expect("Unwrapping a mut leased item should never fail")
+            .item // unwrap is safe here
     }
 }
 
@@ -136,8 +111,6 @@ impl<T> Drop for LeasedItem<T> {
     }
 }
 
-
-
 #[cfg(test)]
 mod tests {
 

src/core/searcher.rs

@@ -6,11 +6,11 @@ use common::TimerTree;
 use query::Query;
 use DocId;
 use DocAddress;
-use schema::Term;
-use termdict::TermMerger;
+use schema::{Field, Term};
+use termdict::{TermDictionary, TermMerger};
+use std::sync::Arc;
 use std::fmt;
-use postings::TermInfo;
-
+use core::InvertedIndexReader;
 
 /// Holds a list of `SegmentReader`s ready for search.
 ///
@@ -21,7 +21,6 @@ pub struct Searcher {
     segment_readers: Vec<SegmentReader>,
 }
 
-
 impl Searcher {
     /// Fetches a document from tantivy's store given a `DocAddress`.
     ///
@@ -46,7 +45,7 @@ impl Searcher {
     pub fn doc_freq(&self, term: &Term) -> u32 {
         self.segment_readers
             .iter()
-            .map(|segment_reader| segment_reader.doc_freq(term))
+            .map(|segment_reader| segment_reader.inverted_index(term.field()).doc_freq(term))
             .fold(0u32, |acc, val| acc + val)
     }
 
@@ -65,23 +64,39 @@ impl Searcher {
         query.search(self, collector)
     }
 
-    /// Returns a Stream over all of the sorted unique terms of
-    /// the searcher.
-    ///
-    /// This includes all of the fields from all of the segment_readers.
-    /// See [`TermIterator`](struct.TermIterator.html).
-    ///
-    /// # Warning
-    /// This API is very likely to change in the future.
-    pub fn terms(&self) -> TermMerger<TermInfo> {
-        TermMerger::from(self.segment_readers())
+    /// Return the field searcher associated to a `Field`.
+    pub fn field(&self, field: Field) -> FieldSearcher {
+        let inv_index_readers = self.segment_readers
+            .iter()
+            .map(|segment_reader| segment_reader.inverted_index(field))
+            .collect::<Vec<_>>();
+        FieldSearcher::new(inv_index_readers)
     }
 }
 
+pub struct FieldSearcher {
+    inv_index_readers: Vec<Arc<InvertedIndexReader>>,
+}
+
+impl FieldSearcher {
+    fn new(inv_index_readers: Vec<Arc<InvertedIndexReader>>) -> FieldSearcher {
+        FieldSearcher { inv_index_readers }
+    }
+
+    /// Returns a Stream over all of the sorted unique terms of
+    /// for the given field.
+    pub fn terms(&self) -> TermMerger {
+        let term_streamers: Vec<_> = self.inv_index_readers
+            .iter()
+            .map(|inverted_index| inverted_index.terms().stream())
+            .collect();
+        TermMerger::new(term_streamers)
+    }
+}
 
 impl From<Vec<SegmentReader>> for Searcher {
     fn from(segment_readers: Vec<SegmentReader>) -> Searcher {
-        Searcher { segment_readers: segment_readers }
+        Searcher { segment_readers }
     }
 }
 

src/core/segment.rs

@@ -3,7 +3,7 @@ use std::path::PathBuf;
 use schema::Schema;
 use std::fmt;
 use core::SegmentId;
-use directory::{ReadOnlySource, WritePtr, FileProtection};
+use directory::{FileProtection, ReadOnlySource, WritePtr};
 use indexer::segment_serializer::SegmentSerializer;
 use super::SegmentComponent;
 use core::Index;
@@ -29,13 +29,15 @@ impl fmt::Debug for Segment {
 ///
 /// The function is here to make it private outside `tantivy`.
 pub fn create_segment(index: Index, meta: SegmentMeta) -> Segment {
-    Segment {
-        index: index,
-        meta: meta,
-    }
+    Segment { index, meta }
 }
 
 impl Segment {
+    /// Returns the index the segment belongs to.
+    pub fn index(&self) -> &Index {
+        &self.index
+    }
+
     /// Returns our index's schema.
     pub fn schema(&self) -> Schema {
         self.index.schema()
@@ -64,7 +66,6 @@ impl Segment {
         self.meta.relative_path(component)
     }
 
-
     /// Protects a specific component file from being deleted.
     ///
     /// Returns a FileProtection object. The file is guaranteed
@@ -76,20 +77,22 @@ impl Segment {
     }
 
     /// Open one of the component file for a *regular* read.
-    pub fn open_read(&self,
-                     component: SegmentComponent)
-                     -> result::Result<ReadOnlySource, OpenReadError> {
+    pub fn open_read(
+        &self,
+        component: SegmentComponent,
+    ) -> result::Result<ReadOnlySource, OpenReadError> {
         let path = self.relative_path(component);
-        let source = try!(self.index.directory().open_read(&path));
+        let source = self.index.directory().open_read(&path)?;
         Ok(source)
     }
 
     /// Open one of the component file for *regular* write.
-    pub fn open_write(&mut self,
-                      component: SegmentComponent)
-                      -> result::Result<WritePtr, OpenWriteError> {
+    pub fn open_write(
+        &mut self,
+        component: SegmentComponent,
+    ) -> result::Result<WritePtr, OpenWriteError> {
         let path = self.relative_path(component);
-        let write = try!(self.index.directory_mut().open_write(&path));
+        let write = self.index.directory_mut().open_write(&path)?;
         Ok(write)
     }
 }
@@ -125,11 +128,11 @@ mod tests {
         {
             let _file_protection = segment.protect_from_delete(SegmentComponent::POSTINGS);
             assert!(directory.exists(&*path));
-            directory.garbage_collect(living_files.clone());
+            directory.garbage_collect(|| living_files.clone());
             assert!(directory.exists(&*path));
         }
 
-        directory.garbage_collect(living_files);
+        directory.garbage_collect(|| living_files);
         assert!(!directory.exists(&*path));
     }
 

src/core/segment_component.rs

@@ -1,4 +1,3 @@
-
 /// Enum describing each component of a tantivy segment.
 /// Each component is stored in its own file,
 /// using the pattern `segment_uuid`.`component_extension`,
@@ -28,13 +27,15 @@ pub enum SegmentComponent {
 impl SegmentComponent {
     /// Iterates through the components.
     pub fn iterator() -> impl Iterator<Item = &'static SegmentComponent> {
-        static SEGMENT_COMPONENTS: [SegmentComponent; 7] = [SegmentComponent::POSTINGS,
-                                                            SegmentComponent::POSITIONS,
-                                                            SegmentComponent::FASTFIELDS,
-                                                            SegmentComponent::FIELDNORMS,
-                                                            SegmentComponent::TERMS,
-                                                            SegmentComponent::STORE,
-                                                            SegmentComponent::DELETE];
+        static SEGMENT_COMPONENTS: [SegmentComponent; 7] = [
+            SegmentComponent::POSTINGS,
+            SegmentComponent::POSITIONS,
+            SegmentComponent::FASTFIELDS,
+            SegmentComponent::FIELDNORMS,
+            SegmentComponent::TERMS,
+            SegmentComponent::STORE,
+            SegmentComponent::DELETE,
+        ];
         SEGMENT_COMPONENTS.into_iter()
     }
 }

src/core/segment_id.rs

@@ -1,11 +1,11 @@
 use uuid::Uuid;
 use std::fmt;
-use std::cmp::{Ordering, Ord};
+use std::cmp::{Ord, Ordering};
 
 #[cfg(test)]
 use std::sync::atomic;
 
-/// Tantivy `SegmentId`.
+/// Uuid identifying a segment.
 ///
 /// Tantivy's segment are identified
 /// by a UUID which is used to prefix the filenames
@@ -16,14 +16,12 @@ use std::sync::atomic;
 #[derive(Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub struct SegmentId(Uuid);
 
-
 #[cfg(test)]
 lazy_static! {
     static ref AUTO_INC_COUNTER: atomic::AtomicUsize = atomic::AtomicUsize::default();
     static ref EMPTY_ARR: [u8; 8] = [0u8; 8];
 }
 
-
 // During tests, we generate the segment id in a autoincrement manner
 // for consistency of segment id between run.
 //
@@ -46,7 +44,6 @@ impl SegmentId {
         SegmentId(create_uuid())
     }
 
-
     /// Returns a shorter identifier of the segment.
     ///
     /// We are using UUID4, so only 6 bits are fixed,
@@ -70,7 +67,6 @@ impl fmt::Debug for SegmentId {
     }
 }
 
-
 impl PartialOrd for SegmentId {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         Some(self.cmp(other))

src/core/segment_meta.rs

@@ -25,7 +25,7 @@ impl SegmentMeta {
     /// a segment with no deletes and no documents.
     pub fn new(segment_id: SegmentId) -> SegmentMeta {
         SegmentMeta {
-            segment_id: segment_id,
+            segment_id,
             max_doc: 0,
             deletes: None,
         }
@@ -54,7 +54,6 @@ impl SegmentMeta {
         SegmentComponent::iterator()
             .map(|component| self.relative_path(*component))
             .collect::<HashSet<PathBuf>>()
-
     }
 
     /// Returns the relative path of a component of our segment.
@@ -64,16 +63,14 @@ impl SegmentMeta {
     pub fn relative_path(&self, component: SegmentComponent) -> PathBuf {
         let mut path = self.id().uuid_string();
         path.push_str(&*match component {
-                           SegmentComponent::POSITIONS => ".pos".to_string(),
-                           SegmentComponent::POSTINGS => ".idx".to_string(),
-                           SegmentComponent::TERMS => ".term".to_string(),
-                           SegmentComponent::STORE => ".store".to_string(),
-                           SegmentComponent::FASTFIELDS => ".fast".to_string(),
-                           SegmentComponent::FIELDNORMS => ".fieldnorm".to_string(),
-                           SegmentComponent::DELETE => {
-                               format!(".{}.del", self.delete_opstamp().unwrap_or(0))
-                           }
-                       });
+            SegmentComponent::POSITIONS => ".pos".to_string(),
+            SegmentComponent::POSTINGS => ".idx".to_string(),
+            SegmentComponent::TERMS => ".term".to_string(),
+            SegmentComponent::STORE => ".store".to_string(),
+            SegmentComponent::FASTFIELDS => ".fast".to_string(),
+            SegmentComponent::FIELDNORMS => ".fieldnorm".to_string(),
+            SegmentComponent::DELETE => format!(".{}.del", self.delete_opstamp().unwrap_or(0)),
+        });
         PathBuf::from(path)
     }
 
@@ -111,8 +108,8 @@ impl SegmentMeta {
     #[doc(hidden)]
     pub fn set_delete_meta(&mut self, num_deleted_docs: u32, opstamp: u64) {
         self.deletes = Some(DeleteMeta {
-                                num_deleted_docs: num_deleted_docs,
-                                opstamp: opstamp,
-                            });
+            num_deleted_docs,
+            opstamp,
+        });
     }
 }

src/core/segment_reader.rs

@@ -2,30 +2,23 @@ use Result;
 use core::Segment;
 use core::SegmentId;
 use core::SegmentComponent;
-use schema::Term;
+use std::sync::RwLock;
 use common::HasLen;
 use core::SegmentMeta;
 use fastfield::{self, FastFieldNotAvailableError};
 use fastfield::DeleteBitSet;
 use store::StoreReader;
-use schema::Document;
 use directory::ReadOnlySource;
+use schema::Document;
 use DocId;
-use std::str;
-use termdict::TermDictionary;
-use std::cmp;
-use postings::TermInfo;
-use termdict::TermDictionaryImpl;
 use std::sync::Arc;
+use std::collections::HashMap;
+use common::CompositeFile;
 use std::fmt;
+use core::InvertedIndexReader;
 use schema::Field;
-use postings::SegmentPostingsOption;
-use postings::{SegmentPostings, BlockSegmentPostings};
-use fastfield::{FastFieldsReader, FastFieldReader, U64FastFieldReader};
+use fastfield::{FastFieldReader, U64FastFieldReader};
 use schema::Schema;
-use postings::FreqHandler;
-
-
 
 /// Entry point to access all of the datastructures of the `Segment`
 ///
@@ -40,15 +33,19 @@ use postings::FreqHandler;
 ///
 #[derive(Clone)]
 pub struct SegmentReader {
+    inv_idx_reader_cache: Arc<RwLock<HashMap<Field, Arc<InvertedIndexReader>>>>,
+
     segment_id: SegmentId,
     segment_meta: SegmentMeta,
-    terms: Arc<TermDictionaryImpl>,
-    postings_data: ReadOnlySource,
+
+    termdict_composite: CompositeFile,
+    postings_composite: CompositeFile,
+    positions_composite: CompositeFile,
+    fast_fields_composite: CompositeFile,
+    fieldnorms_composite: CompositeFile,
+
     store_reader: StoreReader,
-    fast_fields_reader: Arc<FastFieldsReader>,
-    fieldnorms_reader: Arc<FastFieldsReader>,
     delete_bitset: DeleteBitSet,
-    positions_data: ReadOnlySource,
     schema: Schema,
 }
 
@@ -76,11 +73,6 @@ impl SegmentReader {
         self.delete_bitset.len() as DocId
     }
 
-    #[doc(hidden)]
-    pub fn fast_fields_reader(&self) -> &FastFieldsReader {
-        &*self.fast_fields_reader
-    }
-
     /// Accessor to a segment's fast field reader given a field.
     ///
     /// Returns the u64 fast value reader if the field
@@ -91,17 +83,18 @@ impl SegmentReader {
     ///
     /// # Panics
     /// May panic if the index is corrupted.
-    pub fn get_fast_field_reader<TFastFieldReader: FastFieldReader>
-        (&self,
-         field: Field)
-         -> fastfield::Result<TFastFieldReader> {
+    pub fn get_fast_field_reader<TFastFieldReader: FastFieldReader>(
+        &self,
+        field: Field,
+    ) -> fastfield::Result<TFastFieldReader> {
         let field_entry = self.schema.get_field_entry(field);
         if !TFastFieldReader::is_enabled(field_entry.field_type()) {
             Err(FastFieldNotAvailableError::new(field_entry))
         } else {
-            Ok(self.fast_fields_reader
-                   .open_reader(field)
-                   .expect("Fast field file corrupted."))
+            self.fast_fields_composite
+                .open_read(field)
+                .ok_or_else(|| FastFieldNotAvailableError::new(field_entry))
+                .map(TFastFieldReader::open)
         }
     }
 
@@ -114,15 +107,9 @@ impl SegmentReader {
     /// They are simply stored as a fast field, serialized in
     /// the `.fieldnorm` file of the segment.
     pub fn get_fieldnorms_reader(&self, field: Field) -> Option<U64FastFieldReader> {
-        self.fieldnorms_reader.open_reader(field)
-    }
-
-    /// Returns the number of documents containing the term.
-    pub fn doc_freq(&self, term: &Term) -> u32 {
-        match self.get_term_info(term) {
-            Some(term_info) => term_info.doc_freq,
-            None => 0,
-        }
+        self.fieldnorms_composite
+            .open_read(field)
+            .map(U64FastFieldReader::open)
     }
 
     /// Accessor to the segment's `StoreReader`.
@@ -131,25 +118,29 @@ impl SegmentReader {
     }
 
     /// Open a new segment for reading.
-    pub fn open(segment: Segment) -> Result<SegmentReader> {
-
-        let source = segment.open_read(SegmentComponent::TERMS)?;
-        let terms = TermDictionaryImpl::from_source(source)?;
+    pub fn open(segment: &Segment) -> Result<SegmentReader> {
+        let termdict_source = segment.open_read(SegmentComponent::TERMS)?;
+        let termdict_composite = CompositeFile::open(&termdict_source)?;
 
         let store_source = segment.open_read(SegmentComponent::STORE)?;
         let store_reader = StoreReader::from_source(store_source);
 
-        let postings_shared_mmap = segment.open_read(SegmentComponent::POSTINGS)?;
+        let postings_source = segment.open_read(SegmentComponent::POSTINGS)?;
+        let postings_composite = CompositeFile::open(&postings_source)?;
 
-        let fast_field_data = segment.open_read(SegmentComponent::FASTFIELDS)?;
-        let fast_fields_reader = FastFieldsReader::from_source(fast_field_data)?;
+        let positions_composite = {
+            if let Ok(source) = segment.open_read(SegmentComponent::POSITIONS) {
+                CompositeFile::open(&source)?
+            } else {
+                CompositeFile::empty()
+            }
+        };
+
+        let fast_fields_data = segment.open_read(SegmentComponent::FASTFIELDS)?;
+        let fast_fields_composite = CompositeFile::open(&fast_fields_data)?;
 
         let fieldnorms_data = segment.open_read(SegmentComponent::FIELDNORMS)?;
-        let fieldnorms_reader = FastFieldsReader::from_source(fieldnorms_data)?;
-
-        let positions_data = segment
-            .open_read(SegmentComponent::POSITIONS)
-            .unwrap_or_else(|_| ReadOnlySource::empty());
+        let fieldnorms_composite = CompositeFile::open(&fieldnorms_data)?;
 
         let delete_bitset = if segment.meta().has_deletes() {
             let delete_data = segment.open_read(SegmentComponent::DELETE)?;
@@ -160,22 +151,62 @@ impl SegmentReader {
 
         let schema = segment.schema();
         Ok(SegmentReader {
-               segment_meta: segment.meta().clone(),
-               postings_data: postings_shared_mmap,
-               terms: Arc::new(terms),
-               segment_id: segment.id(),
-               store_reader: store_reader,
-               fast_fields_reader: Arc::new(fast_fields_reader),
-               fieldnorms_reader: Arc::new(fieldnorms_reader),
-               delete_bitset: delete_bitset,
-               positions_data: positions_data,
-               schema: schema,
-           })
+            inv_idx_reader_cache: Arc::new(RwLock::new(HashMap::new())),
+            segment_meta: segment.meta().clone(),
+            termdict_composite,
+            postings_composite,
+            fast_fields_composite,
+            fieldnorms_composite,
+            segment_id: segment.id(),
+            store_reader,
+            delete_bitset,
+            positions_composite,
+            schema,
+        })
     }
 
-    /// Return the term dictionary datastructure.
-    pub fn terms(&self) -> &TermDictionaryImpl {
-        &self.terms
+    /// Returns a field reader associated to the field given in argument.
+    ///
+    /// The field reader is in charge of iterating through the
+    /// term dictionary associated to a specific field,
+    /// and opening the posting list associated to any term.
+    pub fn inverted_index(&self, field: Field) -> Arc<InvertedIndexReader> {
+        if let Some(inv_idx_reader) = self.inv_idx_reader_cache
+            .read()
+            .expect("Lock poisoned. This should never happen")
+            .get(&field)
+        {
+            Arc::clone(inv_idx_reader);
+        }
+
+        let termdict_source: ReadOnlySource = self.termdict_composite
+            .open_read(field)
+            .expect("Index corrupted. Failed to open field term dictionary in composite file.");
+
+        let postings_source = self.postings_composite
+            .open_read(field)
+            .expect("Index corrupted. Failed to open field postings in composite file.");
+
+        let positions_source = self.positions_composite
+            .open_read(field)
+            .expect("Index corrupted. Failed to open field positions in composite file.");
+
+        let inv_idx_reader = Arc::new(InvertedIndexReader::new(
+            termdict_source,
+            postings_source,
+            positions_source,
+            self.delete_bitset.clone(),
+            self.schema.clone(),
+        ));
+
+        // by releasing the lock in between, we may end up opening the inverting index
+        // twice, but this is fine.
+        self.inv_idx_reader_cache
+            .write()
+            .expect("Field reader cache lock poisoned. This should never happen.")
+            .insert(field, Arc::clone(&inv_idx_reader));
+
+        inv_idx_reader
     }
 
     /// Returns the document (or to be accurate, its stored field)
@@ -186,90 +217,6 @@ impl SegmentReader {
         self.store_reader.get(doc_id)
     }
 
-
-    /// Returns the segment postings associated with the term, and with the given option,
-    /// or `None` if the term has never been encounterred and indexed.
-    ///
-    /// If the field was not indexed with the indexing options that cover
-    /// the requested options, the returned `SegmentPostings` the method does not fail
-    /// and returns a `SegmentPostings` with as much information as possible.
-    ///
-    /// For instance, requesting `SegmentPostingsOption::FreqAndPositions` for a
-    /// `TextIndexingOptions` that does not index position will return a `SegmentPostings`
-    /// with `DocId`s and frequencies.
-    pub fn read_postings(&self,
-                         term: &Term,
-                         option: SegmentPostingsOption)
-                         -> Option<SegmentPostings> {
-        let field = term.field();
-        let field_entry = self.schema.get_field_entry(field);
-        let term_info = get!(self.get_term_info(term));
-        let maximum_option = get!(field_entry.field_type().get_segment_postings_option());
-        let best_effort_option = cmp::min(maximum_option, option);
-        Some(self.read_postings_from_terminfo(&term_info, best_effort_option))
-    }
-
-
-    /// Returns a posting object given a `term_info`.
-    /// This method is for an advanced usage only.
-    ///
-    /// Most user should prefer using `read_postings` instead.
-    pub fn read_postings_from_terminfo(&self,
-                                       term_info: &TermInfo,
-                                       option: SegmentPostingsOption)
-                                       -> SegmentPostings {
-        let block_postings = self.read_block_postings_from_terminfo(term_info, option);
-        let delete_bitset = self.delete_bitset.clone();
-        SegmentPostings::from_block_postings(block_postings, delete_bitset)
-    }
-
-
-    /// Returns a block postings given a `term_info`.
-    /// This method is for an advanced usage only.
-    ///
-    /// Most user should prefer using `read_postings` instead.
-    pub fn read_block_postings_from_terminfo(&self,
-                                             term_info: &TermInfo,
-                                             option: SegmentPostingsOption)
-                                             -> BlockSegmentPostings {
-        let offset = term_info.postings_offset as usize;
-        let postings_data = &self.postings_data[offset..];
-        let freq_handler = match option {
-            SegmentPostingsOption::NoFreq => FreqHandler::new_without_freq(),
-            SegmentPostingsOption::Freq => FreqHandler::new_with_freq(),
-            SegmentPostingsOption::FreqAndPositions => {
-                let offset = term_info.positions_offset as usize;
-                let offseted_position_data = &self.positions_data[offset..];
-                FreqHandler::new_with_freq_and_position(offseted_position_data)
-            }
-        };
-        BlockSegmentPostings::from_data(term_info.doc_freq as usize, postings_data, freq_handler)
-    }
-
-
-    /// Resets the block segment to another position of the postings
-    /// file.
-    ///
-    /// This is useful for enumerating through a list of terms,
-    /// and consuming the associated posting lists while avoiding
-    /// reallocating a `BlockSegmentPostings`.
-    ///
-    /// # Warning
-    ///
-    /// This does not reset the positions list.
-    pub fn reset_block_postings_from_terminfo<'a>(&'a self,
-                                                  term_info: &TermInfo,
-                                                  block_postings: &mut BlockSegmentPostings<'a>) {
-        let offset = term_info.postings_offset as usize;
-        let postings_data: &'a [u8] = &self.postings_data[offset..];
-        block_postings.reset(term_info.doc_freq as usize, postings_data);
-    }
-
-    /// Returns the term info associated with the term.
-    pub fn get_term_info(&self, term: &Term) -> Option<TermInfo> {
-        self.terms.get(term.as_slice())
-    }
-
     /// Returns the segment id
     pub fn segment_id(&self) -> SegmentId {
         self.segment_id
@@ -281,7 +228,6 @@ impl SegmentReader {
         &self.delete_bitset
     }
 
-
     /// Returns true iff the `doc` is marked
     /// as deleted.
     pub fn is_deleted(&self, doc: DocId) -> bool {
@@ -289,7 +235,6 @@ impl SegmentReader {
     }
 }
 
-
 impl fmt::Debug for SegmentReader {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "SegmentReader({:?})", self.segment_id)

src/datastruct/mod.rs

@@ -1,4 +1,4 @@
 mod skip;
 pub mod stacker;
 
-pub use self::skip::{SkipListBuilder, SkipList};
+pub use self::skip::{SkipList, SkipListBuilder};

src/datastruct/skip/mod.rs

@@ -6,8 +6,6 @@ mod skiplist;
 pub use self::skiplist_builder::SkipListBuilder;
 pub use self::skiplist::SkipList;
 
-
-
 #[cfg(test)]
 mod tests {
 

src/datastruct/skip/skiplist.rs

@@ -32,9 +32,9 @@ impl<'a, T: BinarySerializable> From<&'a [u8]> for 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,
+            data,
+            cursor,
+            next_id,
             _phantom_: PhantomData,
         }
     }
@@ -76,7 +76,6 @@ impl<'a, T: BinarySerializable> Layer<'a, T> {
     }
 }
 
-
 pub struct SkipList<'a, T: BinarySerializable> {
     data_layer: Layer<'a, T>,
     skip_layers: Vec<Layer<'a, u32>>,
@@ -106,7 +105,6 @@ impl<'a, T: BinarySerializable> SkipList<'a, T> {
     }
 }
 
-
 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();
@@ -123,8 +121,8 @@ impl<'a, T: BinarySerializable> From<&'a [u8]> for SkipList<'a, T> {
             .map(|(start, stop)| Layer::from(&layers_data[start..stop]))
             .collect();
         SkipList {
-            skip_layers: skip_layers,
-            data_layer: data_layer,
+            skip_layers,
+            data_layer,
         }
     }
 }

src/datastruct/skip/skiplist_builder.rs

@@ -24,7 +24,7 @@ impl<T: BinarySerializable> LayerBuilder<T> {
 
     fn with_period(period: usize) -> LayerBuilder<T> {
         LayerBuilder {
-            period: period,
+            period,
             buffer: Vec::new(),
             remaining: period,
             len: 0,
@@ -39,26 +39,24 @@ impl<T: BinarySerializable> LayerBuilder<T> {
         doc_id.serialize(&mut self.buffer)?;
         value.serialize(&mut self.buffer)?;
         Ok(if self.remaining == 0 {
-               self.remaining = self.period;
-               Some((doc_id, offset))
-           } else {
-               None
-           })
+            self.remaining = self.period;
+            Some((doc_id, offset))
+        } else {
+            None
+        })
     }
 }
 
-
 pub struct SkipListBuilder<T: BinarySerializable> {
     period: usize,
     data_layer: LayerBuilder<T>,
     skip_layers: Vec<LayerBuilder<u32>>,
 }
 
-
 impl<T: BinarySerializable> SkipListBuilder<T> {
     pub fn new(period: usize) -> SkipListBuilder<T> {
         SkipListBuilder {
-            period: period,
+            period,
             data_layer: LayerBuilder::with_period(period),
             skip_layers: Vec::new(),
         }
@@ -74,13 +72,11 @@ impl<T: BinarySerializable> SkipListBuilder<T> {
 
     pub fn insert(&mut self, doc_id: DocId, dest: &T) -> io::Result<()> {
         let mut layer_id = 0;
-        let mut skip_pointer = try!(self.data_layer.insert(doc_id, dest));
+        let mut skip_pointer = self.data_layer.insert(doc_id, dest)?;
         loop {
             skip_pointer = match skip_pointer {
-                Some((skip_doc_id, skip_offset)) => {
-                    try!(self.get_skip_layer(layer_id)
-                             .insert(skip_doc_id, &skip_offset))
-                }
+                Some((skip_doc_id, skip_offset)) => self.get_skip_layer(layer_id)
+                    .insert(skip_doc_id, &skip_offset)?,
                 None => {
                     return Ok(());
                 }

src/datastruct/stacker/expull.rs

@@ -1,7 +1,6 @@
 use std::mem;
 use super::heap::{Heap, HeapAllocable};
 
-
 #[inline]
 pub fn is_power_of_2(val: u32) -> bool {
     val & (val - 1) == 0
@@ -12,7 +11,6 @@ pub fn jump_needed(val: u32) -> bool {
     val > 3 && is_power_of_2(val)
 }
 
-
 #[derive(Debug, Clone)]
 pub struct ExpUnrolledLinkedList {
     len: u32,
@@ -26,7 +24,7 @@ pub struct ExpUnrolledLinkedList {
 impl ExpUnrolledLinkedList {
     pub fn iter<'a>(&self, addr: u32, heap: &'a Heap) -> ExpUnrolledLinkedListIterator<'a> {
         ExpUnrolledLinkedListIterator {
-            heap: heap,
+            heap,
             addr: addr + 2u32 * (mem::size_of::<u32>() as u32),
             len: self.len,
             consumed: 0,
@@ -51,7 +49,6 @@ impl ExpUnrolledLinkedList {
     }
 }
 
-
 impl HeapAllocable for u32 {
     fn with_addr(_addr: u32) -> u32 {
         0u32
@@ -96,14 +93,9 @@ impl<'a> Iterator for ExpUnrolledLinkedListIterator<'a> {
             self.addr = addr + mem::size_of::<u32>() as u32;
             Some(*self.heap.get_mut_ref(addr))
         }
-
     }
 }
 
-
-
-
-
 #[cfg(test)]
 mod tests {
 

src/datastruct/stacker/hashmap.rs

@@ -1,6 +1,6 @@
 use std::iter;
 use std::mem;
-use super::heap::{Heap, HeapAllocable, BytesRef};
+use super::heap::{BytesRef, Heap, HeapAllocable};
 
 mod murmurhash2 {
 
@@ -9,7 +9,7 @@ mod murmurhash2 {
     #[inline(always)]
     pub fn murmurhash2(key: &[u8]) -> u32 {
         let mut key_ptr: *const u32 = key.as_ptr() as *const u32;
-        let m: u32 = 0x5bd1e995;
+        let m: u32 = 0x5bd1_e995;
         let r = 24;
         let len = key.len() as u32;
 
@@ -30,18 +30,18 @@ mod murmurhash2 {
         let key_ptr_u8: *const u8 = key_ptr as *const u8;
         match remaining {
             3 => {
-                h ^= unsafe { *key_ptr_u8.wrapping_offset(2) as u32 } << 16;
-                h ^= unsafe { *key_ptr_u8.wrapping_offset(1) as u32 } << 8;
-                h ^= unsafe { *key_ptr_u8 as u32 };
+                h ^= unsafe { u32::from(*key_ptr_u8.wrapping_offset(2)) } << 16;
+                h ^= unsafe { u32::from(*key_ptr_u8.wrapping_offset(1)) } << 8;
+                h ^= unsafe { u32::from(*key_ptr_u8) };
                 h = h.wrapping_mul(m);
             }
             2 => {
-                h ^= unsafe { *key_ptr_u8.wrapping_offset(1) as u32 } << 8;
-                h ^= unsafe { *key_ptr_u8 as u32 };
+                h ^= unsafe { u32::from(*key_ptr_u8.wrapping_offset(1)) } << 8;
+                h ^= unsafe { u32::from(*key_ptr_u8) };
                 h = h.wrapping_mul(m);
             }
             1 => {
-                h ^= unsafe { *key_ptr_u8 as u32 };
+                h ^= unsafe { u32::from(*key_ptr_u8) };
                 h = h.wrapping_mul(m);
             }
             _ => {}
@@ -52,31 +52,29 @@ mod murmurhash2 {
     }
 }
 
-
-
-
 /// Split the thread memory budget into
 /// - the heap size
 /// - the hash table "table" itself.
 ///
 /// Returns (the heap size in bytes, the hash table size in number of bits)
 pub(crate) fn split_memory(per_thread_memory_budget: usize) -> (usize, usize) {
-    let table_size_limit: usize = per_thread_memory_budget / 3;
+    let table_size_limit: usize = per_thread_memory_budget / 5;
     let compute_table_size = |num_bits: usize| {
-        let table_size: usize = (1 << num_bits) * mem::size_of::<KeyValue>();
-        table_size * mem::size_of::<KeyValue>()
+        (1 << num_bits) * mem::size_of::<KeyValue>()
     };
     let table_num_bits: usize = (1..)
         .into_iter()
         .take_while(|num_bits: &usize| compute_table_size(*num_bits) < table_size_limit)
         .last()
-        .expect(&format!("Per thread memory is too small: {}", per_thread_memory_budget));
+        .expect(&format!(
+            "Per thread memory is too small: {}",
+            per_thread_memory_budget
+        ));
     let table_size = compute_table_size(table_num_bits);
     let heap_size = per_thread_memory_budget - table_size;
     (heap_size, table_num_bits)
 }
 
-
 /// `KeyValue` is the item stored in the hash table.
 /// The key is actually a `BytesRef` object stored in an external heap.
 /// The `value_addr` also points to an address in the heap.
@@ -85,7 +83,6 @@ pub(crate) fn split_memory(per_thread_memory_budget: usize) -> (usize, usize) {
 /// For this reason, the (start, stop) information is actually redundant
 /// and can be simplified in the future
 #[derive(Copy, Clone, Default)]
-#[repr(packed)]
 struct KeyValue {
     key_value_addr: BytesRef,
     hash: u32,
@@ -97,7 +94,6 @@ impl KeyValue {
     }
 }
 
-
 /// Customized `HashMap` with string keys
 ///
 /// This `HashMap` takes String as keys. Keys are
@@ -114,7 +110,6 @@ pub struct HashMap<'a> {
     occupied: Vec<usize>,
 }
 
-
 struct QuadraticProbing {
     hash: usize,
     i: usize,
@@ -123,11 +118,7 @@ struct QuadraticProbing {
 
 impl QuadraticProbing {
     fn compute(hash: usize, mask: usize) -> QuadraticProbing {
-        QuadraticProbing {
-            hash: hash,
-            i: 0,
-            mask: mask,
-        }
+        QuadraticProbing { hash, i: 0, mask }
     }
 
     #[inline]
@@ -137,14 +128,13 @@ impl QuadraticProbing {
     }
 }
 
-
 impl<'a> HashMap<'a> {
     pub fn new(num_bucket_power_of_2: usize, heap: &'a Heap) -> HashMap<'a> {
         let table_size = 1 << num_bucket_power_of_2;
         let table: Vec<KeyValue> = iter::repeat(KeyValue::default()).take(table_size).collect();
         HashMap {
             table: table.into_boxed_slice(),
-            heap: heap,
+            heap,
             mask: table_size - 1,
             occupied: Vec::with_capacity(table_size / 2),
         }
@@ -169,21 +159,17 @@ impl<'a> HashMap<'a> {
         self.occupied.push(bucket);
         self.table[bucket] = KeyValue {
             key_value_addr: key_bytes_ref,
-            hash: hash,
+            hash,
         };
     }
 
     pub fn iter<'b: 'a>(&'b self) -> impl Iterator<Item = (&'a [u8], u32)> + 'b {
-        self.occupied
-            .iter()
-            .cloned()
-            .map(move |bucket: usize| {
-                     let kv = self.table[bucket];
-                     self.get_key_value(kv.key_value_addr)
-                 })
+        self.occupied.iter().cloned().map(move |bucket: usize| {
+            let kv = self.table[bucket];
+            self.get_key_value(kv.key_value_addr)
+        })
     }
 
-
     pub fn get_or_create<S: AsRef<[u8]>, V: HeapAllocable>(&mut self, key: S) -> &mut V {
         let key_bytes: &[u8] = key.as_ref();
         let hash = murmurhash2::murmurhash2(key.as_ref());
@@ -207,7 +193,6 @@ impl<'a> HashMap<'a> {
     }
 }
 
-
 #[cfg(test)]
 mod tests {
 
@@ -218,7 +203,6 @@ mod tests {
     use std::collections::HashSet;
     use super::split_memory;
 
-
     struct TestValue {
         val: u32,
         _addr: u32,
@@ -240,7 +224,6 @@ mod tests {
         assert_eq!(split_memory(10_000_000), (7902848, 15));
     }
 
-
     #[test]
     fn test_hash_map() {
         let heap = Heap::with_capacity(2_000_000);
@@ -282,8 +265,10 @@ mod tests {
         let s1 = "abcdef";
         let s2 = "abcdeg";
         for i in 0..5 {
-            assert_eq!(murmurhash2(&s1[i..5].as_bytes()),
-                       murmurhash2(&s2[i..5].as_bytes()));
+            assert_eq!(
+                murmurhash2(&s1[i..5].as_bytes()),
+                murmurhash2(&s2[i..5].as_bytes())
+            );
         }
     }
 
@@ -303,14 +288,13 @@ mod tests {
         let keys: Vec<&'static str> =
             vec!["wer qwe qwe qwe ", "werbq weqweqwe2 ", "weraq weqweqwe3 "];
         b.iter(|| {
-                   keys.iter()
-                       .map(|&s| s.as_bytes())
-                       .map(murmurhash2::murmurhash2)
-                       .map(|h| h as u64)
-                       .last()
-                       .unwrap()
-               });
+            keys.iter()
+                .map(|&s| s.as_bytes())
+                .map(murmurhash2::murmurhash2)
+                .map(|h| h as u64)
+                .last()
+                .unwrap()
+        });
     }
 
-
 }

src/datastruct/stacker/heap.rs

@@ -1,7 +1,7 @@
 use std::cell::UnsafeCell;
 use std::mem;
 use std::ptr;
-use byteorder::{NativeEndian, ByteOrder};
+use byteorder::{ByteOrder, NativeEndian};
 
 /// `BytesRef` refers to a slice in tantivy's custom `Heap`.
 ///
@@ -40,7 +40,9 @@ pub struct Heap {
 impl Heap {
     /// Creates a new heap with a given capacity
     pub fn with_capacity(num_bytes: usize) -> Heap {
-        Heap { inner: UnsafeCell::new(InnerHeap::with_capacity(num_bytes)) }
+        Heap {
+            inner: UnsafeCell::new(InnerHeap::with_capacity(num_bytes)),
+        }
     }
 
     fn inner(&self) -> &mut InnerHeap {
@@ -102,7 +104,6 @@ impl Heap {
     }
 }
 
-
 struct InnerHeap {
     buffer: Vec<u8>,
     buffer_len: u32,
@@ -110,12 +111,11 @@ struct InnerHeap {
     next_heap: Option<Box<InnerHeap>>,
 }
 
-
 impl InnerHeap {
     pub fn with_capacity(num_bytes: usize) -> InnerHeap {
         let buffer: Vec<u8> = vec![0u8; num_bytes];
         InnerHeap {
-            buffer: buffer,
+            buffer,
             buffer_len: num_bytes as u32,
             next_heap: None,
             used: 0u32,
@@ -144,7 +144,10 @@ impl InnerHeap {
             addr
         } else {
             if self.next_heap.is_none() {
-                info!(r#"Exceeded heap size. The segment will be committed right after indexing this document."#,);
+                info!(
+                    r#"Exceeded heap size. The segment will be committed right
+                         after indexing this document."#,
+                );
                 self.next_heap = Some(Box::new(InnerHeap::with_capacity(self.buffer_len as usize)));
             }
             self.next_heap.as_mut().unwrap().allocate_space(num_bytes) + self.buffer_len

src/datastruct/stacker/mod.rs

@@ -39,6 +39,5 @@ fn test_unrolled_linked_list() {
                 assert!(!it.next().is_some());
             }
         }
-
     }
 }

src/directory/directory.rs

@@ -1,7 +1,7 @@
 use std::marker::Send;
 use std::fmt;
 use std::path::Path;
-use directory::error::{OpenReadError, DeleteError, OpenWriteError};
+use directory::error::{DeleteError, OpenReadError, OpenWriteError};
 use directory::{ReadOnlySource, WritePtr};
 use std::result;
 use std::io;

src/directory/error.rs

@@ -33,17 +33,14 @@ impl IOError {
     pub(crate) fn with_path(path: PathBuf, err: io::Error) -> Self {
         IOError {
             path: Some(path),
-            err: err,
+            err,
         }
     }
 }
 
 impl From<io::Error> for IOError {
     fn from(err: io::Error) -> IOError {
-        IOError {
-            path: None,
-            err: err,
-        }
+        IOError { path: None, err }
     }
 }
 
@@ -102,11 +99,11 @@ impl fmt::Display for OpenWriteError {
             OpenWriteError::FileAlreadyExists(ref path) => {
                 write!(f, "the file '{:?}' already exists", path)
             }
-            OpenWriteError::IOError(ref err) => {
-                write!(f,
-                       "an io error occurred while opening a file for writing: '{}'",
-                       err)
-            }
+            OpenWriteError::IOError(ref err) => write!(
+                f,
+                "an io error occurred while opening a file for writing: '{}'",
+                err
+            ),
         }
     }
 }
@@ -146,11 +143,11 @@ impl fmt::Display for OpenReadError {
             OpenReadError::FileDoesNotExist(ref path) => {
                 write!(f, "the file '{:?}' does not exist", path)
             }
-            OpenReadError::IOError(ref err) => {
-                write!(f,
-                       "an io error occurred while opening a file for reading: '{}'",
-                       err)
-            }
+            OpenReadError::IOError(ref err) => write!(
+                f,
+                "an io error occurred while opening a file for reading: '{}'",
+                err
+            ),
         }
     }
 }
@@ -210,8 +207,7 @@ impl StdError for DeleteError {
 
     fn cause(&self) -> Option<&StdError> {
         match *self {
-            DeleteError::FileDoesNotExist(_) |
-            DeleteError::FileProtected(_) => None,
+            DeleteError::FileDoesNotExist(_) | DeleteError::FileProtected(_) => None,
             DeleteError::IOError(ref err) => Some(err),
         }
     }

src/directory/managed_directory.rs

@@ -1,6 +1,6 @@
 use std::path::{Path, PathBuf};
 use serde_json;
-use directory::error::{IOError, OpenReadError, DeleteError, OpenWriteError};
+use directory::error::{DeleteError, IOError, OpenReadError, OpenWriteError};
 use directory::{ReadOnlySource, WritePtr};
 use std::result;
 use std::io;
@@ -12,7 +12,7 @@ use std::io::Write;
 use core::MANAGED_FILEPATH;
 use std::collections::HashMap;
 use std::fmt;
-use error::{Result, ErrorKind, ResultExt};
+use error::{ErrorKind, Result, ResultExt};
 
 /// Wrapper of directories that keeps track of files created by Tantivy.
 ///
@@ -35,7 +35,6 @@ struct MetaInformation {
     protected_files: HashMap<PathBuf, usize>,
 }
 
-
 /// A `FileProtection` prevents the garbage collection of a file.
 ///
 /// See `ManagedDirectory.protect_file_from_delete`.
@@ -68,9 +67,10 @@ impl Drop for FileProtection {
 
 /// Saves the file containing the list of existing files
 /// that were created by tantivy.
-fn save_managed_paths(directory: &mut Directory,
-                      wlock: &RwLockWriteGuard<MetaInformation>)
-                      -> io::Result<()> {
+fn save_managed_paths(
+    directory: &mut Directory,
+    wlock: &RwLockWriteGuard<MetaInformation>,
+) -> io::Result<()> {
     let mut w = serde_json::to_vec(&wlock.managed_paths)?;
     write!(&mut w, "\n")?;
     directory.atomic_write(&MANAGED_FILEPATH, &w[..])?;
@@ -83,24 +83,20 @@ impl ManagedDirectory {
         match directory.atomic_read(&MANAGED_FILEPATH) {
             Ok(data) => {
                 let managed_files_json = String::from_utf8_lossy(&data);
-                let managed_files: HashSet<PathBuf> =
-                    serde_json::from_str(&managed_files_json)
-                        .chain_err(|| ErrorKind::CorruptedFile(MANAGED_FILEPATH.clone()))?;
+                let managed_files: HashSet<PathBuf> = serde_json::from_str(&managed_files_json)
+                    .chain_err(|| ErrorKind::CorruptedFile(MANAGED_FILEPATH.clone()))?;
                 Ok(ManagedDirectory {
-                       directory: box directory,
-                       meta_informations: Arc::new(RwLock::new(MetaInformation {
-                                                                   managed_paths: managed_files,
-                                                                   protected_files:
-                                                                       HashMap::default(),
-                                                               })),
-                   })
-            }
-            Err(OpenReadError::FileDoesNotExist(_)) => {
-                Ok(ManagedDirectory {
-                       directory: box directory,
-                       meta_informations: Arc::default(),
-                   })
+                    directory: box directory,
+                    meta_informations: Arc::new(RwLock::new(MetaInformation {
+                        managed_paths: managed_files,
+                        protected_files: HashMap::default(),
+                    })),
+                })
             }
+            Err(OpenReadError::FileDoesNotExist(_)) => Ok(ManagedDirectory {
+                directory: box directory,
+                meta_informations: Arc::default(),
+            }),
             Err(OpenReadError::IOError(e)) => Err(From::from(e)),
         }
     }
@@ -116,15 +112,25 @@ impl ManagedDirectory {
     /// If a file cannot be deleted (for permission reasons for instance)
     /// an error is simply logged, and the file remains in the list of managed
     /// files.
-    pub fn garbage_collect(&mut self, living_files: HashSet<PathBuf>) {
+    pub fn garbage_collect<L: FnOnce() -> HashSet<PathBuf>>(&mut self, get_living_files: L) {
         info!("Garbage collect");
         let mut files_to_delete = vec![];
         {
             // releasing the lock as .delete() will use it too.
-            let meta_informations_rlock =
-                self.meta_informations
-                    .read()
-                    .expect("Managed directory rlock poisoned in garbage collect.");
+            let meta_informations_rlock = self.meta_informations
+                .read()
+                .expect("Managed directory rlock poisoned in garbage collect.");
+
+            // It is crucial to get the living files after acquiring the
+            // read lock of meta informations. That way, we
+            // avoid the following scenario.
+            //
+            // 1) we get the list of living files.
+            // 2) someone creates a new file.
+            // 3) we start garbage collection and remove this file
+            // even though it is a living file.
+            let living_files = get_living_files();
+
             for managed_path in &meta_informations_rlock.managed_paths {
                 if !living_files.contains(managed_path) {
                     files_to_delete.push(managed_path.clone());
@@ -156,13 +162,11 @@ impl ManagedDirectory {
                                 // this is expected.
                             }
                         }
-
                     }
                 }
             }
         }
 
-
         if !deleted_files.is_empty() {
             // update the list of managed files by removing
             // the file that were removed.
@@ -179,10 +183,8 @@ impl ManagedDirectory {
                 error!("Failed to save the list of managed files.");
             }
         }
-
     }
 
-
     /// Protects a file from being garbage collected.
     ///
     /// The method returns a `FileProtection` object.
@@ -195,9 +197,9 @@ impl ManagedDirectory {
                 .write()
                 .expect("Managed file lock poisoned on protect");
             *meta_informations_wlock
-                 .protected_files
-                 .entry(pathbuf.clone())
-                 .or_insert(0) += 1;
+                .protected_files
+                .entry(pathbuf.clone())
+                .or_insert(0) += 1;
         }
         FileProtection {
             directory: self.clone(),
@@ -271,14 +273,11 @@ impl Clone for ManagedDirectory {
     fn clone(&self) -> ManagedDirectory {
         ManagedDirectory {
             directory: self.directory.box_clone(),
-            meta_informations: self.meta_informations.clone(),
+            meta_informations: Arc::clone(&self.meta_informations),
         }
     }
 }
 
-
-
-
 #[cfg(test)]
 mod tests {
 
@@ -316,7 +315,7 @@ mod tests {
             {
                 let living_files: HashSet<PathBuf> =
                     [TEST_PATH1.to_owned()].into_iter().cloned().collect();
-                managed_directory.garbage_collect(living_files);
+                managed_directory.garbage_collect(|| living_files);
             }
             {
                 assert!(managed_directory.exists(*TEST_PATH1));
@@ -332,7 +331,7 @@ mod tests {
             }
             {
                 let living_files: HashSet<PathBuf> = HashSet::new();
-                managed_directory.garbage_collect(living_files);
+                managed_directory.garbage_collect(|| living_files);
             }
             {
                 assert!(!managed_directory.exists(*TEST_PATH1));
@@ -355,7 +354,7 @@ mod tests {
         assert!(managed_directory.exists(*TEST_PATH1));
 
         let _mmap_read = managed_directory.open_read(*TEST_PATH1).unwrap();
-        managed_directory.garbage_collect(living_files.clone());
+        managed_directory.garbage_collect(|| living_files.clone());
         if cfg!(target_os = "windows") {
             // On Windows, gc should try and fail the file as it is mmapped.
             assert!(managed_directory.exists(*TEST_PATH1));
@@ -363,15 +362,13 @@ mod tests {
             drop(_mmap_read);
             // The file should still be in the list of managed file and
             // eventually be deleted once mmap is released.
-            managed_directory.garbage_collect(living_files);
+            managed_directory.garbage_collect(|| living_files);
             assert!(!managed_directory.exists(*TEST_PATH1));
         } else {
             assert!(!managed_directory.exists(*TEST_PATH1));
         }
-
     }
 
-
     #[test]
     fn test_managed_directory_protect() {
         let tempdir = TempDir::new("index").unwrap();
@@ -387,14 +384,12 @@ mod tests {
 
         {
             let _file_protection = managed_directory.protect_file_from_delete(*TEST_PATH1);
-            managed_directory.garbage_collect(living_files.clone());
+            managed_directory.garbage_collect(|| living_files.clone());
             assert!(managed_directory.exists(*TEST_PATH1));
         }
 
-        managed_directory.garbage_collect(living_files.clone());
+        managed_directory.garbage_collect(|| living_files.clone());
         assert!(!managed_directory.exists(*TEST_PATH1));
-
-
     }
 
 }

src/directory/mmap_directory.rs

@@ -1,7 +1,7 @@
 use atomicwrites;
 use common::make_io_err;
 use directory::Directory;
-use directory::error::{IOError, OpenWriteError, OpenReadError, DeleteError, OpenDirectoryError};
+use directory::error::{DeleteError, IOError, OpenDirectoryError, OpenReadError, OpenWriteError};
 use directory::ReadOnlySource;
 use directory::shared_vec_slice::SharedVecSlice;
 use directory::WritePtr;
@@ -23,13 +23,14 @@ use std::sync::RwLock;
 use std::sync::Weak;
 use tempdir::TempDir;
 
-fn open_mmap(full_path: &PathBuf) -> result::Result<Option<Arc<Mmap>>, OpenReadError> {
-    let file = File::open(&full_path)
-        .map_err(|e| if e.kind() == io::ErrorKind::NotFound {
-                     OpenReadError::FileDoesNotExist(full_path.clone())
-                 } else {
-                     OpenReadError::IOError(IOError::with_path(full_path.to_owned(), e))
-                 })?;
+fn open_mmap(full_path: &Path) -> result::Result<Option<Arc<Mmap>>, OpenReadError> {
+    let file = File::open(&full_path).map_err(|e| {
+        if e.kind() == io::ErrorKind::NotFound {
+            OpenReadError::FileDoesNotExist(full_path.to_owned())
+        } else {
+            OpenReadError::IOError(IOError::with_path(full_path.to_owned(), e))
+        }
+    })?;
 
     let meta_data = file.metadata()
         .map_err(|e| IOError::with_path(full_path.to_owned(), e))?;
@@ -43,10 +44,9 @@ fn open_mmap(full_path: &PathBuf) -> result::Result<Option<Arc<Mmap>>, OpenReadE
         Ok(mmap) => Ok(Some(Arc::new(mmap))),
         Err(e) => Err(IOError::with_path(full_path.to_owned(), e))?,
     }
-
 }
 
-#[derive(Default,Clone,Debug,Serialize,Deserialize)]
+#[derive(Default, Clone, Debug, Serialize, Deserialize)]
 pub struct CacheCounters {
     // Number of time the cache prevents to call `mmap`
     pub hit: usize,
@@ -58,7 +58,7 @@ pub struct CacheCounters {
     pub miss_weak: usize,
 }
 
-#[derive(Clone,Debug,Serialize,Deserialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct CacheInfo {
     pub counters: CacheCounters,
     pub mmapped: Vec<PathBuf>,
@@ -82,7 +82,6 @@ impl Default for MmapCache {
     }
 }
 
-
 impl MmapCache {
     fn cleanup(&mut self) {
         let previous_cache_size = self.cache.len();
@@ -106,38 +105,38 @@ impl MmapCache {
         }
     }
 
-    fn get_mmap(&mut self, full_path: PathBuf) -> Result<Option<Arc<Mmap>>, OpenReadError> {
+    fn get_mmap(&mut self, full_path: &PathBuf) -> Result<Option<Arc<Mmap>>, OpenReadError> {
         // if we exceed this limit, then we go through the weak
         // and remove those that are obsolete.
         if self.cache.len() > self.purge_weak_limit {
             self.cleanup();
         }
         Ok(match self.cache.entry(full_path.clone()) {
-               HashMapEntry::Occupied(mut occupied_entry) => {
-                   if let Some(mmap_arc) = occupied_entry.get().upgrade() {
-                       self.counters.hit += 1;
-                       Some(mmap_arc.clone())
-                   } else {
-                       // The entry exists but the weak ref has been destroyed.
-                       self.counters.miss_weak += 1;
-                       if let Some(mmap_arc) = open_mmap(&full_path)? {
-                           occupied_entry.insert(Arc::downgrade(&mmap_arc));
-                           Some(mmap_arc)
-                       } else {
-                           None
-                       }
-                   }
-               }
-               HashMapEntry::Vacant(vacant_entry) => {
-                   self.counters.miss_empty += 1;
-                   if let Some(mmap_arc) = open_mmap(&full_path)? {
-                       vacant_entry.insert(Arc::downgrade(&mmap_arc));
-                       Some(mmap_arc)
-                   } else {
-                       None
-                   }
-               }
-           })
+            HashMapEntry::Occupied(mut occupied_entry) => {
+                if let Some(mmap_arc) = occupied_entry.get().upgrade() {
+                    self.counters.hit += 1;
+                    Some(Arc::clone(&mmap_arc))
+                } else {
+                    // The entry exists but the weak ref has been destroyed.
+                    self.counters.miss_weak += 1;
+                    if let Some(mmap_arc) = open_mmap(full_path)? {
+                        occupied_entry.insert(Arc::downgrade(&mmap_arc));
+                        Some(mmap_arc)
+                    } else {
+                        None
+                    }
+                }
+            }
+            HashMapEntry::Vacant(vacant_entry) => {
+                self.counters.miss_empty += 1;
+                if let Some(mmap_arc) = open_mmap(full_path)? {
+                    vacant_entry.insert(Arc::downgrade(&mmap_arc));
+                    Some(mmap_arc)
+                } else {
+                    None
+                }
+            }
+        })
     }
 }
 
@@ -164,10 +163,10 @@ impl MmapDirectory {
     /// This is mostly useful to test the MmapDirectory itself.
     /// For your unit tests, prefer the RAMDirectory.
     pub fn create_from_tempdir() -> io::Result<MmapDirectory> {
-        let tempdir = try!(TempDir::new("index"));
+        let tempdir = TempDir::new("index")?;
         let tempdir_path = PathBuf::from(tempdir.path());
         let directory = MmapDirectory {
-            root_path: PathBuf::from(tempdir_path),
+            root_path: tempdir_path,
             mmap_cache: Arc::new(RwLock::new(MmapCache::default())),
             _temp_directory: Arc::new(Some(tempdir)),
         };
@@ -178,17 +177,22 @@ impl MmapDirectory {
     ///
     /// Returns an error if the `directory_path` does not
     /// exist or if it is not a directory.
-    pub fn open(directory_path: &Path) -> Result<MmapDirectory, OpenDirectoryError> {
+    pub fn open<P: AsRef<Path>>(directory_path: P) -> Result<MmapDirectory, OpenDirectoryError> {
+        let directory_path: &Path = directory_path.as_ref();
         if !directory_path.exists() {
-            Err(OpenDirectoryError::DoesNotExist(PathBuf::from(directory_path)))
+            Err(OpenDirectoryError::DoesNotExist(PathBuf::from(
+                directory_path,
+            )))
         } else if !directory_path.is_dir() {
-            Err(OpenDirectoryError::NotADirectory(PathBuf::from(directory_path)))
+            Err(OpenDirectoryError::NotADirectory(PathBuf::from(
+                directory_path,
+            )))
         } else {
             Ok(MmapDirectory {
-                   root_path: PathBuf::from(directory_path),
-                   mmap_cache: Arc::new(RwLock::new(MmapCache::default())),
-                   _temp_directory: Arc::new(None),
-               })
+                root_path: PathBuf::from(directory_path),
+                mmap_cache: Arc::new(RwLock::new(MmapCache::default())),
+                _temp_directory: Arc::new(None),
+            })
         }
     }
 
@@ -220,8 +224,8 @@ impl MmapDirectory {
                 .custom_flags(winbase::FILE_FLAG_BACKUP_SEMANTICS);
         }
 
-        let fd = try!(open_opts.open(&self.root_path));
-        try!(fd.sync_all());
+        let fd = open_opts.open(&self.root_path)?;
+        fd.sync_all()?;
         Ok(())
     }
     /// Returns some statistical information
@@ -253,7 +257,7 @@ impl Write for SafeFileWriter {
     }
 
     fn flush(&mut self) -> io::Result<()> {
-        try!(self.0.flush());
+        self.0.flush()?;
         self.0.sync_all()
     }
 }
@@ -264,26 +268,25 @@ impl Seek for SafeFileWriter {
     }
 }
 
-
 impl Directory for MmapDirectory {
     fn open_read(&self, path: &Path) -> result::Result<ReadOnlySource, OpenReadError> {
         debug!("Open Read {:?}", path);
         let full_path = self.resolve_path(path);
 
-        let mut mmap_cache = self.mmap_cache
-            .write()
-            .map_err(|_| {
-                         let msg = format!("Failed to acquired write lock \
-                                            on mmap cache while reading {:?}",
-                                           path);
-                         IOError::with_path(path.to_owned(), make_io_err(msg))
-                     })?;
+        let mut mmap_cache = self.mmap_cache.write().map_err(|_| {
+            let msg = format!(
+                "Failed to acquired write lock \
+                 on mmap cache while reading {:?}",
+                path
+            );
+            IOError::with_path(path.to_owned(), make_io_err(msg))
+        })?;
 
         Ok(mmap_cache
-               .get_mmap(full_path)?
-               .map(MmapReadOnly::from)
-               .map(ReadOnlySource::Mmap)
-               .unwrap_or_else(|| ReadOnlySource::Anonymous(SharedVecSlice::empty())))
+            .get_mmap(&full_path)?
+            .map(MmapReadOnly::from)
+            .map(ReadOnlySource::Mmap)
+            .unwrap_or_else(|| ReadOnlySource::Anonymous(SharedVecSlice::empty())))
     }
 
     fn open_write(&mut self, path: &Path) -> Result<WritePtr, OpenWriteError> {
@@ -295,12 +298,13 @@ impl Directory for MmapDirectory {
             .create_new(true)
             .open(full_path);
 
-        let mut file = open_res
-            .map_err(|err| if err.kind() == io::ErrorKind::AlreadyExists {
-                         OpenWriteError::FileAlreadyExists(path.to_owned())
-                     } else {
-                         IOError::with_path(path.to_owned(), err).into()
-                     })?;
+        let mut file = open_res.map_err(|err| {
+            if err.kind() == io::ErrorKind::AlreadyExists {
+                OpenWriteError::FileAlreadyExists(path.to_owned())
+            } else {
+                IOError::with_path(path.to_owned(), err).into()
+            }
+        })?;
 
         // making sure the file is created.
         file.flush()
@@ -318,23 +322,21 @@ impl Directory for MmapDirectory {
     fn delete(&self, path: &Path) -> result::Result<(), DeleteError> {
         debug!("Deleting file {:?}", path);
         let full_path = self.resolve_path(path);
-        let mut mmap_cache = self.mmap_cache
-            .write()
-            .map_err(|_| {
-                         let msg = format!("Failed to acquired write lock \
-                                            on mmap cache while deleting {:?}",
-                                           path);
-                         IOError::with_path(path.to_owned(), make_io_err(msg))
-                     })?;
+        let mut mmap_cache = self.mmap_cache.write().map_err(|_| {
+            let msg = format!(
+                "Failed to acquired write lock \
+                 on mmap cache while deleting {:?}",
+                path
+            );
+            IOError::with_path(path.to_owned(), make_io_err(msg))
+        })?;
         // Removing the entry in the MMap cache.
         // The munmap will appear on Drop,
         // when the last reference is gone.
         mmap_cache.cache.remove(&full_path);
         match fs::remove_file(&full_path) {
-            Ok(_) => {
-                self.sync_directory()
-                    .map_err(|e| IOError::with_path(path.to_owned(), e).into())
-            }
+            Ok(_) => self.sync_directory()
+                .map_err(|e| IOError::with_path(path.to_owned(), e).into()),
             Err(e) => {
                 if e.kind() == io::ErrorKind::NotFound {
                     Err(DeleteError::FileDoesNotExist(path.to_owned()))
@@ -367,14 +369,13 @@ impl Directory for MmapDirectory {
                 }
             }
         }
-
     }
 
     fn atomic_write(&mut self, path: &Path, data: &[u8]) -> io::Result<()> {
         debug!("Atomic Write {:?}", path);
         let full_path = self.resolve_path(path);
         let meta_file = atomicwrites::AtomicFile::new(full_path, atomicwrites::AllowOverwrite);
-        try!(meta_file.write(|f| f.write_all(data)));
+        meta_file.write(|f| f.write_all(data))?;
         Ok(())
     }
 
@@ -383,9 +384,6 @@ impl Directory for MmapDirectory {
     }
 }
 
-
-
-
 #[cfg(test)]
 mod tests {
 
@@ -438,7 +436,6 @@ mod tests {
         }
         assert_eq!(mmap_directory.get_cache_info().counters.miss_empty, 10);
 
-
         {
             // test weak miss
             // the first pass create the weak refs.
@@ -473,7 +470,6 @@ mod tests {
         }
 
         assert_eq!(mmap_directory.get_cache_info().mmapped.len(), 0);
-
     }
 
 }

src/directory/mod.rs

@@ -13,14 +13,15 @@ mod managed_directory;
 /// Errors specific to the directory module.
 pub mod error;
 
-use std::io::{Write, Seek};
+use std::io::{BufWriter, Seek, Write};
 
-use std::io::BufWriter;
 pub use self::read_only_source::ReadOnlySource;
 pub use self::directory::Directory;
 pub use self::ram_directory::RAMDirectory;
 pub use self::mmap_directory::MmapDirectory;
-pub use self::managed_directory::{ManagedDirectory, FileProtection};
+
+pub(crate) use self::read_only_source::SourceRead;
+pub(crate) use self::managed_directory::{FileProtection, ManagedDirectory};
 
 /// Synonym of Seek + Write
 pub trait SeekableWrite: Seek + Write {}
@@ -37,7 +38,7 @@ mod tests {
 
     use super::*;
     use std::path::Path;
-    use std::io::{Write, Seek, SeekFrom};
+    use std::io::{Seek, SeekFrom, Write};
 
     lazy_static! {
         static ref TEST_PATH: &'static Path = Path::new("some_path_for_test");
@@ -103,7 +104,6 @@ mod tests {
         {
             directory.open_write(*TEST_PATH).unwrap();
             assert!(directory.exists(*TEST_PATH));
-
         }
         {
             assert!(directory.open_write(*TEST_PATH).is_err());

src/directory/ram_directory.rs

@@ -1,12 +1,12 @@
 use std::collections::HashMap;
 use std::fmt;
-use std::io::{self, BufWriter, Cursor, Write, Seek, SeekFrom};
+use std::io::{self, BufWriter, Cursor, Seek, SeekFrom, Write};
 use std::path::{Path, PathBuf};
 use std::result;
 use std::sync::{Arc, RwLock};
 use common::make_io_err;
 use directory::{Directory, ReadOnlySource};
-use directory::error::{IOError, OpenWriteError, OpenReadError, DeleteError};
+use directory::error::{DeleteError, IOError, OpenReadError, OpenWriteError};
 use directory::WritePtr;
 use super::shared_vec_slice::SharedVecSlice;
 
@@ -32,7 +32,7 @@ impl VecWriter {
         VecWriter {
             path: path_buf,
             data: Cursor::new(Vec::new()),
-            shared_directory: shared_directory,
+            shared_directory,
             is_flushed: true,
         }
     }
@@ -41,8 +41,10 @@ impl VecWriter {
 impl Drop for VecWriter {
     fn drop(&mut self) {
         if !self.is_flushed {
-            panic!("You forgot to flush {:?} before its writter got Drop. Do not rely on drop.",
-                   self.path)
+            panic!(
+                "You forgot to flush {:?} before its writter got Drop. Do not rely on drop.",
+                self.path
+            )
         }
     }
 }
@@ -56,14 +58,14 @@ impl Seek for VecWriter {
 impl Write for VecWriter {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         self.is_flushed = false;
-        try!(self.data.write_all(buf));
+        self.data.write_all(buf)?;
         Ok(buf.len())
     }
 
     fn flush(&mut self) -> io::Result<()> {
         self.is_flushed = true;
-        try!(self.shared_directory
-                 .write(self.path.clone(), self.data.get_ref()));
+        self.shared_directory
+            .write(self.path.clone(), self.data.get_ref())?;
         Ok(())
     }
 }
@@ -71,20 +73,18 @@ impl Write for VecWriter {
 #[derive(Clone)]
 struct InnerDirectory(Arc<RwLock<HashMap<PathBuf, Arc<Vec<u8>>>>>);
 
-
-
 impl InnerDirectory {
     fn new() -> InnerDirectory {
         InnerDirectory(Arc::new(RwLock::new(HashMap::new())))
     }
 
     fn write(&self, path: PathBuf, data: &[u8]) -> io::Result<bool> {
-        let mut map = try!(self.0
-                               .write()
-                               .map_err(|_| {
-            make_io_err(format!("Failed to lock the directory, when trying to write {:?}",
-                                path))
-        }));
+        let mut map = self.0.write().map_err(|_| {
+            make_io_err(format!(
+                "Failed to lock the directory, when trying to write {:?}",
+                path
+            ))
+        })?;
         let prev_value = map.insert(path, Arc::new(Vec::from(data)));
         Ok(prev_value.is_some())
     }
@@ -93,17 +93,20 @@ impl InnerDirectory {
         self.0
             .read()
             .map_err(|_| {
-                         let msg = format!("Failed to acquire read lock for the \
-                                            directory when trying to read {:?}",
-                                           path);
-                         let io_err = make_io_err(msg);
-                         OpenReadError::IOError(IOError::with_path(path.to_owned(), io_err))
-                     })
+                let msg = format!(
+                    "Failed to acquire read lock for the \
+                     directory when trying to read {:?}",
+                    path
+                );
+                let io_err = make_io_err(msg);
+                OpenReadError::IOError(IOError::with_path(path.to_owned(), io_err))
+            })
             .and_then(|readable_map| {
                 readable_map
                     .get(path)
                     .ok_or_else(|| OpenReadError::FileDoesNotExist(PathBuf::from(path)))
-                    .map(|data| ReadOnlySource::Anonymous(SharedVecSlice::new(data.clone())))
+                    .map(Arc::clone)
+                    .map(|data| ReadOnlySource::Anonymous(SharedVecSlice::new(data)))
             })
     }
 
@@ -111,16 +114,18 @@ impl InnerDirectory {
         self.0
             .write()
             .map_err(|_| {
-                         let msg = format!("Failed to acquire write lock for the \
-                                            directory when trying to delete {:?}",
-                                           path);
-                         let io_err = make_io_err(msg);
-                         DeleteError::IOError(IOError::with_path(path.to_owned(), io_err))
-                     })
+                let msg = format!(
+                    "Failed to acquire write lock for the \
+                     directory when trying to delete {:?}",
+                    path
+                );
+                let io_err = make_io_err(msg);
+                DeleteError::IOError(IOError::with_path(path.to_owned(), io_err))
+            })
             .and_then(|mut writable_map| match writable_map.remove(path) {
-                          Some(_) => Ok(()),
-                          None => Err(DeleteError::FileDoesNotExist(PathBuf::from(path))),
-                      })
+                Some(_) => Ok(()),
+                None => Err(DeleteError::FileDoesNotExist(PathBuf::from(path))),
+            })
     }
 
     fn exists(&self, path: &Path) -> bool {
@@ -137,7 +142,6 @@ impl fmt::Debug for RAMDirectory {
     }
 }
 
-
 /// A Directory storing everything in anonymous memory.
 ///
 /// It is mainly meant for unit testing.
@@ -151,7 +155,9 @@ pub struct RAMDirectory {
 impl RAMDirectory {
     /// Constructor
     pub fn create() -> RAMDirectory {
-        RAMDirectory { fs: InnerDirectory::new() }
+        RAMDirectory {
+            fs: InnerDirectory::new(),
+        }
     }
 }
 
@@ -180,7 +186,6 @@ impl Directory for RAMDirectory {
         self.fs.delete(path)
     }
 
-
     fn exists(&self, path: &Path) -> bool {
         self.fs.exists(path)
     }
@@ -193,9 +198,9 @@ impl Directory for RAMDirectory {
     fn atomic_write(&mut self, path: &Path, data: &[u8]) -> io::Result<()> {
         let path_buf = PathBuf::from(path);
         let mut vec_writer = VecWriter::new(path_buf.clone(), self.fs.clone());
-        try!(self.fs.write(path_buf, &Vec::new()));
-        try!(vec_writer.write_all(data));
-        try!(vec_writer.flush());
+        self.fs.write(path_buf, &Vec::new())?;
+        vec_writer.write_all(data)?;
+        vec_writer.flush()?;
         Ok(())
     }
 

src/directory/read_only_source.rs

@@ -2,6 +2,8 @@ use fst::raw::MmapReadOnly;
 use std::ops::Deref;
 use super::shared_vec_slice::SharedVecSlice;
 use common::HasLen;
+use std::slice;
+use std::io::{self, Read};
 use stable_deref_trait::StableDeref;
 
 /// Read object that represents files in tantivy.
@@ -41,6 +43,14 @@ impl ReadOnlySource {
         }
     }
 
+    /// Splits into 2 `ReadOnlySource`, at the offset given
+    /// as an argument.
+    pub fn split(self, addr: usize) -> (ReadOnlySource, ReadOnlySource) {
+        let left = self.slice(0, addr);
+        let right = self.slice_from(addr);
+        (left, right)
+    }
+
     /// Creates a ReadOnlySource that is just a
     /// view over a slice of the data.
     ///
@@ -62,6 +72,23 @@ impl ReadOnlySource {
             }
         }
     }
+
+    /// Like `.slice(...)` but enforcing only the `from`
+    /// boundary.
+    ///
+    /// Equivalent to `.slice(from_offset, self.len())`
+    pub fn slice_from(&self, from_offset: usize) -> ReadOnlySource {
+        let len = self.len();
+        self.slice(from_offset, len)
+    }
+
+    /// Like `.slice(...)` but enforcing only the `to`
+    /// boundary.
+    ///
+    /// Equivalent to `.slice(0, to_offset)`
+    pub fn slice_to(&self, to_offset: usize) -> ReadOnlySource {
+        self.slice(0, to_offset)
+    }
 }
 
 impl HasLen for ReadOnlySource {
@@ -82,3 +109,41 @@ impl From<Vec<u8>> for ReadOnlySource {
         ReadOnlySource::Anonymous(shared_data)
     }
 }
+
+/// Acts as a owning cursor over the data backed up by a `ReadOnlySource`
+pub(crate) struct SourceRead {
+    _data_owner: ReadOnlySource,
+    cursor: &'static [u8],
+}
+
+impl SourceRead {
+    // Advance the cursor by a given number of bytes.
+    pub fn advance(&mut self, len: usize) {
+        self.cursor = &self.cursor[len..];
+    }
+}
+
+impl AsRef<[u8]> for SourceRead {
+    fn as_ref(&self) -> &[u8] {
+        self.cursor
+    }
+}
+
+impl From<ReadOnlySource> for SourceRead {
+    // Creates a new `SourceRead` from a given `ReadOnlySource`
+    fn from(source: ReadOnlySource) -> SourceRead {
+        let len = source.len();
+        let slice_ptr = source.as_slice().as_ptr();
+        let static_slice = unsafe { slice::from_raw_parts(slice_ptr, len) };
+        SourceRead {
+            _data_owner: source,
+            cursor: static_slice,
+        }
+    }
+}
+
+impl Read for SourceRead {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        self.cursor.read(buf)
+    }
+}

src/directory/shared_vec_slice.rs

@@ -1,6 +1,5 @@
 use std::sync::Arc;
 
-
 #[derive(Clone)]
 pub struct SharedVecSlice {
     pub data: Arc<Vec<u8>>,
@@ -16,7 +15,7 @@ impl SharedVecSlice {
     pub fn new(data: Arc<Vec<u8>>) -> SharedVecSlice {
         let data_len = data.len();
         SharedVecSlice {
-            data: data,
+            data,
             start: 0,
             len: data_len,
         }
@@ -28,14 +27,13 @@ impl SharedVecSlice {
 
     pub fn slice(&self, from_offset: usize, to_offset: usize) -> SharedVecSlice {
         SharedVecSlice {
-            data: self.data.clone(),
+            data: Arc::clone(&self.data),
             start: self.start + from_offset,
             len: to_offset - from_offset,
         }
     }
 }
 
-
 impl From<Vec<u8>> for SharedVecSlice {
     fn from(data: Vec<u8>) -> SharedVecSlice {
         SharedVecSlice::new(Arc::new(data))

src/error.rs

@@ -4,7 +4,7 @@ use std::io;
 
 use std::path::PathBuf;
 use std::sync::PoisonError;
-use directory::error::{IOError, OpenReadError, OpenWriteError, OpenDirectoryError};
+use directory::error::{IOError, OpenDirectoryError, OpenReadError, OpenWriteError};
 use query;
 use schema;
 use fastfield::FastFieldNotAvailableError;
@@ -111,12 +111,9 @@ impl From<schema::DocParsingError> for Error {
 impl From<OpenWriteError> for Error {
     fn from(error: OpenWriteError) -> Error {
         match error {
-                OpenWriteError::FileAlreadyExists(filepath) => {
-                    ErrorKind::FileAlreadyExists(filepath)
-                }
-                OpenWriteError::IOError(io_error) => ErrorKind::IOError(io_error),
-            }
-            .into()
+            OpenWriteError::FileAlreadyExists(filepath) => ErrorKind::FileAlreadyExists(filepath),
+            OpenWriteError::IOError(io_error) => ErrorKind::IOError(io_error),
+        }.into()
     }
 }
 
@@ -126,10 +123,9 @@ impl From<OpenDirectoryError> for Error {
             OpenDirectoryError::DoesNotExist(directory_path) => {
                 ErrorKind::PathDoesNotExist(directory_path).into()
             }
-            OpenDirectoryError::NotADirectory(directory_path) => {
-                ErrorKind::InvalidArgument(format!("{:?} is not a directory", directory_path))
-                    .into()
-            }
+            OpenDirectoryError::NotADirectory(directory_path) => ErrorKind::InvalidArgument(
+                format!("{:?} is not a directory", directory_path),
+            ).into(),
         }
     }
 }

src/fastfield/delete.rs

@@ -38,7 +38,6 @@ pub struct DeleteBitSet {
     len: usize,
 }
 
-
 impl DeleteBitSet {
     /// Opens a delete bitset given its data source.
     pub fn open(data: ReadOnlySource) -> DeleteBitSet {
@@ -47,7 +46,7 @@ impl DeleteBitSet {
             .map(|b| b.count_ones() as usize)
             .sum();
         DeleteBitSet {
-            data: data,
+            data,
             len: num_deleted,
         }
     }
@@ -79,7 +78,6 @@ impl DeleteBitSet {
     }
 }
 
-
 impl HasLen for DeleteBitSet {
     fn len(&self) -> usize {
         self.len

src/fastfield/error.rs

@@ -14,10 +14,11 @@ impl FastFieldNotAvailableError {
     /// `field_entry` is the configuration of the field
     /// for which fast fields are not available.
     pub fn new(field_entry: &FieldEntry) -> FastFieldNotAvailableError {
-        FastFieldNotAvailableError { field_name: field_entry.name().to_string() }
+        FastFieldNotAvailableError {
+            field_name: field_entry.name().to_string(),
+        }
     }
 }
 
-
 /// Result when trying to access a fast field reader.
 pub type Result<R> = result::Result<R, FastFieldNotAvailableError>;

src/fastfield/mod.rs

@@ -1,5 +1,5 @@
 /*!
-Fast fields is a column oriented storage storage.
+Column oriented field storage for tantivy.
 
 It is the equivalent of `Lucene`'s `DocValues`.
 
@@ -9,14 +9,14 @@ It is designed for the fast random access of some document
 fields given a document id.
 
 `FastField` are useful when a field is required for all or most of
-the `DocSet` : for instance for scoring, grouping, filtering, or facetting.
+the `DocSet` : for instance for scoring, grouping, filtering, or faceting.
 
 
 Fields have to be declared as `FAST` in the  schema.
 Currently only 64-bits integers (signed or unsigned) are
 supported.
 
-They are stored in a bitpacked fashion so that their
+They are stored in a bit-packed fashion so that their
 memory usage is directly linear with the amplitude of the
 values stored.
 
@@ -32,17 +32,17 @@ mod delete;
 pub use self::delete::write_delete_bitset;
 pub use self::delete::DeleteBitSet;
 pub use self::writer::{FastFieldsWriter, IntFastFieldWriter};
-pub use self::reader::{FastFieldsReader, U64FastFieldReader, I64FastFieldReader};
+pub use self::reader::{I64FastFieldReader, U64FastFieldReader};
 pub use self::reader::FastFieldReader;
 pub use self::serializer::FastFieldSerializer;
-pub use self::error::{Result, FastFieldNotAvailableError};
+pub use self::error::{FastFieldNotAvailableError, Result};
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use schema::Field;
     use std::path::Path;
-    use directory::{Directory, WritePtr, RAMDirectory};
+    use directory::{Directory, RAMDirectory, WritePtr};
     use schema::Document;
     use schema::{Schema, SchemaBuilder};
     use schema::FAST;
@@ -51,6 +51,7 @@ mod tests {
     use fastfield::FastFieldReader;
     use rand::Rng;
     use rand::SeedableRng;
+    use common::CompositeFile;
     use rand::XorShiftRng;
 
     lazy_static! {
@@ -84,7 +85,7 @@ mod tests {
         let mut directory: RAMDirectory = RAMDirectory::create();
         {
             let write: WritePtr = directory.open_write(Path::new("test")).unwrap();
-            let mut serializer = FastFieldSerializer::new(write).unwrap();
+            let mut serializer = FastFieldSerializer::from_write(write).unwrap();
             let mut fast_field_writers = FastFieldsWriter::from_schema(&SCHEMA);
             add_single_field_doc(&mut fast_field_writers, *FIELD, 13u64);
             add_single_field_doc(&mut fast_field_writers, *FIELD, 14u64);
@@ -94,12 +95,12 @@ mod tests {
         }
         let source = directory.open_read(&path).unwrap();
         {
-            assert_eq!(source.len(), 38 as usize);
+            assert_eq!(source.len(), 35 as usize);
         }
         {
-            let fast_field_readers = FastFieldsReader::from_source(source).unwrap();
-            let fast_field_reader: U64FastFieldReader =
-                fast_field_readers.open_reader(*FIELD).unwrap();
+            let composite_file = CompositeFile::open(&source).unwrap();
+            let field_source = composite_file.open_read(*FIELD).unwrap();
+            let fast_field_reader: U64FastFieldReader = U64FastFieldReader::open(field_source);
             assert_eq!(fast_field_reader.get(0), 13u64);
             assert_eq!(fast_field_reader.get(1), 14u64);
             assert_eq!(fast_field_reader.get(2), 2u64);
@@ -112,7 +113,7 @@ mod tests {
         let mut directory: RAMDirectory = RAMDirectory::create();
         {
             let write: WritePtr = directory.open_write(Path::new("test")).unwrap();
-            let mut serializer = FastFieldSerializer::new(write).unwrap();
+            let mut serializer = FastFieldSerializer::from_write(write).unwrap();
             let mut fast_field_writers = FastFieldsWriter::from_schema(&SCHEMA);
             add_single_field_doc(&mut fast_field_writers, *FIELD, 4u64);
             add_single_field_doc(&mut fast_field_writers, *FIELD, 14_082_001u64);
@@ -128,12 +129,12 @@ mod tests {
         }
         let source = directory.open_read(&path).unwrap();
         {
-            assert_eq!(source.len(), 63 as usize);
+            assert_eq!(source.len(), 60 as usize);
         }
         {
-            let fast_field_readers = FastFieldsReader::from_source(source).unwrap();
+            let fast_fields_composite = CompositeFile::open(&source).unwrap();
             let fast_field_reader: U64FastFieldReader =
-                fast_field_readers.open_reader(*FIELD).unwrap();
+                U64FastFieldReader::open(fast_fields_composite.open_read(*FIELD).unwrap());
             assert_eq!(fast_field_reader.get(0), 4u64);
             assert_eq!(fast_field_reader.get(1), 14_082_001u64);
             assert_eq!(fast_field_reader.get(2), 3_052u64);
@@ -151,10 +152,9 @@ mod tests {
         let path = Path::new("test");
         let mut directory: RAMDirectory = RAMDirectory::create();
 
-
         {
             let write: WritePtr = directory.open_write(Path::new("test")).unwrap();
-            let mut serializer = FastFieldSerializer::new(write).unwrap();
+            let mut serializer = FastFieldSerializer::from_write(write).unwrap();
             let mut fast_field_writers = FastFieldsWriter::from_schema(&SCHEMA);
             for _ in 0..10_000 {
                 add_single_field_doc(&mut fast_field_writers, *FIELD, 100_000u64);
@@ -164,12 +164,12 @@ mod tests {
         }
         let source = directory.open_read(&path).unwrap();
         {
-            assert_eq!(source.len(), 36 as usize);
+            assert_eq!(source.len(), 33 as usize);
         }
         {
-            let fast_field_readers = FastFieldsReader::from_source(source).unwrap();
+            let fast_fields_composite = CompositeFile::open(&source).unwrap();
             let fast_field_reader: U64FastFieldReader =
-                fast_field_readers.open_reader(*FIELD).unwrap();
+                U64FastFieldReader::open(fast_fields_composite.open_read(*FIELD).unwrap());
             for doc in 0..10_000 {
                 assert_eq!(fast_field_reader.get(doc), 100_000u64);
             }
@@ -183,30 +183,35 @@ mod tests {
 
         {
             let write: WritePtr = directory.open_write(Path::new("test")).unwrap();
-            let mut serializer = FastFieldSerializer::new(write).unwrap();
+            let mut serializer = FastFieldSerializer::from_write(write).unwrap();
             let mut fast_field_writers = FastFieldsWriter::from_schema(&SCHEMA);
             // forcing the amplitude to be high
             add_single_field_doc(&mut fast_field_writers, *FIELD, 0u64);
             for i in 0u64..10_000u64 {
-                add_single_field_doc(&mut fast_field_writers,
-                                     *FIELD,
-                                     5_000_000_000_000_000_000u64 + i);
+                add_single_field_doc(
+                    &mut fast_field_writers,
+                    *FIELD,
+                    5_000_000_000_000_000_000u64 + i,
+                );
             }
             fast_field_writers.serialize(&mut serializer).unwrap();
             serializer.close().unwrap();
         }
         let source = directory.open_read(&path).unwrap();
         {
-            assert_eq!(source.len(), 80044 as usize);
+            assert_eq!(source.len(), 80041 as usize);
         }
         {
-            let fast_field_readers = FastFieldsReader::from_source(source).unwrap();
+            let fast_fields_composite = CompositeFile::open(&source).unwrap();
             let fast_field_reader: U64FastFieldReader =
-                fast_field_readers.open_reader(*FIELD).unwrap();
+                U64FastFieldReader::open(fast_fields_composite.open_read(*FIELD).unwrap());
+
             assert_eq!(fast_field_reader.get(0), 0u64);
             for doc in 1..10_001 {
-                assert_eq!(fast_field_reader.get(doc),
-                           5_000_000_000_000_000_000u64 + doc as u64 - 1u64);
+                assert_eq!(
+                    fast_field_reader.get(doc),
+                    5_000_000_000_000_000_000u64 + doc as u64 - 1u64
+                );
             }
         }
     }
@@ -221,7 +226,7 @@ mod tests {
         let schema = schema_builder.build();
         {
             let write: WritePtr = directory.open_write(Path::new("test")).unwrap();
-            let mut serializer = FastFieldSerializer::new(write).unwrap();
+            let mut serializer = FastFieldSerializer::from_write(write).unwrap();
             let mut fast_field_writers = FastFieldsWriter::from_schema(&schema);
             for i in -100i64..10_000i64 {
                 let mut doc = Document::default();
@@ -233,12 +238,13 @@ mod tests {
         }
         let source = directory.open_read(&path).unwrap();
         {
-            assert_eq!(source.len(), 17711 as usize);
+            assert_eq!(source.len(), 17708 as usize);
         }
         {
-            let fast_field_readers = FastFieldsReader::from_source(source).unwrap();
+            let fast_fields_composite = CompositeFile::open(&source).unwrap();
             let fast_field_reader: I64FastFieldReader =
-                fast_field_readers.open_reader(i64_field).unwrap();
+                I64FastFieldReader::open(fast_fields_composite.open_read(i64_field).unwrap());
+
             assert_eq!(fast_field_reader.min_value(), -100i64);
             assert_eq!(fast_field_reader.max_value(), 9_999i64);
             for (doc, i) in (-100i64..10_000i64).enumerate() {
@@ -262,7 +268,7 @@ mod tests {
 
         {
             let write: WritePtr = directory.open_write(Path::new("test")).unwrap();
-            let mut serializer = FastFieldSerializer::new(write).unwrap();
+            let mut serializer = FastFieldSerializer::from_write(write).unwrap();
             let mut fast_field_writers = FastFieldsWriter::from_schema(&schema);
             let doc = Document::default();
             fast_field_writers.add_document(&doc);
@@ -272,9 +278,9 @@ mod tests {
 
         let source = directory.open_read(&path).unwrap();
         {
-            let fast_field_readers = FastFieldsReader::from_source(source).unwrap();
+            let fast_fields_composite = CompositeFile::open(&source).unwrap();
             let fast_field_reader: I64FastFieldReader =
-                fast_field_readers.open_reader(i64_field).unwrap();
+                I64FastFieldReader::open(fast_fields_composite.open_read(i64_field).unwrap());
             assert_eq!(fast_field_reader.get(0u32), 0i64);
         }
     }
@@ -295,7 +301,7 @@ mod tests {
         let mut directory = RAMDirectory::create();
         {
             let write: WritePtr = directory.open_write(Path::new("test")).unwrap();
-            let mut serializer = FastFieldSerializer::new(write).unwrap();
+            let mut serializer = FastFieldSerializer::from_write(write).unwrap();
             let mut fast_field_writers = FastFieldsWriter::from_schema(&SCHEMA);
             for x in &permutation {
                 add_single_field_doc(&mut fast_field_writers, *FIELD, *x);
@@ -305,9 +311,10 @@ mod tests {
         }
         let source = directory.open_read(&path).unwrap();
         {
-            let fast_field_readers = FastFieldsReader::from_source(source).unwrap();
+            let fast_fields_composite = CompositeFile::open(&source).unwrap();
             let fast_field_reader: U64FastFieldReader =
-                fast_field_readers.open_reader(*FIELD).unwrap();
+                U64FastFieldReader::open(fast_fields_composite.open_read(*FIELD).unwrap());
+
             let mut a = 0u64;
             for _ in 0..n {
                 assert_eq!(fast_field_reader.get(a as u32), permutation[a as usize]);
@@ -333,13 +340,13 @@ mod tests {
     fn bench_intfastfield_veclookup(b: &mut Bencher) {
         let permutation = generate_permutation();
         b.iter(|| {
-                   let n = test::black_box(1000u32);
-                   let mut a = 0u64;
-                   for _ in 0u32..n {
-                       a = permutation[a as usize];
-                   }
-                   a
-               });
+            let n = test::black_box(1000u32);
+            let mut a = 0u64;
+            for _ in 0u32..n {
+                a = permutation[a as usize];
+            }
+            a
+        });
     }
 
     #[bench]
@@ -349,7 +356,7 @@ mod tests {
         let mut directory: RAMDirectory = RAMDirectory::create();
         {
             let write: WritePtr = directory.open_write(Path::new("test")).unwrap();
-            let mut serializer = FastFieldSerializer::new(write).unwrap();
+            let mut serializer = FastFieldSerializer::from_write(write).unwrap();
             let mut fast_field_writers = FastFieldsWriter::from_schema(&SCHEMA);
             for x in &permutation {
                 add_single_field_doc(&mut fast_field_writers, *FIELD, *x);
@@ -359,9 +366,10 @@ mod tests {
         }
         let source = directory.open_read(&path).unwrap();
         {
-            let fast_field_readers = FastFieldsReader::from_source(source).unwrap();
+            let fast_fields_composite = CompositeFile::open(&source).unwrap();
             let fast_field_reader: U64FastFieldReader =
-                fast_field_readers.open_reader(*FIELD).unwrap();
+                U64FastFieldReader::open(fast_fields_composite.open_read(*FIELD).unwrap());
+
             b.iter(|| {
                 let n = test::black_box(7000u32);
                 let mut a = 0u64;
@@ -380,7 +388,7 @@ mod tests {
         let mut directory: RAMDirectory = RAMDirectory::create();
         {
             let write: WritePtr = directory.open_write(Path::new("test")).unwrap();
-            let mut serializer = FastFieldSerializer::new(write).unwrap();
+            let mut serializer = FastFieldSerializer::from_write(write).unwrap();
             let mut fast_field_writers = FastFieldsWriter::from_schema(&SCHEMA);
             for x in &permutation {
                 add_single_field_doc(&mut fast_field_writers, *FIELD, *x);
@@ -390,17 +398,18 @@ mod tests {
         }
         let source = directory.open_read(&path).unwrap();
         {
-            let fast_field_readers = FastFieldsReader::from_source(source).unwrap();
+            let fast_fields_composite = CompositeFile::open(&source).unwrap();
             let fast_field_reader: U64FastFieldReader =
-                fast_field_readers.open_reader(*FIELD).unwrap();
+                U64FastFieldReader::open(fast_fields_composite.open_read(*FIELD).unwrap());
+
             b.iter(|| {
-                       let n = test::black_box(1000u32);
-                       let mut a = 0u32;
-                       for _ in 0u32..n {
-                           a = fast_field_reader.get(a) as u32;
-                       }
-                       a
-                   });
+                let n = test::black_box(1000u32);
+                let mut a = 0u32;
+                for _ in 0u32..n {
+                    a = fast_field_reader.get(a) as u32;
+                }
+                a
+            });
         }
     }
 }

src/fastfield/reader.rs

@@ -1,20 +1,15 @@
-use std::io;
-use std::collections::HashMap;
 use directory::ReadOnlySource;
-use common::BinarySerializable;
+use common::{self, BinarySerializable};
+use common::bitpacker::{compute_num_bits, BitUnpacker};
 use DocId;
-use schema::{Field, SchemaBuilder};
+use schema::SchemaBuilder;
 use std::path::Path;
 use schema::FAST;
-use directory::{WritePtr, RAMDirectory, Directory};
-use fastfield::FastFieldSerializer;
-use fastfield::FastFieldsWriter;
-use common::bitpacker::compute_num_bits;
-use common::bitpacker::BitUnpacker;
+use directory::{Directory, RAMDirectory, WritePtr};
+use fastfield::{FastFieldSerializer, FastFieldsWriter};
 use schema::FieldType;
-use error::ResultExt;
 use std::mem;
-use common;
+use common::CompositeFile;
 use owning_ref::OwningRef;
 
 /// Trait for accessing a fastfield.
@@ -111,11 +106,10 @@ impl FastFieldReader for U64FastFieldReader {
         let amplitude: u64;
         {
             let mut cursor = data.as_slice();
-            min_value = u64::deserialize(&mut cursor)
-                .expect("Failed to read the min_value of fast field.");
-            amplitude = u64::deserialize(&mut cursor)
-                .expect("Failed to read the amplitude of fast field.");
-
+            min_value =
+                u64::deserialize(&mut cursor).expect("Failed to read the min_value of fast field.");
+            amplitude =
+                u64::deserialize(&mut cursor).expect("Failed to read the amplitude of fast field.");
         }
         let max_value = min_value + amplitude;
         let num_bits = compute_num_bits(amplitude);
@@ -129,39 +123,40 @@ impl FastFieldReader for U64FastFieldReader {
     }
 }
 
-
 impl From<Vec<u64>> for U64FastFieldReader {
     fn from(vals: Vec<u64>) -> U64FastFieldReader {
         let mut schema_builder = SchemaBuilder::default();
         let field = schema_builder.add_u64_field("field", FAST);
         let schema = schema_builder.build();
-        let path = Path::new("test");
+        let path = Path::new("__dummy__");
         let mut directory: RAMDirectory = RAMDirectory::create();
         {
-            let write: WritePtr = directory.open_write(Path::new("test")).unwrap();
-            let mut serializer = FastFieldSerializer::new(write).unwrap();
+            let write: WritePtr = directory
+                .open_write(path)
+                .expect("With a RAMDirectory, this should never fail.");
+            let mut serializer = FastFieldSerializer::from_write(write)
+                .expect("With a RAMDirectory, this should never fail.");
             let mut fast_field_writers = FastFieldsWriter::from_schema(&schema);
-            for val in vals {
-                let mut fast_field_writer = fast_field_writers.get_field_writer(field).unwrap();
-                fast_field_writer.add_val(val);
+            {
+                let fast_field_writer = fast_field_writers
+                    .get_field_writer(field)
+                    .expect("With a RAMDirectory, this should never fail.");
+                for val in vals {
+                    fast_field_writer.add_val(val);
+                }
             }
             fast_field_writers.serialize(&mut serializer).unwrap();
             serializer.close().unwrap();
         }
-        directory
-            .open_read(path)
-            .chain_err(|| "Failed to open the file")
-            .and_then(|source| {
-                          FastFieldsReader::from_source(source)
-                              .chain_err(|| "Failed to read the file.")
-                      })
-            .and_then(|ff_readers| {
-                          ff_readers
-                              .open_reader(field)
-                              .ok_or_else(|| "Failed to find the requested field".into())
-                      })
-            .expect("This should never happen, please report.")
 
+        let source = directory.open_read(path).expect("Failed to open the file");
+        let composite_file =
+            CompositeFile::open(&source).expect("Failed to read the composite file");
+
+        let field_source = composite_file
+            .open_read(field)
+            .expect("File component not found");
+        U64FastFieldReader::open(field_source)
     }
 }
 
@@ -212,7 +207,7 @@ impl FastFieldReader for I64FastFieldReader {
         let output_u64: &mut [u64] = unsafe { mem::transmute(output) };
         self.underlying.get_range(start, output_u64);
         for mut_val in output_u64.iter_mut() {
-            *mut_val ^= 1 << 63;
+            *mut_val = common::u64_to_i64(*mut_val as u64) as u64;
         }
     }
 
@@ -221,7 +216,9 @@ impl FastFieldReader for I64FastFieldReader {
     /// # Panics
     /// Panics if the data is corrupted.
     fn open(data: ReadOnlySource) -> I64FastFieldReader {
-        I64FastFieldReader { underlying: U64FastFieldReader::open(data) }
+        I64FastFieldReader {
+            underlying: U64FastFieldReader::open(data),
+        }
     }
 
     fn is_enabled(field_type: &FieldType) -> bool {
@@ -231,67 +228,3 @@ impl FastFieldReader for I64FastFieldReader {
         }
     }
 }
-
-
-
-/// The `FastFieldsReader` is the datastructure containing
-/// all of the fast fields' data.
-///
-/// It contains a mapping that associated these fields to
-/// the proper slice in the fastfield reader file.
-pub struct FastFieldsReader {
-    source: ReadOnlySource,
-    field_offsets: HashMap<Field, (u32, u32)>,
-}
-
-impl FastFieldsReader {
-    /// Opens a `FastFieldsReader`
-    ///
-    /// When opening the fast field reader, the
-    /// the list of the offset is read (as a footer of the
-    /// data file).
-    pub fn from_source(source: ReadOnlySource) -> io::Result<FastFieldsReader> {
-        let header_offset;
-        let field_offsets: Vec<(Field, u32)>;
-        {
-            let buffer = source.as_slice();
-            {
-                let mut cursor = buffer;
-                header_offset = u32::deserialize(&mut cursor)?;
-            }
-            {
-                let mut cursor = &buffer[header_offset as usize..];
-                field_offsets = Vec::deserialize(&mut cursor)?;
-            }
-        }
-        let mut end_offsets: Vec<u32> = field_offsets.iter().map(|&(_, offset)| offset).collect();
-        end_offsets.push(header_offset);
-        let mut field_offsets_map: HashMap<Field, (u32, u32)> = HashMap::new();
-        for (field_start_offsets, stop_offset) in
-            field_offsets.iter().zip(end_offsets.iter().skip(1)) {
-            let (field, start_offset) = *field_start_offsets;
-            field_offsets_map.insert(field, (start_offset, *stop_offset));
-        }
-        Ok(FastFieldsReader {
-               field_offsets: field_offsets_map,
-               source: source,
-           })
-    }
-
-    /// Returns the u64 fast value reader if the field
-    /// is a u64 field indexed as "fast".
-    ///
-    /// Return None if the field is not a u64 field
-    /// indexed with the fast option.
-    ///
-    /// # Panics
-    /// May panic if the index is corrupted.
-    pub fn open_reader<FFReader: FastFieldReader>(&self, field: Field) -> Option<FFReader> {
-        self.field_offsets
-            .get(&field)
-            .map(|&(start, stop)| {
-                     let field_source = self.source.slice(start as usize, stop as usize);
-                     FFReader::open(field_source)
-                 })
-    }
-}

src/fastfield/serializer.rs

@@ -3,7 +3,8 @@ use directory::WritePtr;
 use schema::Field;
 use common::bitpacker::{compute_num_bits, BitPacker};
 use common::CountingWriter;
-use std::io::{self, Write, Seek, SeekFrom};
+use common::CompositeWrite;
+use std::io::{self, Write};
 
 /// `FastFieldSerializer` is in charge of serializing
 /// fastfields on disk.
@@ -26,51 +27,60 @@ use std::io::{self, Write, Seek, SeekFrom};
 /// * `close_field()`
 /// * `close()`
 pub struct FastFieldSerializer {
-    write: CountingWriter<WritePtr>,
-    fields: Vec<(Field, u32)>,
-    min_value: u64,
-    field_open: bool,
-    bit_packer: BitPacker,
+    composite_write: CompositeWrite<WritePtr>,
 }
 
-
 impl FastFieldSerializer {
     /// Constructor
-    pub fn new(write: WritePtr) -> io::Result<FastFieldSerializer> {
+    pub fn from_write(write: WritePtr) -> io::Result<FastFieldSerializer> {
         // just making room for the pointer to header.
-        let mut counting_writer = CountingWriter::wrap(write);
-        0u32.serialize(&mut counting_writer)?;
-        Ok(FastFieldSerializer {
-               write: counting_writer,
-               fields: Vec::new(),
-               min_value: 0,
-               field_open: false,
-               bit_packer: BitPacker::new(0),
-           })
+        let composite_write = CompositeWrite::wrap(write);
+        Ok(FastFieldSerializer { composite_write })
     }
 
     /// Start serializing a new u64 fast field
-    pub fn new_u64_fast_field(&mut self,
-                              field: Field,
-                              min_value: u64,
-                              max_value: u64)
-                              -> io::Result<()> {
-        if self.field_open {
-            return Err(io::Error::new(io::ErrorKind::Other, "Previous field not closed"));
-        }
-        self.min_value = min_value;
-        self.field_open = true;
-        self.fields.push((field, self.write.written_bytes() as u32));
-        let write = &mut self.write;
+    pub fn new_u64_fast_field(
+        &mut self,
+        field: Field,
+        min_value: u64,
+        max_value: u64,
+    ) -> io::Result<FastSingleFieldSerializer<CountingWriter<WritePtr>>> {
+        let field_write = self.composite_write.for_field(field);
+        FastSingleFieldSerializer::open(field_write, min_value, max_value)
+    }
+
+    /// Closes the serializer
+    ///
+    /// After this call the data must be persistently save on disk.
+    pub fn close(self) -> io::Result<()> {
+        self.composite_write.close()
+    }
+}
+
+pub struct FastSingleFieldSerializer<'a, W: Write + 'a> {
+    bit_packer: BitPacker,
+    write: &'a mut W,
+    min_value: u64,
+}
+
+impl<'a, W: Write> FastSingleFieldSerializer<'a, W> {
+    fn open(
+        write: &'a mut W,
+        min_value: u64,
+        max_value: u64,
+    ) -> io::Result<FastSingleFieldSerializer<'a, W>> {
         min_value.serialize(write)?;
         let amplitude = max_value - min_value;
         amplitude.serialize(write)?;
         let num_bits = compute_num_bits(amplitude);
-        self.bit_packer = BitPacker::new(num_bits as usize);
-        Ok(())
+        let bit_packer = BitPacker::new(num_bits as usize);
+        Ok(FastSingleFieldSerializer {
+            write,
+            bit_packer,
+            min_value,
+        })
     }
 
-
     /// Pushes a new value to the currently open u64 fast field.
     pub fn add_val(&mut self, val: u64) -> io::Result<()> {
         let val_to_write: u64 = val - self.min_value;
@@ -78,33 +88,7 @@ impl FastFieldSerializer {
         Ok(())
     }
 
-    /// Close the u64 fast field.
-    pub fn close_field(&mut self) -> io::Result<()> {
-        if !self.field_open {
-            return Err(io::Error::new(io::ErrorKind::Other, "Current field is already closed"));
-        }
-        self.field_open = false;
-        // adding some padding to make sure we
-        // can read the last elements with our u64
-        // cursor
-        self.bit_packer.close(&mut self.write)?;
-        Ok(())
-    }
-
-
-    /// Closes the serializer
-    ///
-    /// After this call the data must be persistently save on disk.
-    pub fn close(self) -> io::Result<usize> {
-        if self.field_open {
-            return Err(io::Error::new(io::ErrorKind::Other, "Last field not closed"));
-        }
-        let header_offset: usize = self.write.written_bytes() as usize;
-        let (mut write, written_size) = self.write.finish()?;
-        self.fields.serialize(&mut write)?;
-        write.seek(SeekFrom::Start(0))?;
-        (header_offset as u32).serialize(&mut write)?;
-        write.flush()?;
-        Ok(written_size)
+    pub fn close_field(mut self) -> io::Result<()> {
+        self.bit_packer.close(&mut self.write)
     }
 }

src/fastfield/writer.rs

@@ -1,4 +1,4 @@
-use schema::{Schema, Field, Document};
+use schema::{Document, Field, Schema};
 use fastfield::FastFieldSerializer;
 use std::io;
 use schema::Value;
@@ -43,7 +43,7 @@ impl FastFieldsWriter {
                 }
             })
             .collect();
-        FastFieldsWriter { field_writers: field_writers }
+        FastFieldsWriter { field_writers }
     }
 
     /// Returns a `FastFieldsWriter`
@@ -63,7 +63,6 @@ impl FastFieldsWriter {
             .find(|field_writer| field_writer.field == field)
     }
 
-
     /// Indexes all of the fastfields of a new document.
     pub fn add_document(&mut self, doc: &Document) {
         for field_writer in &mut self.field_writers {
@@ -119,7 +118,7 @@ impl IntFastFieldWriter {
     /// Creates a new `IntFastFieldWriter`
     pub fn new(field: Field) -> IntFastFieldWriter {
         IntFastFieldWriter {
-            field: field,
+            field,
             vals: Vec::new(),
             val_count: 0,
             val_if_missing: 0u64,
@@ -169,7 +168,6 @@ impl IntFastFieldWriter {
         self.val_count += 1;
     }
 
-
     /// Extract the value associated to the fast field for
     /// this document.
     ///
@@ -182,13 +180,11 @@ impl IntFastFieldWriter {
     /// only the first one is taken in account.
     fn extract_val(&self, doc: &Document) -> u64 {
         match doc.get_first(self.field) {
-            Some(v) => {
-                match *v {
-                    Value::U64(ref val) => *val,
-                    Value::I64(ref val) => common::i64_to_u64(*val),
-                    _ => panic!("Expected a u64field, got {:?} ", v),
-                }
-            }
+            Some(v) => match *v {
+                Value::U64(ref val) => *val,
+                Value::I64(ref val) => common::i64_to_u64(*val),
+                _ => panic!("Expected a u64field, got {:?} ", v),
+            },
             None => self.val_if_missing,
         }
     }
@@ -208,13 +204,13 @@ impl IntFastFieldWriter {
             (self.val_min, self.val_max)
         };
 
-        serializer.new_u64_fast_field(self.field, min, max)?;
+        let mut single_field_serializer = serializer.new_u64_fast_field(self.field, min, max)?;
 
         let mut cursor = self.vals.as_slice();
         while let Ok(VInt(val)) = VInt::deserialize(&mut cursor) {
-            serializer.add_val(val)?;
+            single_field_serializer.add_val(val)?;
         }
 
-        serializer.close_field()
+        single_field_serializer.close_field()
     }
 }

src/functional_test.rs

@@ -14,7 +14,6 @@ fn check_index_content(searcher: &Searcher, vals: &HashSet<u64>) {
 #[test]
 #[ignore]
 fn test_indexing() {
-
     let mut schema_builder = SchemaBuilder::default();
 
     let id_field = schema_builder.add_u64_field("id", INT_INDEXED);

src/indexer/delete_queue.rs

@@ -3,7 +3,6 @@ use std::sync::{Arc, RwLock};
 use std::mem;
 use std::ops::DerefMut;
 
-
 // The DeleteQueue is similar in conceptually to a multiple
 // consumer single producer broadcast channel.
 //
@@ -16,7 +15,7 @@ use std::ops::DerefMut;
 // - calling `delete_queue.cursor()` returns a cursor, that
 //   will include all future delete operation (and no past operations).
 // - cloning an existing cursor returns a new cursor, that
-//   is at the exact same position, and can now advance independantly
+//   is at the exact same position, and can now advance independently
 //   from the original cursor.
 #[derive(Default)]
 struct InnerDeleteQueue {
@@ -29,26 +28,25 @@ pub struct DeleteQueue {
     inner: Arc<RwLock<InnerDeleteQueue>>,
 }
 
-
 impl DeleteQueue {
     // Creates a new delete queue.
     pub fn new() -> DeleteQueue {
-
-        let delete_queue = DeleteQueue { inner: Arc::default() };
+        let delete_queue = DeleteQueue {
+            inner: Arc::default(),
+        };
 
         let next_block = NextBlock::from(delete_queue.clone());
         {
             let mut delete_queue_wlock = delete_queue.inner.write().unwrap();
             delete_queue_wlock.last_block = Some(Arc::new(Block {
-                                                              operations: Arc::default(),
-                                                              next: next_block,
-                                                          }));
+                operations: Arc::default(),
+                next: next_block,
+            }));
         }
 
         delete_queue
     }
 
-
     // Creates a new cursor that makes it possible to
     // consume future delete operations.
     //
@@ -59,9 +57,11 @@ impl DeleteQueue {
             .expect("Read lock poisoned when opening delete queue cursor")
             .last_block
             .clone()
-            .expect("Failed to unwrap last_block. This should never happen
+            .expect(
+                "Failed to unwrap last_block. This should never happen
                 as the Option<> is only here to make
-                initialization possible");
+                initialization possible",
+            );
         let operations_len = last_block.operations.len();
         DeleteCursor {
             block: last_block,
@@ -108,9 +108,9 @@ impl DeleteQueue {
         let next_block = NextBlock::from(self.clone());
         {
             self_wlock.last_block = Some(Arc::new(Block {
-                                                      operations: Arc::new(delete_operations),
-                                                      next: next_block,
-                                                  }));
+                operations: Arc::new(delete_operations),
+                next: next_block,
+            }));
         }
         self_wlock.last_block.clone()
     }
@@ -136,7 +136,7 @@ impl NextBlock {
                 .read()
                 .expect("Failed to acquire write lock in delete queue");
             if let InnerNextBlock::Closed(ref block) = *next_read_lock {
-                return Some(block.clone());
+                return Some(Arc::clone(block));
             }
         }
         let next_block;
@@ -146,20 +146,18 @@ impl NextBlock {
                 .expect("Failed to acquire write lock in delete queue");
             match *next_write_lock {
                 InnerNextBlock::Closed(ref block) => {
-                    return Some(block.clone());
+                    return Some(Arc::clone(block));
                 }
-                InnerNextBlock::Writer(ref writer) => {
-                    match writer.flush() {
-                        Some(flushed_next_block) => {
-                            next_block = flushed_next_block;
-                        }
-                        None => {
-                            return None;
-                        }
+                InnerNextBlock::Writer(ref writer) => match writer.flush() {
+                    Some(flushed_next_block) => {
+                        next_block = flushed_next_block;
                     }
-                }
+                    None => {
+                        return None;
+                    }
+                },
             }
-            *next_write_lock.deref_mut() = InnerNextBlock::Closed(next_block.clone());
+            *next_write_lock.deref_mut() = InnerNextBlock::Closed(Arc::clone(&next_block));
             Some(next_block)
         }
     }
@@ -170,14 +168,12 @@ struct Block {
     next: NextBlock,
 }
 
-
 #[derive(Clone)]
 pub struct DeleteCursor {
     block: Arc<Block>,
     pos: usize,
 }
 
-
 impl DeleteCursor {
     /// Skips operations and position it so that
     /// - either all of the delete operation currently in the
@@ -246,16 +242,11 @@ impl DeleteCursor {
     }
 }
 
-
-
-
-
-
 #[cfg(test)]
 mod tests {
 
-    use super::{DeleteQueue, DeleteOperation};
-    use schema::{Term, Field};
+    use super::{DeleteOperation, DeleteQueue};
+    use schema::{Field, Term};
 
     #[test]
     fn test_deletequeue() {
@@ -302,6 +293,5 @@ mod tests {
             operations_it.advance();
             assert!(operations_it.get().is_none());
         }
-
     }
 }

src/indexer/directory_lock.rs

@@ -2,8 +2,6 @@ use Directory;
 use directory::error::OpenWriteError;
 use core::LOCKFILE_FILEPATH;
 
-
-
 /// The directory lock is a mechanism used to
 /// prevent the creation of two [`IndexWriter`](struct.IndexWriter.html)
 ///
@@ -15,8 +13,8 @@ pub struct DirectoryLock {
 
 impl DirectoryLock {
     pub fn lock(mut directory: Box<Directory>) -> Result<DirectoryLock, OpenWriteError> {
-        try!(directory.open_write(&*LOCKFILE_FILEPATH));
-        Ok(DirectoryLock { directory: directory })
+        directory.open_write(&*LOCKFILE_FILEPATH)?;
+        Ok(DirectoryLock { directory })
     }
 }
 

src/indexer/doc_opstamp_mapping.rs

@@ -1,7 +1,6 @@
 use std::sync::Arc;
 use DocId;
 
-
 // Doc to opstamp is used to identify which
 // document should be deleted.
 //
@@ -56,8 +55,10 @@ mod tests {
     #[test]
     fn test_doc_to_opstamp_mapping_none() {
         let doc_to_opstamp_mapping = DocToOpstampMapping::None;
-        assert_eq!(doc_to_opstamp_mapping.compute_doc_limit(1),
-                   u32::max_value());
+        assert_eq!(
+            doc_to_opstamp_mapping.compute_doc_limit(1),
+            u32::max_value()
+        );
     }
 
     #[test]

src/indexer/index_writer.rs

@@ -22,7 +22,7 @@ use indexer::operation::DeleteOperation;
 use indexer::SegmentEntry;
 use indexer::SegmentWriter;
 use postings::DocSet;
-use postings::SegmentPostingsOption;
+use schema::IndexRecordOption;
 use schema::Document;
 use schema::Schema;
 use schema::Term;
@@ -52,7 +52,7 @@ type DocumentReceiver = chan::Receiver<AddOperation>;
 ///
 /// It manages a small number of indexing thread, as well as a shared
 /// indexing queue.
-/// Each indexing thread builds its own independant `Segment`, via
+/// Each indexing thread builds its own independent `Segment`, via
 /// a `SegmentWriter` object.
 pub struct IndexWriter {
     // the lock is just used to bind the
@@ -86,8 +86,6 @@ pub struct IndexWriter {
 impl !Send for IndexWriter {}
 impl !Sync for IndexWriter {}
 
-
-
 /// Open a new index writer. Attempts to acquire a lockfile.
 ///
 /// The lockfile should be deleted on drop, but it is possible
@@ -102,14 +100,16 @@ impl !Sync for IndexWriter {}
 /// If the lockfile already exists, returns `Error::FileAlreadyExists`.
 /// # Panics
 /// If the heap size per thread is too small, panics.
-pub fn open_index_writer(index: &Index,
-                         num_threads: usize,
-                         heap_size_in_bytes_per_thread: usize)
-                         -> Result<IndexWriter> {
-
+pub fn open_index_writer(
+    index: &Index,
+    num_threads: usize,
+    heap_size_in_bytes_per_thread: usize,
+) -> Result<IndexWriter> {
     if heap_size_in_bytes_per_thread <= HEAP_SIZE_LIMIT as usize {
-        panic!(format!("The heap size per thread needs to be at least {}.",
-                       HEAP_SIZE_LIMIT));
+        panic!(format!(
+            "The heap size per thread needs to be at least {}.",
+            HEAP_SIZE_LIMIT
+        ));
     }
 
     let directory_lock = DirectoryLock::lock(index.directory().box_clone())?;
@@ -117,7 +117,6 @@ pub fn open_index_writer(index: &Index,
     let (document_sender, document_receiver): (DocumentSender, DocumentReceiver) =
         chan::sync(PIPELINE_MAX_SIZE_IN_DOCS);
 
-
     let delete_queue = DeleteQueue::new();
 
     let current_opstamp = index.opstamp();
@@ -125,26 +124,26 @@ pub fn open_index_writer(index: &Index,
     let stamper = Stamper::new(current_opstamp);
 
     let segment_updater =
-        SegmentUpdater::new(index.clone(), stamper.clone(), delete_queue.cursor())?;
+        SegmentUpdater::new(index.clone(), stamper.clone(), &delete_queue.cursor())?;
 
     let mut index_writer = IndexWriter {
         _directory_lock: directory_lock,
 
-        heap_size_in_bytes_per_thread: heap_size_in_bytes_per_thread,
+        heap_size_in_bytes_per_thread,
         index: index.clone(),
 
-        document_receiver: document_receiver,
-        document_sender: document_sender,
+        document_receiver,
+        document_sender,
 
-        segment_updater: segment_updater,
+        segment_updater,
 
         workers_join_handle: vec![],
-        num_threads: num_threads,
+        num_threads,
 
-        delete_queue: delete_queue,
+        delete_queue,
 
         committed_opstamp: current_opstamp,
-        stamper: stamper,
+        stamper,
 
         generation: 0,
 
@@ -154,15 +153,13 @@ pub fn open_index_writer(index: &Index,
     Ok(index_writer)
 }
 
-
-
-pub fn compute_deleted_bitset(delete_bitset: &mut BitSet,
-                              segment_reader: &SegmentReader,
-                              delete_cursor: &mut DeleteCursor,
-                              doc_opstamps: &DocToOpstampMapping,
-                              target_opstamp: u64)
-                              -> Result<bool> {
-
+pub fn compute_deleted_bitset(
+    delete_bitset: &mut BitSet,
+    segment_reader: &SegmentReader,
+    delete_cursor: &mut DeleteCursor,
+    doc_opstamps: &DocToOpstampMapping,
+    target_opstamp: u64,
+) -> Result<bool> {
     let mut might_have_changed = false;
 
     #[cfg_attr(feature = "cargo-clippy", allow(while_let_loop))]
@@ -177,8 +174,10 @@ pub fn compute_deleted_bitset(delete_bitset: &mut BitSet,
                 // Limit doc helps identify the first document
                 // that may be affected by the delete operation.
                 let limit_doc = doc_opstamps.compute_doc_limit(delete_op.opstamp);
+                let inverted_index = segment_reader.inverted_index(delete_op.term.field());
                 if let Some(mut docset) =
-                    segment_reader.read_postings(&delete_op.term, SegmentPostingsOption::NoFreq) {
+                    inverted_index.read_postings(&delete_op.term, IndexRecordOption::Basic)
+                {
                     while docset.advance() {
                         let deleted_doc = docset.doc();
                         if deleted_doc < limit_doc {
@@ -198,11 +197,11 @@ pub fn compute_deleted_bitset(delete_bitset: &mut BitSet,
 
 /// Advance delete for the given segment up
 /// to the target opstamp.
-pub fn advance_deletes(mut segment: Segment,
-                       segment_entry: &mut SegmentEntry,
-                       target_opstamp: u64)
-                       -> Result<Option<FileProtection>> {
-
+pub fn advance_deletes(
+    mut segment: Segment,
+    segment_entry: &mut SegmentEntry,
+    target_opstamp: u64,
+) -> Result<Option<FileProtection>> {
     let mut file_protect: Option<FileProtection> = None;
 
     {
@@ -212,7 +211,7 @@ pub fn advance_deletes(mut segment: Segment,
                 return Ok(file_protect);
             }
         }
-        let segment_reader = SegmentReader::open(segment.clone())?;
+        let segment_reader = SegmentReader::open(&segment)?;
         let max_doc = segment_reader.max_doc();
 
         let mut delete_bitset: BitSet = match segment_entry.delete_bitset() {
@@ -222,11 +221,13 @@ pub fn advance_deletes(mut segment: Segment,
 
         let delete_cursor = segment_entry.delete_cursor();
 
-        compute_deleted_bitset(&mut delete_bitset,
-                               &segment_reader,
-                               delete_cursor,
-                               &DocToOpstampMapping::None,
-                               target_opstamp)?;
+        compute_deleted_bitset(
+            &mut delete_bitset,
+            &segment_reader,
+            delete_cursor,
+            &DocToOpstampMapping::None,
+            target_opstamp,
+        )?;
 
         for doc in 0u32..max_doc {
             if segment_reader.is_deleted(doc) {
@@ -247,26 +248,29 @@ pub fn advance_deletes(mut segment: Segment,
     Ok(file_protect)
 }
 
-fn index_documents(heap: &mut Heap,
-                   table_size: usize,
-                   segment: Segment,
-                   schema: &Schema,
-                   generation: usize,
-                   document_iterator: &mut Iterator<Item = AddOperation>,
-                   segment_updater: &mut SegmentUpdater,
-                   mut delete_cursor: DeleteCursor)
-                   -> Result<bool> {
+fn index_documents(
+    heap: &mut Heap,
+    table_size: usize,
+    segment: &Segment,
+    schema: &Schema,
+    generation: usize,
+    document_iterator: &mut Iterator<Item = AddOperation>,
+    segment_updater: &mut SegmentUpdater,
+    mut delete_cursor: DeleteCursor,
+) -> Result<bool> {
     heap.clear();
     let segment_id = segment.id();
     let mut segment_writer = SegmentWriter::for_segment(heap, table_size, segment.clone(), schema)?;
     for doc in document_iterator {
-        try!(segment_writer.add_document(&doc, schema));
+        segment_writer.add_document(&doc, schema)?;
         // There is two possible conditions to close the segment.
         // One is the memory arena dedicated to the segment is
         // getting full.
         if segment_writer.is_buffer_full() {
-            info!("Buffer limit reached, flushing segment with maxdoc={}.",
-                  segment_writer.max_doc());
+            info!(
+                "Buffer limit reached, flushing segment with maxdoc={}.",
+                segment_writer.max_doc()
+            );
             break;
         }
         // The second is the term dictionary hash table
@@ -275,8 +279,10 @@ fn index_documents(heap: &mut Heap,
         // Tantivy does not resize its hashtable. When it reaches
         // capacity, we just stop indexing new document.
         if segment_writer.is_term_saturated() {
-            info!("Term dic saturated, flushing segment with maxdoc={}.",
-                  segment_writer.max_doc());
+            info!(
+                "Term dic saturated, flushing segment with maxdoc={}.",
+                segment_writer.max_doc()
+            );
             break;
         }
     }
@@ -296,11 +302,13 @@ fn index_documents(heap: &mut Heap,
     let doc_to_opstamps = DocToOpstampMapping::from(doc_opstamps);
     let segment_reader = SegmentReader::open(segment)?;
     let mut deleted_bitset = BitSet::with_capacity(num_docs as usize);
-    let may_have_deletes = compute_deleted_bitset(&mut deleted_bitset,
-                                                  &segment_reader,
-                                                  &mut delete_cursor,
-                                                  &doc_to_opstamps,
-                                                  last_docstamp)?;
+    let may_have_deletes = compute_deleted_bitset(
+        &mut deleted_bitset,
+        &segment_reader,
+        &mut delete_cursor,
+        &doc_to_opstamps,
+        last_docstamp,
+    )?;
 
     let segment_entry = SegmentEntry::new(segment_meta, delete_cursor, {
         if may_have_deletes {
@@ -311,13 +319,11 @@ fn index_documents(heap: &mut Heap,
     });
 
     Ok(segment_updater.add_segment(generation, segment_entry))
-
 }
 
 impl IndexWriter {
     /// The index writer
     pub fn wait_merging_threads(mut self) -> Result<()> {
-
         // this will stop the indexing thread,
         // dropping the last reference to the segment_updater.
         drop(self.document_sender);
@@ -331,10 +337,9 @@ impl IndexWriter {
         }
         drop(self.workers_join_handle);
 
-        let result =
-            self.segment_updater
-                .wait_merging_thread()
-                .chain_err(|| ErrorKind::ErrorInThread("Failed to join merging thread.".into()));
+        let result = self.segment_updater
+            .wait_merging_thread()
+            .chain_err(|| ErrorKind::ErrorInThread("Failed to join merging thread.".into()));
 
         if let Err(ref e) = result {
             error!("Some merging thread failed {:?}", e);
@@ -372,11 +377,12 @@ impl IndexWriter {
         let mut delete_cursor = self.delete_queue.cursor();
 
         let join_handle: JoinHandle<Result<()>> = thread::Builder::new()
-            .name(format!("indexing thread {} for gen {}", self.worker_id, generation))
+            .name(format!(
+                "indexing thread {} for gen {}",
+                self.worker_id, generation
+            ))
             .spawn(move || {
-
                 loop {
-
                     let mut document_iterator =
                         document_receiver_clone.clone().into_iter().peekable();
 
@@ -396,15 +402,16 @@ impl IndexWriter {
                         return Ok(());
                     }
                     let segment = segment_updater.new_segment();
-                    index_documents(&mut heap,
-                                    table_size,
-                                    segment,
-                                    &schema,
-                                    generation,
-                                    &mut document_iterator,
-                                    &mut segment_updater,
-                                    delete_cursor.clone())?;
-
+                    index_documents(
+                        &mut heap,
+                        table_size,
+                        &segment,
+                        &schema,
+                        generation,
+                        &mut document_iterator,
+                        &mut segment_updater,
+                        delete_cursor.clone(),
+                    )?;
                 }
             })?;
         self.worker_id += 1;
@@ -424,7 +431,7 @@ impl IndexWriter {
 
     fn start_workers(&mut self) -> Result<()> {
         for _ in 0..self.num_threads {
-            try!(self.add_indexing_worker());
+            self.add_indexing_worker()?;
         }
         Ok(())
     }
@@ -436,9 +443,10 @@ impl IndexWriter {
     }
 
     /// Merges a given list of segments
-    pub fn merge(&mut self,
-                 segment_ids: &[SegmentId])
-                 -> impl Future<Item = SegmentMeta, Error = Canceled> {
+    pub fn merge(
+        &mut self,
+        segment_ids: &[SegmentId],
+    ) -> impl Future<Item = SegmentMeta, Error = Canceled> {
         self.segment_updater.start_merge(segment_ids)
     }
 
@@ -451,9 +459,10 @@ impl IndexWriter {
     ///
     /// Returns the former segment_ready channel.
     fn recreate_document_channel(&mut self) -> DocumentReceiver {
-        let (mut document_sender, mut document_receiver): (DocumentSender,
-                                                           DocumentReceiver) =
-            chan::sync(PIPELINE_MAX_SIZE_IN_DOCS);
+        let (mut document_sender, mut document_receiver): (
+            DocumentSender,
+            DocumentReceiver,
+        ) = chan::sync(PIPELINE_MAX_SIZE_IN_DOCS);
         swap(&mut self.document_sender, &mut document_sender);
         swap(&mut self.document_receiver, &mut document_receiver);
         document_receiver
@@ -484,10 +493,8 @@ impl IndexWriter {
         let index_writer = open_index_writer(&index, num_threads, heap_size_in_bytes_per_thread)?;
 
         Ok(index_writer)
-
     }
 
-
     /// Commits all of the pending changes
     ///
     /// A call to commit blocks.
@@ -503,7 +510,6 @@ impl IndexWriter {
     /// that made it in the commit.
     ///
     pub fn commit(&mut self) -> Result<u64> {
-
         // here, because we join all of the worker threads,
         // all of the segment update for this commit have been
         // sent.
@@ -522,22 +528,21 @@ impl IndexWriter {
         self.recreate_document_channel();
 
         let mut former_workers_join_handle = Vec::new();
-        swap(&mut former_workers_join_handle,
-             &mut self.workers_join_handle);
+        swap(
+            &mut former_workers_join_handle,
+            &mut self.workers_join_handle,
+        );
 
         for worker_handle in former_workers_join_handle {
-            let indexing_worker_result =
-                worker_handle
-                    .join()
-                    .map_err(|e| Error::from_kind(ErrorKind::ErrorInThread(format!("{:?}", e))))?;
+            let indexing_worker_result = worker_handle
+                .join()
+                .map_err(|e| Error::from_kind(ErrorKind::ErrorInThread(format!("{:?}", e))))?;
 
             indexing_worker_result?;
             // add a new worker for the next generation.
             self.add_indexing_worker()?;
         }
 
-
-
         // wait for the segment update thread to have processed the info
         self.segment_updater.commit(self.committed_opstamp)?;
 
@@ -554,10 +559,7 @@ impl IndexWriter {
     /// only after calling `commit()`.
     pub fn delete_term(&mut self, term: Term) -> u64 {
         let opstamp = self.stamper.stamp();
-        let delete_operation = DeleteOperation {
-            opstamp: opstamp,
-            term: term,
-        };
+        let delete_operation = DeleteOperation { opstamp, term };
         self.delete_queue.push(delete_operation);
         opstamp
     }
@@ -585,18 +587,12 @@ impl IndexWriter {
     /// have been added since the creation of the index.
     pub fn add_document(&mut self, document: Document) -> u64 {
         let opstamp = self.stamper.stamp();
-        let add_operation = AddOperation {
-            opstamp: opstamp,
-            document: document,
-        };
+        let add_operation = AddOperation { opstamp, document };
         self.document_sender.send(add_operation);
         opstamp
     }
 }
 
-
-
-
 #[cfg(test)]
 mod tests {
 
@@ -623,13 +619,17 @@ mod tests {
         let schema_builder = schema::SchemaBuilder::default();
         let index = Index::create_in_ram(schema_builder.build());
         let index_writer = index.writer(40_000_000).unwrap();
-        assert_eq!(format!("{:?}", index_writer.get_merge_policy()),
-                   "LogMergePolicy { min_merge_size: 8, min_layer_size: 10000, \
-                    level_log_size: 0.75 }");
+        assert_eq!(
+            format!("{:?}", index_writer.get_merge_policy()),
+            "LogMergePolicy { min_merge_size: 8, min_layer_size: 10000, \
+             level_log_size: 0.75 }"
+        );
         let merge_policy = box NoMergePolicy::default();
         index_writer.set_merge_policy(merge_policy);
-        assert_eq!(format!("{:?}", index_writer.get_merge_policy()),
-                   "NoMergePolicy");
+        assert_eq!(
+            format!("{:?}", index_writer.get_merge_policy()),
+            "NoMergePolicy"
+        );
     }
 
     #[test]
@@ -690,7 +690,6 @@ mod tests {
         index.searcher();
     }
 
-
     #[test]
     fn test_with_merges() {
         let _ = env_logger::init();
@@ -726,9 +725,7 @@ mod tests {
 
             assert_eq!(num_docs_containing("a"), 200);
             assert!(index.searchable_segments().unwrap().len() < 8);
-
         }
     }
 
-
 }

src/indexer/log_merge_policy.rs

@@ -1,5 +1,4 @@
-extern crate itertools;
-use super::merge_policy::{MergePolicy, MergeCandidate};
+use super::merge_policy::{MergeCandidate, MergePolicy};
 use core::SegmentMeta;
 use std::cmp;
 use std::f64;
@@ -8,7 +7,6 @@ const DEFAULT_LEVEL_LOG_SIZE: f64 = 0.75;
 const DEFAULT_MIN_LAYER_SIZE: u32 = 10_000;
 const DEFAULT_MIN_MERGE_SIZE: usize = 8;
 
-
 /// `LogMergePolicy` tries tries to merge segments that have a similar number of
 /// documents.
 #[derive(Debug, Clone)]
@@ -58,11 +56,11 @@ impl MergePolicy for LogMergePolicy {
             .enumerate()
             .collect::<Vec<(usize, u32)>>();
 
-        size_sorted_tuples.sort_by(|x, y| y.cmp(x));
+        size_sorted_tuples.sort_by(|x, y| y.1.cmp(&(x.1)));
 
         let size_sorted_log_tuples: Vec<_> = size_sorted_tuples
             .into_iter()
-            .map(|(ind, num_docs)| (ind, (self.clip_min_size(num_docs) as f64).log2()))
+            .map(|(ind, num_docs)| (ind, f64::from(self.clip_min_size(num_docs)).log2()))
             .collect();
 
         let (first_ind, first_score) = size_sorted_log_tuples[0];
@@ -102,7 +100,7 @@ impl Default for LogMergePolicy {
 mod tests {
     use super::*;
     use indexer::merge_policy::MergePolicy;
-    use core::{SegmentMeta, SegmentId};
+    use core::{SegmentId, SegmentMeta};
 
     fn test_merge_policy() -> LogMergePolicy {
         let mut log_merge_policy = LogMergePolicy::default();
@@ -134,12 +132,23 @@ mod tests {
     #[test]
     fn test_log_merge_policy_levels() {
         // multiple levels all get merged correctly
-        let test_input = vec![seg_meta(10),
-                              seg_meta(10),
-                              seg_meta(10),
-                              seg_meta(1000),
-                              seg_meta(1000),
-                              seg_meta(1000)];
+        // 2 MergeCandidates expected:
+        // * one with the 6 * 10-docs segments
+        // * one with the 3 * 1000-docs segments
+        // no MergeCandidate expected for the 2 * 10_000-docs segments as min_merge_size=3
+        let test_input = vec![
+            seg_meta(10),
+            seg_meta(10),
+            seg_meta(10),
+            seg_meta(1000),
+            seg_meta(1000),
+            seg_meta(1000),
+            seg_meta(10000),
+            seg_meta(10000),
+            seg_meta(10),
+            seg_meta(10),
+            seg_meta(10),
+        ];
         let result_list = test_merge_policy().compute_merge_candidates(&test_input);
         assert_eq!(result_list.len(), 2);
     }
@@ -147,24 +156,28 @@ mod tests {
     #[test]
     fn test_log_merge_policy_within_levels() {
         // multiple levels all get merged correctly
-        let test_input = vec![seg_meta(10),
-                              seg_meta(11),
-                              seg_meta(12),
-                              seg_meta(1000),
-                              seg_meta(1000),
-                              seg_meta(1000)];
+        let test_input = vec![
+            seg_meta(10),   // log2(10) = ~3.32 (> 3.58 - 0.75)
+            seg_meta(11),   // log2(11) = ~3.46
+            seg_meta(12),   // log2(12) = ~3.58
+            seg_meta(800),  // log2(800) = ~9.64 (> 9.97 - 0.75)
+            seg_meta(1000), // log2(1000) = ~9.97
+            seg_meta(1000),
+        ]; // log2(1000) = ~9.97
         let result_list = test_merge_policy().compute_merge_candidates(&test_input);
         assert_eq!(result_list.len(), 2);
     }
     #[test]
     fn test_log_merge_policy_small_segments() {
-        // multiple levels all get merged correctly
-        let test_input = vec![seg_meta(1),
-                              seg_meta(1),
-                              seg_meta(1),
-                              seg_meta(2),
-                              seg_meta(2),
-                              seg_meta(2)];
+        // segments under min_layer_size are merged together
+        let test_input = vec![
+            seg_meta(1),
+            seg_meta(1),
+            seg_meta(1),
+            seg_meta(2),
+            seg_meta(2),
+            seg_meta(2),
+        ];
         let result_list = test_merge_policy().compute_merge_candidates(&test_input);
         assert_eq!(result_list.len(), 1);
     }

src/indexer/merge_policy.rs

@@ -3,12 +3,10 @@ use core::SegmentMeta;
 use std::marker;
 use std::fmt::Debug;
 
-
 /// Set of segment suggested for a merge.
 #[derive(Debug, Clone)]
 pub struct MergeCandidate(pub Vec<SegmentId>);
 
-
 /// The `MergePolicy` defines which segments should be merged.
 ///
 /// Every time a the list of segments changes, the segment updater
@@ -43,7 +41,6 @@ impl MergePolicy for NoMergePolicy {
     }
 }
 
-
 #[cfg(test)]
 pub mod tests {
 
@@ -51,7 +48,6 @@ pub mod tests {
     use core::SegmentId;
     use core::SegmentMeta;
 
-
     /// `MergePolicy` useful for test purposes.
     ///
     /// Everytime there is more than one segment,

src/indexer/merger.rs

@@ -5,21 +5,21 @@ use DocId;
 use core::SerializableSegment;
 use schema::FieldValue;
 use indexer::SegmentSerializer;
-use postings::PostingsSerializer;
+use postings::InvertedIndexSerializer;
 use fastfield::U64FastFieldReader;
 use itertools::Itertools;
 use postings::Postings;
 use postings::DocSet;
 use fastfield::DeleteBitSet;
-use schema::{Schema, Field};
+use schema::{Field, Schema};
 use termdict::TermMerger;
 use fastfield::FastFieldSerializer;
 use fastfield::FastFieldReader;
 use store::StoreWriter;
-use std::cmp::{min, max};
+use std::cmp::{max, min};
+use termdict::TermDictionary;
 use schema::Term;
 use termdict::TermStreamer;
-use postings::SegmentPostingsOption;
 
 pub struct IndexMerger {
     schema: Schema,
@@ -27,34 +27,11 @@ pub struct IndexMerger {
     max_doc: u32,
 }
 
-
-struct DeltaPositionComputer {
-    buffer: Vec<u32>,
-}
-
-impl DeltaPositionComputer {
-    fn new() -> DeltaPositionComputer {
-        DeltaPositionComputer { buffer: vec![0u32; 512] }
-    }
-
-    fn compute_delta_positions(&mut self, positions: &[u32]) -> &[u32] {
-        if positions.len() > self.buffer.len() {
-            self.buffer.resize(positions.len(), 0u32);
-        }
-        let mut last_pos = 0u32;
-        for (i, position) in positions.iter().cloned().enumerate() {
-            self.buffer[i] = position - last_pos;
-            last_pos = position;
-        }
-        &self.buffer[..positions.len()]
-    }
-}
-
-
-fn compute_min_max_val(u64_reader: &U64FastFieldReader,
-                       max_doc: DocId,
-                       delete_bitset: &DeleteBitSet)
-                       -> Option<(u64, u64)> {
+fn compute_min_max_val(
+    u64_reader: &U64FastFieldReader,
+    max_doc: DocId,
+    delete_bitset: &DeleteBitSet,
+) -> Option<(u64, u64)> {
     if max_doc == 0 {
         None
     } else if !delete_bitset.has_deletes() {
@@ -72,16 +49,42 @@ fn compute_min_max_val(u64_reader: &U64FastFieldReader,
     }
 }
 
-fn extract_fieldnorm_reader(segment_reader: &SegmentReader,
-                            field: Field)
-                            -> Option<U64FastFieldReader> {
+fn extract_fieldnorm_reader(
+    segment_reader: &SegmentReader,
+    field: Field,
+) -> Option<U64FastFieldReader> {
     segment_reader.get_fieldnorms_reader(field)
 }
 
-fn extract_fast_field_reader(segment_reader: &SegmentReader,
-                             field: Field)
-                             -> Option<U64FastFieldReader> {
-    segment_reader.fast_fields_reader().open_reader(field)
+fn extract_fast_field_reader(
+    segment_reader: &SegmentReader,
+    field: Field,
+) -> Option<U64FastFieldReader> {
+    segment_reader.get_fast_field_reader(field).ok()
+}
+
+struct DeltaComputer {
+    buffer: Vec<u32>,
+}
+
+impl DeltaComputer {
+    fn new() -> DeltaComputer {
+        DeltaComputer {
+            buffer: vec![0u32; 512],
+        }
+    }
+
+    fn compute_delta(&mut self, positions: &[u32]) -> &[u32] {
+        if positions.len() > self.buffer.len() {
+            self.buffer.resize(positions.len(), 0u32);
+        }
+        let mut last_pos = 0u32;
+        for (cur_pos, dest) in positions.iter().cloned().zip(self.buffer.iter_mut()) {
+            *dest = cur_pos - last_pos;
+            last_pos = cur_pos;
+        }
+        &self.buffer[..positions.len()]
+    }
 }
 
 impl IndexMerger {
@@ -90,18 +93,19 @@ impl IndexMerger {
         let mut max_doc: u32 = 0u32;
         for segment in segments {
             if segment.meta().num_docs() > 0 {
-                let reader = SegmentReader::open(segment.clone())?;
+                let reader = SegmentReader::open(segment)?;
                 max_doc += reader.num_docs();
                 readers.push(reader);
             }
         }
         Ok(IndexMerger {
-               schema: schema,
-               readers: readers,
-               max_doc: max_doc,
-           })
+            schema,
+            readers,
+            max_doc,
+        })
     }
 
+    #[inline(never)]
     fn write_fieldnorms(&self, fast_field_serializer: &mut FastFieldSerializer) -> Result<()> {
         let fieldnorm_fastfields: Vec<Field> = self.schema
             .fields()
@@ -110,11 +114,14 @@ impl IndexMerger {
             .filter(|&(_, field_entry)| field_entry.is_indexed())
             .map(|(field_id, _)| Field(field_id as u32))
             .collect();
-        self.generic_write_fast_field(fieldnorm_fastfields,
-                                      &extract_fieldnorm_reader,
-                                      fast_field_serializer)
+        self.generic_write_fast_field(
+            fieldnorm_fastfields,
+            &extract_fieldnorm_reader,
+            fast_field_serializer,
+        )
     }
 
+    #[inline(never)]
     fn write_fast_fields(&self, fast_field_serializer: &mut FastFieldSerializer) -> Result<()> {
         let fast_fields: Vec<Field> = self.schema
             .fields()
@@ -123,22 +130,21 @@ impl IndexMerger {
             .filter(|&(_, field_entry)| field_entry.is_int_fast())
             .map(|(field_id, _)| Field(field_id as u32))
             .collect();
-        self.generic_write_fast_field(fast_fields,
-                                      &extract_fast_field_reader,
-                                      fast_field_serializer)
+        self.generic_write_fast_field(
+            fast_fields,
+            &extract_fast_field_reader,
+            fast_field_serializer,
+        )
     }
 
-
     // used both to merge field norms and regular u64 fast fields.
-    fn generic_write_fast_field(&self,
-                                fields: Vec<Field>,
-                                field_reader_extractor: &Fn(&SegmentReader, Field)
-                                                            -> Option<U64FastFieldReader>,
-                                fast_field_serializer: &mut FastFieldSerializer)
-                                -> Result<()> {
-
+    fn generic_write_fast_field(
+        &self,
+        fields: Vec<Field>,
+        field_reader_extractor: &Fn(&SegmentReader, Field) -> Option<U64FastFieldReader>,
+        fast_field_serializer: &mut FastFieldSerializer,
+    ) -> Result<()> {
         for field in fields {
-
             let mut u64_readers = vec![];
             let mut min_val = u64::max_value();
             let mut max_val = u64::min_value();
@@ -146,20 +152,24 @@ impl IndexMerger {
             for reader in &self.readers {
                 match field_reader_extractor(reader, field) {
                     Some(u64_reader) => {
-                        if let Some((seg_min_val, seg_max_val)) =
-                            compute_min_max_val(&u64_reader,
-                                                reader.max_doc(),
-                                                reader.delete_bitset()) {
+                        if let Some((seg_min_val, seg_max_val)) = compute_min_max_val(
+                            &u64_reader,
+                            reader.max_doc(),
+                            reader.delete_bitset(),
+                        ) {
                             // the segment has some non-deleted documents
                             min_val = min(min_val, seg_min_val);
                             max_val = max(max_val, seg_max_val);
-                            u64_readers
-                                .push((reader.max_doc(), u64_reader, reader.delete_bitset()));
+                            u64_readers.push((
+                                reader.max_doc(),
+                                u64_reader,
+                                reader.delete_bitset(),
+                            ));
                         }
                     }
                     None => {
-                        let error_msg = format!("Failed to find a u64_reader for field {:?}",
-                                                field);
+                        let error_msg =
+                            format!("Failed to find a u64_reader for field {:?}", field);
                         error!("{}", error_msg);
                         bail!(ErrorKind::SchemaError(error_msg));
                     }
@@ -174,50 +184,63 @@ impl IndexMerger {
 
             assert!(min_val <= max_val);
 
-            fast_field_serializer
-                .new_u64_fast_field(field, min_val, max_val)?;
+            let mut fast_single_field_serializer =
+                fast_field_serializer.new_u64_fast_field(field, min_val, max_val)?;
             for (max_doc, u64_reader, delete_bitset) in u64_readers {
                 for doc_id in 0..max_doc {
                     if !delete_bitset.is_deleted(doc_id) {
                         let val = u64_reader.get(doc_id);
-                        fast_field_serializer.add_val(val)?;
+                        fast_single_field_serializer.add_val(val)?;
                     }
                 }
             }
 
-            fast_field_serializer.close_field()?;
+            fast_single_field_serializer.close_field()?;
         }
         Ok(())
     }
 
-    fn write_postings(&self, serializer: &mut PostingsSerializer) -> Result<()> {
+    #[inline(never)]
+    fn write_postings(&self, serializer: &mut InvertedIndexSerializer) -> Result<()> {
+        let mut delta_computer = DeltaComputer::new();
 
-        let mut merged_terms = TermMerger::from(&self.readers[..]);
-        let mut delta_position_computer = DeltaPositionComputer::new();
-
-        let mut max_doc = 0;
-
-        // map from segment doc ids to the resulting merged segment doc id.
-        let mut merged_doc_id_map: Vec<Vec<Option<DocId>>> = Vec::with_capacity(self.readers.len());
-
-        for reader in &self.readers {
-            let mut segment_local_map = Vec::with_capacity(reader.max_doc() as usize);
-            for doc_id in 0..reader.max_doc() {
-                if reader.is_deleted(doc_id) {
-                    segment_local_map.push(None);
-                } else {
-                    segment_local_map.push(Some(max_doc));
-                    max_doc += 1u32;
-                }
+        let mut indexed_fields = vec![];
+        for (field_ord, field_entry) in self.schema.fields().iter().enumerate() {
+            if field_entry.is_indexed() {
+                indexed_fields.push(Field(field_ord as u32));
             }
-            merged_doc_id_map.push(segment_local_map);
         }
 
-        let mut last_field: Option<Field> = None;
+        for indexed_field in indexed_fields {
+            let field_readers = self.readers
+                .iter()
+                .map(|reader| reader.inverted_index(indexed_field))
+                .collect::<Vec<_>>();
 
-        let mut segment_postings_option = SegmentPostingsOption::FreqAndPositions;
+            let field_term_streams = field_readers
+                .iter()
+                .map(|field_reader| field_reader.terms().stream())
+                .collect();
 
-        while merged_terms.advance() {
+            let mut merged_terms = TermMerger::new(field_term_streams);
+            let mut max_doc = 0;
+
+            // map from segment doc ids to the resulting merged segment doc id.
+            let mut merged_doc_id_map: Vec<Vec<Option<DocId>>> =
+                Vec::with_capacity(self.readers.len());
+
+            for reader in &self.readers {
+                let mut segment_local_map = Vec::with_capacity(reader.max_doc() as usize);
+                for doc_id in 0..reader.max_doc() {
+                    if reader.is_deleted(doc_id) {
+                        segment_local_map.push(None);
+                    } else {
+                        segment_local_map.push(Some(max_doc));
+                        max_doc += 1u32;
+                    }
+                }
+                merged_doc_id_map.push(segment_local_map);
+            }
 
             // Create the total list of doc ids
             // by stacking the doc ids from the different segment.
@@ -229,97 +252,98 @@ impl IndexMerger {
             // - Segment 2's doc ids become  [seg0.max_doc + seg1.max_doc,
             //                                seg0.max_doc + seg1.max_doc + seg2.max_doc]
             // ...
-            let term = Term::wrap(merged_terms.key());
-            let current_field = term.field();
 
-            if last_field != Some(current_field) {
-                // we reached a new field.
-                let field_entry = self.schema.get_field_entry(current_field);
-                // ... set segment postings option the new field.
-                segment_postings_option = field_entry
-                    .field_type()
-                    .get_segment_postings_option()
-                    .expect("Encounterred a field that is not supposed to be
-                         indexed. Have you modified the index?");
-                last_field = Some(current_field);
+            let mut field_serializer = serializer.new_field(indexed_field)?;
 
-                // it is perfectly safe to call `.new_field`
-                // even if there is no postings associated.
-                serializer.new_field(current_field);
-            }
+            let field_entry = self.schema.get_field_entry(indexed_field);
 
-            // Let's compute the list of non-empty posting lists
-            let segment_postings: Vec<_> = merged_terms
-                .current_kvs()
-                .iter()
-                .flat_map(|heap_item| {
-                    let segment_ord = heap_item.segment_ord;
-                    let term_info = heap_item.streamer.value();
-                    let segment_reader = &self.readers[heap_item.segment_ord];
-                    let mut segment_postings =
-                        segment_reader
+            // ... set segment postings option the new field.
+            let segment_postings_option =
+                field_entry.field_type().get_index_record_option().expect(
+                    "Encountered a field that is not supposed to be
+                         indexed. Have you modified the schema?",
+                );
+
+            while merged_terms.advance() {
+                let term = Term::wrap(merged_terms.key());
+
+                // Let's compute the list of non-empty posting lists
+                let segment_postings: Vec<_> = merged_terms
+                    .current_kvs()
+                    .iter()
+                    .flat_map(|heap_item| {
+                        let segment_ord = heap_item.segment_ord;
+                        let term_info = heap_item.streamer.value();
+                        let segment_reader = &self.readers[heap_item.segment_ord];
+                        let inverted_index = segment_reader.inverted_index(term.field());
+                        let mut segment_postings = inverted_index
                             .read_postings_from_terminfo(term_info, segment_postings_option);
-                    if segment_postings.advance() {
-                        Some((segment_ord, segment_postings))
-                    } else {
-                        None
+                        if segment_postings.advance() {
+                            Some((segment_ord, segment_postings))
+                        } else {
+                            None
+                        }
+                    })
+                    .collect();
+
+                // At this point, `segment_postings` contains the posting list
+                // of all of the segments containing the given term.
+                //
+                // These segments are non-empty and advance has already been called.
+
+                if !segment_postings.is_empty() {
+                    // If not, the `term` will be entirely removed.
+
+                    // We know that there is at least one document containing
+                    // the term, so we add it.
+                    field_serializer.new_term(term.as_ref())?;
+
+                    // We can now serialize this postings, by pushing each document to the
+                    // postings serializer.
+                    for (segment_ord, mut segment_postings) in segment_postings {
+                        let old_to_new_doc_id = &merged_doc_id_map[segment_ord];
+                        loop {
+                            // `.advance()` has been called once before the loop.
+                            // Hence we cannot use a `while segment_postings.advance()` loop.
+                            if let Some(remapped_doc_id) =
+                                old_to_new_doc_id[segment_postings.doc() as usize]
+                            {
+                                // we make sure to only write the term iff
+                                // there is at least one document.
+                                let positions: &[u32] = segment_postings.positions();
+                                let term_freq = segment_postings.term_freq();
+                                let delta_positions = delta_computer.compute_delta(positions);
+                                field_serializer.write_doc(
+                                    remapped_doc_id,
+                                    term_freq,
+                                    delta_positions,
+                                )?;
+                            }
+                            if !segment_postings.advance() {
+                                break;
+                            }
+                        }
                     }
-                })
-                .collect();
 
-            // At this point, `segment_postings` contains the posting list
-            // of all of the segments containing the given term.
-            //
-            // These segments are non-empty and advance has already been called.
-
-            if segment_postings.is_empty() {
-                // by continuing here, the `term` will be entirely removed.
-                continue;
-            }
-
-            // We know that there is at least one document containing
-            // the term, so we add it.
-            serializer.new_term(term.as_ref())?;
-
-            // We can now serialize this postings, by pushing each document to the
-            // postings serializer.
-
-            for (segment_ord, mut segment_postings) in segment_postings {
-                let old_to_new_doc_id = &merged_doc_id_map[segment_ord];
-                loop {
-                    // `.advance()` has been called once before the loop.
-                    // Hence we cannot use a `while segment_postings.advance()` loop.
-                    if let Some(remapped_doc_id) =
-                        old_to_new_doc_id[segment_postings.doc() as usize] {
-                        // we make sure to only write the term iff
-                        // there is at least one document.
-                        let delta_positions: &[u32] =
-                            delta_position_computer
-                                .compute_delta_positions(segment_postings.positions());
-                        let term_freq = segment_postings.term_freq();
-                        serializer
-                            .write_doc(remapped_doc_id, term_freq, delta_positions)?;
-                    }
-                    if !segment_postings.advance() {
-                        break;
-                    }
+                    // closing the term.
+                    field_serializer.close_term()?;
                 }
             }
 
-            // closing the term.
-            serializer.close_term()?;
+            field_serializer.close()?;
         }
         Ok(())
     }
 
+    #[inline(never)]
     fn write_storable_fields(&self, store_writer: &mut StoreWriter) -> Result<()> {
         for reader in &self.readers {
             let store_reader = reader.get_store_reader();
             for doc_id in 0..reader.max_doc() {
                 if !reader.is_deleted(doc_id) {
-                    let doc = try!(store_reader.get(doc_id));
+                    let doc = store_reader.get(doc_id)?;
                     let field_values: Vec<&FieldValue> = doc.field_values().iter().collect();
-                    try!(store_writer.store(&field_values));
+                    store_writer.store(&field_values)?;
                 }
             }
         }
@@ -329,11 +353,11 @@ impl IndexMerger {
 
 impl SerializableSegment for IndexMerger {
     fn write(&self, mut serializer: SegmentSerializer) -> Result<u32> {
-        try!(self.write_postings(serializer.get_postings_serializer()));
-        try!(self.write_fieldnorms(serializer.get_fieldnorms_serializer()));
-        try!(self.write_fast_fields(serializer.get_fast_field_serializer()));
-        try!(self.write_storable_fields(serializer.get_store_writer()));
-        try!(serializer.close());
+        self.write_postings(serializer.get_postings_serializer())?;
+        self.write_fieldnorms(serializer.get_fieldnorms_serializer())?;
+        self.write_fast_fields(serializer.get_fast_field_serializer())?;
+        self.write_storable_fields(serializer.get_store_writer())?;
+        serializer.close()?;
         Ok(self.max_doc)
     }
 }
@@ -343,6 +367,7 @@ mod tests {
     use schema;
     use schema::Document;
     use schema::Term;
+    use schema::TextFieldIndexing;
     use query::TermQuery;
     use schema::Field;
     use core::Index;
@@ -352,15 +377,18 @@ mod tests {
     use collector::tests::FastFieldTestCollector;
     use collector::tests::TestCollector;
     use query::BooleanQuery;
-    use postings::SegmentPostingsOption;
-    use schema::TextIndexingOptions;
+    use schema::IndexRecordOption;
     use futures::Future;
 
     #[test]
     fn test_index_merger_no_deletes() {
         let mut schema_builder = schema::SchemaBuilder::default();
         let text_fieldtype = schema::TextOptions::default()
-            .set_indexing_options(TextIndexingOptions::TokenizedWithFreq)
+            .set_indexing_options(
+                TextFieldIndexing::default()
+                    .set_tokenizer("default")
+                    .set_index_option(IndexRecordOption::WithFreqs),
+            )
             .set_stored();
         let text_field = schema_builder.add_text_field("text", text_fieldtype);
         let score_fieldtype = schema::IntOptions::default().set_fast();
@@ -430,14 +458,22 @@ mod tests {
                 collector.docs()
             };
             {
-                assert_eq!(get_doc_ids(vec![Term::from_field_text(text_field, "a")]),
-                           vec![1, 2, 4]);
-                assert_eq!(get_doc_ids(vec![Term::from_field_text(text_field, "af")]),
-                           vec![0, 3]);
-                assert_eq!(get_doc_ids(vec![Term::from_field_text(text_field, "g")]),
-                           vec![4]);
-                assert_eq!(get_doc_ids(vec![Term::from_field_text(text_field, "b")]),
-                           vec![0, 1, 2, 3, 4]);
+                assert_eq!(
+                    get_doc_ids(vec![Term::from_field_text(text_field, "a")]),
+                    vec![1, 2, 4]
+                );
+                assert_eq!(
+                    get_doc_ids(vec![Term::from_field_text(text_field, "af")]),
+                    vec![0, 3]
+                );
+                assert_eq!(
+                    get_doc_ids(vec![Term::from_field_text(text_field, "g")]),
+                    vec![4]
+                );
+                assert_eq!(
+                    get_doc_ids(vec![Term::from_field_text(text_field, "b")]),
+                    vec![0, 1, 2, 3, 4]
+                );
             }
             {
                 let doc = searcher.doc(&DocAddress(0, 0)).unwrap();
@@ -466,15 +502,17 @@ mod tests {
                     assert!(searcher.search(&query, &mut collector).is_ok());
                     collector.vals()
                 };
-                assert_eq!(get_fast_vals(vec![Term::from_field_text(text_field, "a")]),
-                           vec![5, 7, 13]);
+                assert_eq!(
+                    get_fast_vals(vec![Term::from_field_text(text_field, "a")]),
+                    vec![5, 7, 13]
+                );
             }
         }
     }
 
     fn search_term(searcher: &Searcher, term: Term) -> Vec<u64> {
         let mut collector = FastFieldTestCollector::for_field(Field(1));
-        let term_query = TermQuery::new(term, SegmentPostingsOption::NoFreq);
+        let term_query = TermQuery::new(term, IndexRecordOption::Basic);
         searcher.search(&term_query, &mut collector).unwrap();
         collector.vals()
     }
@@ -483,7 +521,9 @@ mod tests {
     fn test_index_merger_with_deletes() {
         let mut schema_builder = schema::SchemaBuilder::default();
         let text_fieldtype = schema::TextOptions::default()
-            .set_indexing_options(TextIndexingOptions::TokenizedWithFreq)
+            .set_indexing_options(
+                TextFieldIndexing::default().set_index_option(IndexRecordOption::WithFreqs),
+            )
             .set_stored();
         let text_field = schema_builder.add_text_field("text", text_fieldtype);
         let score_fieldtype = schema::IntOptions::default().set_fast();
@@ -514,14 +554,22 @@ mod tests {
             assert_eq!(searcher.num_docs(), 2);
             assert_eq!(searcher.segment_readers()[0].num_docs(), 2);
             assert_eq!(searcher.segment_readers()[0].max_doc(), 3);
-            assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "a")),
-                       vec![1]);
-            assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "b")),
-                       vec![1]);
-            assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "c")),
-                       vec![3]);
-            assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "d")),
-                       vec![1, 3]);
+            assert_eq!(
+                search_term(&searcher, Term::from_field_text(text_field, "a")),
+                vec![1]
+            );
+            assert_eq!(
+                search_term(&searcher, Term::from_field_text(text_field, "b")),
+                vec![1]
+            );
+            assert_eq!(
+                search_term(&searcher, Term::from_field_text(text_field, "c")),
+                vec![3]
+            );
+            assert_eq!(
+                search_term(&searcher, Term::from_field_text(text_field, "d")),
+                vec![1, 3]
+            );
         }
         {
             // a second commit
@@ -553,20 +601,34 @@ mod tests {
             assert_eq!(searcher.segment_readers()[0].max_doc(), 3);
             assert_eq!(searcher.segment_readers()[1].num_docs(), 2);
             assert_eq!(searcher.segment_readers()[1].max_doc(), 4);
-            assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "a")),
-                       empty_vec);
-            assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "b")),
-                       empty_vec);
-            assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "c")),
-                       vec![3]);
-            assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "d")),
-                       vec![3]);
-            assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "e")),
-                       empty_vec);
-            assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "f")),
-                       vec![6_000]);
-            assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "g")),
-                       vec![6_000, 7_000]);
+            assert_eq!(
+                search_term(&searcher, Term::from_field_text(text_field, "a")),
+                empty_vec
+            );
+            assert_eq!(
+                search_term(&searcher, Term::from_field_text(text_field, "b")),
+                empty_vec
+            );
+            assert_eq!(
+                search_term(&searcher, Term::from_field_text(text_field, "c")),
+                vec![3]
+            );
+            assert_eq!(
+                search_term(&searcher, Term::from_field_text(text_field, "d")),
+                vec![3]
+            );
+            assert_eq!(
+                search_term(&searcher, Term::from_field_text(text_field, "e")),
+                empty_vec
+            );
+            assert_eq!(
+                search_term(&searcher, Term::from_field_text(text_field, "f")),
+                vec![6_000]
+            );
+            assert_eq!(
+                search_term(&searcher, Term::from_field_text(text_field, "g")),
+                vec![6_000, 7_000]
+            );
 
             let score_field_reader: U64FastFieldReader = searcher
                 .segment_reader(0)
@@ -597,20 +659,34 @@ mod tests {
             assert_eq!(searcher.num_docs(), 3);
             assert_eq!(searcher.segment_readers()[0].num_docs(), 3);
             assert_eq!(searcher.segment_readers()[0].max_doc(), 3);
-            assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "a")),
-                       empty_vec);
-            assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "b")),
-                       empty_vec);
-            assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "c")),
-                       vec![3]);
-            assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "d")),
-                       vec![3]);
-            assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "e")),
-                       empty_vec);
-            assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "f")),
-                       vec![6_000]);
-            assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "g")),
-                       vec![6_000, 7_000]);
+            assert_eq!(
+                search_term(&searcher, Term::from_field_text(text_field, "a")),
+                empty_vec
+            );
+            assert_eq!(
+                search_term(&searcher, Term::from_field_text(text_field, "b")),
+                empty_vec
+            );
+            assert_eq!(
+                search_term(&searcher, Term::from_field_text(text_field, "c")),
+                vec![3]
+            );
+            assert_eq!(
+                search_term(&searcher, Term::from_field_text(text_field, "d")),
+                vec![3]
+            );
+            assert_eq!(
+                search_term(&searcher, Term::from_field_text(text_field, "e")),
+                empty_vec
+            );
+            assert_eq!(
+                search_term(&searcher, Term::from_field_text(text_field, "f")),
+                vec![6_000]
+            );
+            assert_eq!(
+                search_term(&searcher, Term::from_field_text(text_field, "g")),
+                vec![6_000, 7_000]
+            );
             let score_field_reader: U64FastFieldReader = searcher
                 .segment_reader(0)
                 .get_fast_field_reader(score_field)
@@ -629,20 +705,34 @@ mod tests {
             assert_eq!(searcher.num_docs(), 2);
             assert_eq!(searcher.segment_readers()[0].num_docs(), 2);
             assert_eq!(searcher.segment_readers()[0].max_doc(), 3);
-            assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "a")),
-                       empty_vec);
-            assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "b")),
-                       empty_vec);
-            assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "c")),
-                       empty_vec);
-            assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "d")),
-                       empty_vec);
-            assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "e")),
-                       empty_vec);
-            assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "f")),
-                       vec![6_000]);
-            assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "g")),
-                       vec![6_000, 7_000]);
+            assert_eq!(
+                search_term(&searcher, Term::from_field_text(text_field, "a")),
+                empty_vec
+            );
+            assert_eq!(
+                search_term(&searcher, Term::from_field_text(text_field, "b")),
+                empty_vec
+            );
+            assert_eq!(
+                search_term(&searcher, Term::from_field_text(text_field, "c")),
+                empty_vec
+            );
+            assert_eq!(
+                search_term(&searcher, Term::from_field_text(text_field, "d")),
+                empty_vec
+            );
+            assert_eq!(
+                search_term(&searcher, Term::from_field_text(text_field, "e")),
+                empty_vec
+            );
+            assert_eq!(
+                search_term(&searcher, Term::from_field_text(text_field, "f")),
+                vec![6_000]
+            );
+            assert_eq!(
+                search_term(&searcher, Term::from_field_text(text_field, "g")),
+                vec![6_000, 7_000]
+            );
             let score_field_reader: U64FastFieldReader = searcher
                 .segment_reader(0)
                 .get_fast_field_reader(score_field)
@@ -666,20 +756,34 @@ mod tests {
             assert_eq!(searcher.num_docs(), 2);
             assert_eq!(searcher.segment_readers()[0].num_docs(), 2);
             assert_eq!(searcher.segment_readers()[0].max_doc(), 2);
-            assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "a")),
-                       empty_vec);
-            assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "b")),
-                       empty_vec);
-            assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "c")),
-                       empty_vec);
-            assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "d")),
-                       empty_vec);
-            assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "e")),
-                       empty_vec);
-            assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "f")),
-                       vec![6_000]);
-            assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "g")),
-                       vec![6_000, 7_000]);
+            assert_eq!(
+                search_term(&searcher, Term::from_field_text(text_field, "a")),
+                empty_vec
+            );
+            assert_eq!(
+                search_term(&searcher, Term::from_field_text(text_field, "b")),
+                empty_vec
+            );
+            assert_eq!(
+                search_term(&searcher, Term::from_field_text(text_field, "c")),
+                empty_vec
+            );
+            assert_eq!(
+                search_term(&searcher, Term::from_field_text(text_field, "d")),
+                empty_vec
+            );
+            assert_eq!(
+                search_term(&searcher, Term::from_field_text(text_field, "e")),
+                empty_vec
+            );
+            assert_eq!(
+                search_term(&searcher, Term::from_field_text(text_field, "f")),
+                vec![6_000]
+            );
+            assert_eq!(
+                search_term(&searcher, Term::from_field_text(text_field, "g")),
+                vec![6_000, 7_000]
+            );
             let score_field_reader: U64FastFieldReader = searcher
                 .segment_reader(0)
                 .get_fast_field_reader(score_field)
@@ -704,7 +808,5 @@ mod tests {
             assert_eq!(searcher.segment_readers().len(), 1);
             assert_eq!(searcher.num_docs(), 0);
         }
-
-
     }
 }

src/indexer/mod.rs

@@ -19,7 +19,7 @@ pub use self::segment_serializer::SegmentSerializer;
 pub use self::segment_writer::SegmentWriter;
 pub use self::index_writer::IndexWriter;
 pub use self::log_merge_policy::LogMergePolicy;
-pub use self::merge_policy::{NoMergePolicy, MergeCandidate, MergePolicy};
+pub use self::merge_policy::{MergeCandidate, MergePolicy, NoMergePolicy};
 pub use self::segment_manager::SegmentManager;
 
 /// Alias for the default merge policy, which is the `LogMergePolicy`.

src/indexer/operation.rs

@@ -1,7 +1,6 @@
 use schema::Document;
 use schema::Term;
 
-
 /// Timestamped Delete operation.
 #[derive(Clone, Eq, PartialEq, Debug)]
 pub struct DeleteOperation {

src/indexer/segment_entry.rs

@@ -4,7 +4,6 @@ use indexer::delete_queue::DeleteCursor;
 use core::SegmentId;
 use std::fmt;
 
-
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
 pub enum SegmentState {
     Ready,
@@ -20,7 +19,6 @@ impl SegmentState {
     }
 }
 
-
 /// A segment entry describes the state of
 /// a given segment, at a given instant.
 ///
@@ -44,19 +42,19 @@ pub struct SegmentEntry {
 
 impl SegmentEntry {
     /// Create a new `SegmentEntry`
-    pub fn new(segment_meta: SegmentMeta,
-               delete_cursor: DeleteCursor,
-               delete_bitset: Option<BitSet>)
-               -> SegmentEntry {
+    pub fn new(
+        segment_meta: SegmentMeta,
+        delete_cursor: DeleteCursor,
+        delete_bitset: Option<BitSet>,
+    ) -> SegmentEntry {
         SegmentEntry {
             meta: segment_meta,
             state: SegmentState::Ready,
-            delete_bitset: delete_bitset,
-            delete_cursor: delete_cursor,
+            delete_bitset,
+            delete_cursor,
         }
     }
 
-
     /// Return a reference to the segment entry deleted bitset.
     ///
     /// `DocId` in this bitset are flagged as deleted.
@@ -69,7 +67,6 @@ impl SegmentEntry {
         self.meta = segment_meta;
     }
 
-
     /// Return a reference to the segment_entry's delete cursor
     pub fn delete_cursor(&mut self) -> &mut DeleteCursor {
         &mut self.delete_cursor
@@ -88,13 +85,11 @@ impl SegmentEntry {
         self.meta.id()
     }
 
-
     /// Accessor to the `SegmentMeta`
     pub fn meta(&self) -> &SegmentMeta {
         &self.meta
     }
 
-
     /// Mark the `SegmentEntry` as in merge.
     ///
     /// Only segments that are not already
@@ -112,7 +107,6 @@ impl SegmentEntry {
         self.state = SegmentState::Ready;
     }
 
-
     /// Returns true iff a segment should
     /// be considered for a merge.
     pub fn is_ready(&self) -> bool {

src/indexer/segment_manager.rs

@@ -1,7 +1,7 @@
 use super::segment_register::SegmentRegister;
 use std::sync::RwLock;
 use core::SegmentMeta;
-use core::{META_FILEPATH, LOCKFILE_FILEPATH};
+use core::{LOCKFILE_FILEPATH, META_FILEPATH};
 use core::SegmentId;
 use indexer::SegmentEntry;
 use std::path::PathBuf;
@@ -17,8 +17,6 @@ struct SegmentRegisters {
     writing: HashSet<SegmentId>,
 }
 
-
-
 /// The segment manager stores the list of segments
 /// as well as their state.
 ///
@@ -32,31 +30,35 @@ pub struct SegmentManager {
 impl Debug for SegmentManager {
     fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
         let lock = self.read();
-        write!(f,
-               "{{ uncommitted: {:?}, committed: {:?} }}",
-               lock.uncommitted,
-               lock.committed)
+        write!(
+            f,
+            "{{ uncommitted: {:?}, committed: {:?} }}",
+            lock.uncommitted, lock.committed
+        )
     }
 }
 
-pub fn get_mergeable_segments(segment_manager: &SegmentManager)
-                              -> (Vec<SegmentMeta>, Vec<SegmentMeta>) {
+pub fn get_mergeable_segments(
+    segment_manager: &SegmentManager,
+) -> (Vec<SegmentMeta>, Vec<SegmentMeta>) {
     let registers_lock = segment_manager.read();
-    (registers_lock.committed.get_mergeable_segments(),
-     registers_lock.uncommitted.get_mergeable_segments())
+    (
+        registers_lock.committed.get_mergeable_segments(),
+        registers_lock.uncommitted.get_mergeable_segments(),
+    )
 }
 
 impl SegmentManager {
-    pub fn from_segments(segment_metas: Vec<SegmentMeta>,
-                         delete_cursor: DeleteCursor)
-                         -> SegmentManager {
+    pub fn from_segments(
+        segment_metas: Vec<SegmentMeta>,
+        delete_cursor: &DeleteCursor,
+    ) -> SegmentManager {
         SegmentManager {
             registers: RwLock::new(SegmentRegisters {
-                                       uncommitted: SegmentRegister::default(),
-                                       committed: SegmentRegister::new(segment_metas,
-                                                                       delete_cursor),
-                                       writing: HashSet::new(),
-                                   }),
+                uncommitted: SegmentRegister::default(),
+                committed: SegmentRegister::new(segment_metas, delete_cursor),
+                writing: HashSet::new(),
+            }),
         }
     }
 
@@ -139,11 +141,11 @@ impl SegmentManager {
         }
     }
 
-
-    pub fn cancel_merge(&self,
-                        before_merge_segment_ids: &[SegmentId],
-                        after_merge_segment_id: SegmentId) {
-
+    pub fn cancel_merge(
+        &self,
+        before_merge_segment_ids: &[SegmentId],
+        after_merge_segment_id: SegmentId,
+    ) {
         let mut registers_lock = self.write();
 
         // we mark all segments are ready for merge.
@@ -151,12 +153,14 @@ impl SegmentManager {
             let target_segment_register: &mut SegmentRegister;
             target_segment_register = {
                 if registers_lock
-                       .uncommitted
-                       .contains_all(before_merge_segment_ids) {
+                    .uncommitted
+                    .contains_all(before_merge_segment_ids)
+                {
                     &mut registers_lock.uncommitted
                 } else if registers_lock
-                              .committed
-                              .contains_all(before_merge_segment_ids) {
+                    .committed
+                    .contains_all(before_merge_segment_ids)
+                {
                     &mut registers_lock.committed
                 } else {
                     warn!("couldn't find segment in SegmentManager");
@@ -173,7 +177,6 @@ impl SegmentManager {
         registers_lock.writing.remove(&after_merge_segment_id);
     }
 
-
     pub fn write_segment(&self, segment_id: SegmentId) {
         let mut registers_lock = self.write();
         registers_lock.writing.insert(segment_id);
@@ -185,23 +188,26 @@ impl SegmentManager {
         registers_lock.uncommitted.add_segment_entry(segment_entry);
     }
 
-    pub fn end_merge(&self,
-                     before_merge_segment_ids: &[SegmentId],
-                     after_merge_segment_entry: SegmentEntry) {
-
+    pub fn end_merge(
+        &self,
+        before_merge_segment_ids: &[SegmentId],
+        after_merge_segment_entry: SegmentEntry,
+    ) {
         let mut registers_lock = self.write();
         registers_lock
             .writing
             .remove(&after_merge_segment_entry.segment_id());
 
-        let mut target_register: &mut SegmentRegister = {
+        let target_register: &mut SegmentRegister = {
             if registers_lock
-                   .uncommitted
-                   .contains_all(before_merge_segment_ids) {
+                .uncommitted
+                .contains_all(before_merge_segment_ids)
+            {
                 &mut registers_lock.uncommitted
             } else if registers_lock
-                          .committed
-                          .contains_all(before_merge_segment_ids) {
+                .committed
+                .contains_all(before_merge_segment_ids)
+            {
                 &mut registers_lock.committed
             } else {
                 warn!("couldn't find segment in SegmentManager");
@@ -212,10 +218,6 @@ impl SegmentManager {
             target_register.remove_segment(segment_id);
         }
         target_register.add_segment_entry(after_merge_segment_entry);
-
-
-
-
     }
 
     pub fn committed_segment_metas(&self) -> Vec<SegmentMeta> {

src/indexer/segment_register.rs

@@ -19,19 +19,17 @@ pub struct SegmentRegister {
     segment_states: HashMap<SegmentId, SegmentEntry>,
 }
 
-
 impl Debug for SegmentRegister {
     fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
-        try!(write!(f, "SegmentRegister("));
+        write!(f, "SegmentRegister(")?;
         for (k, v) in &self.segment_states {
-            try!(write!(f, "{}:{}, ", k.short_uuid_string(), v.state().letter_code()));
+            write!(f, "{}:{}, ", k.short_uuid_string(), v.state().letter_code())?;
         }
-        try!(write!(f, ")"));
+        write!(f, ")")?;
         Ok(())
     }
 }
 
-
 impl SegmentRegister {
     pub fn clear(&mut self) {
         self.segment_states.clear();
@@ -102,18 +100,17 @@ impl SegmentRegister {
             .start_merge();
     }
 
-    pub fn new(segment_metas: Vec<SegmentMeta>, delete_cursor: DeleteCursor) -> SegmentRegister {
+    pub fn new(segment_metas: Vec<SegmentMeta>, delete_cursor: &DeleteCursor) -> SegmentRegister {
         let mut segment_states = HashMap::new();
         for segment_meta in segment_metas {
             let segment_id = segment_meta.id();
             let segment_entry = SegmentEntry::new(segment_meta, delete_cursor.clone(), None);
             segment_states.insert(segment_id, segment_entry);
         }
-        SegmentRegister { segment_states: segment_states }
+        SegmentRegister { segment_states }
     }
 }
 
-
 #[cfg(test)]
 mod tests {
     use indexer::SegmentState;
@@ -144,34 +141,42 @@ mod tests {
             let segment_entry = SegmentEntry::new(segment_meta, delete_queue.cursor(), None);
             segment_register.add_segment_entry(segment_entry);
         }
-        assert_eq!(segment_register
-                       .segment_entry(&segment_id_a)
-                       .unwrap()
-                       .state(),
-                   SegmentState::Ready);
+        assert_eq!(
+            segment_register
+                .segment_entry(&segment_id_a)
+                .unwrap()
+                .state(),
+            SegmentState::Ready
+        );
         assert_eq!(segment_ids(&segment_register), vec![segment_id_a]);
         {
             let segment_meta = SegmentMeta::new(segment_id_b);
             let segment_entry = SegmentEntry::new(segment_meta, delete_queue.cursor(), None);
             segment_register.add_segment_entry(segment_entry);
         }
-        assert_eq!(segment_register
-                       .segment_entry(&segment_id_b)
-                       .unwrap()
-                       .state(),
-                   SegmentState::Ready);
+        assert_eq!(
+            segment_register
+                .segment_entry(&segment_id_b)
+                .unwrap()
+                .state(),
+            SegmentState::Ready
+        );
         segment_register.start_merge(&segment_id_a);
         segment_register.start_merge(&segment_id_b);
-        assert_eq!(segment_register
-                       .segment_entry(&segment_id_a)
-                       .unwrap()
-                       .state(),
-                   SegmentState::InMerge);
-        assert_eq!(segment_register
-                       .segment_entry(&segment_id_b)
-                       .unwrap()
-                       .state(),
-                   SegmentState::InMerge);
+        assert_eq!(
+            segment_register
+                .segment_entry(&segment_id_a)
+                .unwrap()
+                .state(),
+            SegmentState::InMerge
+        );
+        assert_eq!(
+            segment_register
+                .segment_entry(&segment_id_b)
+                .unwrap()
+                .state(),
+            SegmentState::InMerge
+        );
         segment_register.remove_segment(&segment_id_a);
         segment_register.remove_segment(&segment_id_b);
         {

src/indexer/segment_serializer.rs

@@ -4,8 +4,7 @@ use core::Segment;
 use core::SegmentComponent;
 use fastfield::FastFieldSerializer;
 use store::StoreWriter;
-use postings::PostingsSerializer;
-
+use postings::InvertedIndexSerializer;
 
 /// Segment serializer is in charge of laying out on disk
 /// the data accumulated and sorted by the `SegmentWriter`.
@@ -13,31 +12,31 @@ pub struct SegmentSerializer {
     store_writer: StoreWriter,
     fast_field_serializer: FastFieldSerializer,
     fieldnorms_serializer: FastFieldSerializer,
-    postings_serializer: PostingsSerializer,
+    postings_serializer: InvertedIndexSerializer,
 }
 
 impl SegmentSerializer {
     /// Creates a new `SegmentSerializer`.
     pub fn for_segment(segment: &mut Segment) -> Result<SegmentSerializer> {
-        let store_write = try!(segment.open_write(SegmentComponent::STORE));
+        let store_write = segment.open_write(SegmentComponent::STORE)?;
 
-        let fast_field_write = try!(segment.open_write(SegmentComponent::FASTFIELDS));
-        let fast_field_serializer = try!(FastFieldSerializer::new(fast_field_write));
+        let fast_field_write = segment.open_write(SegmentComponent::FASTFIELDS)?;
+        let fast_field_serializer = FastFieldSerializer::from_write(fast_field_write)?;
 
-        let fieldnorms_write = try!(segment.open_write(SegmentComponent::FIELDNORMS));
-        let fieldnorms_serializer = try!(FastFieldSerializer::new(fieldnorms_write));
+        let fieldnorms_write = segment.open_write(SegmentComponent::FIELDNORMS)?;
+        let fieldnorms_serializer = FastFieldSerializer::from_write(fieldnorms_write)?;
 
-        let postings_serializer = try!(PostingsSerializer::open(segment));
+        let postings_serializer = InvertedIndexSerializer::open(segment)?;
         Ok(SegmentSerializer {
-               postings_serializer: postings_serializer,
-               store_writer: StoreWriter::new(store_write),
-               fast_field_serializer: fast_field_serializer,
-               fieldnorms_serializer: fieldnorms_serializer,
-           })
+            postings_serializer,
+            store_writer: StoreWriter::new(store_write),
+            fast_field_serializer,
+            fieldnorms_serializer,
+        })
     }
 
     /// Accessor to the `PostingsSerializer`.
-    pub fn get_postings_serializer(&mut self) -> &mut PostingsSerializer {
+    pub fn get_postings_serializer(&mut self) -> &mut InvertedIndexSerializer {
         &mut self.postings_serializer
     }
 
@@ -57,6 +56,7 @@ impl SegmentSerializer {
     }
 
     /// Finalize the segment serialization.
+    #[inline(never)]
     pub fn close(self) -> Result<()> {
         self.fast_field_serializer.close()?;
         self.postings_serializer.close()?;

src/indexer/segment_updater.rs

@@ -13,7 +13,7 @@ use futures::Future;
 use futures::Canceled;
 use futures::oneshot;
 use directory::FileProtection;
-use indexer::{MergePolicy, DefaultMergePolicy};
+use indexer::{DefaultMergePolicy, MergePolicy};
 use indexer::index_writer::advance_deletes;
 use indexer::MergeCandidate;
 use indexer::merger::IndexMerger;
@@ -29,13 +29,12 @@ use std::io::Write;
 use std::mem;
 use std::ops::DerefMut;
 use std::sync::Arc;
-use std::sync::atomic::{AtomicUsize, AtomicBool};
+use std::sync::atomic::{AtomicBool, AtomicUsize};
 use std::sync::atomic::Ordering;
 use std::sync::RwLock;
 use std::thread;
 use std::thread::JoinHandle;
-use super::segment_manager::{SegmentManager, get_mergeable_segments};
-
+use super::segment_manager::{get_mergeable_segments, SegmentManager};
 
 /// Save the index meta file.
 /// This operation is atomic :
@@ -50,8 +49,6 @@ pub fn save_new_metas(schema: Schema, opstamp: u64, directory: &mut Directory) -
     save_metas(vec![], schema, opstamp, directory)
 }
 
-
-
 /// Save the index meta file.
 /// This operation is atomic:
 /// Either
@@ -61,24 +58,24 @@ pub fn save_new_metas(schema: Schema, opstamp: u64, directory: &mut Directory) -
 /// and flushed.
 ///
 /// This method is not part of tantivy's public API
-pub fn save_metas(segment_metas: Vec<SegmentMeta>,
-                  schema: Schema,
-                  opstamp: u64,
-                  directory: &mut Directory)
-                  -> Result<()> {
+pub fn save_metas(
+    segment_metas: Vec<SegmentMeta>,
+    schema: Schema,
+    opstamp: u64,
+    directory: &mut Directory,
+) -> Result<()> {
     let metas = IndexMeta {
         segments: segment_metas,
-        schema: schema,
-        opstamp: opstamp,
+        schema,
+        opstamp,
     };
-    let mut w = try!(serde_json::to_vec_pretty(&metas));
-    try!(write!(&mut w, "\n"));
-    directory.atomic_write(&META_FILEPATH, &w[..])?;
+    let mut buffer = serde_json::to_vec_pretty(&metas)?;
+    write!(&mut buffer, "\n")?;
+    directory.atomic_write(&META_FILEPATH, &buffer[..])?;
     debug!("Saved metas {:?}", serde_json::to_string_pretty(&metas));
     Ok(())
 }
 
-
 // The segment update runner is in charge of processing all
 //  of the `SegmentUpdate`s.
 //
@@ -87,13 +84,12 @@ pub fn save_metas(segment_metas: Vec<SegmentMeta>,
 #[derive(Clone)]
 pub struct SegmentUpdater(Arc<InnerSegmentUpdater>);
 
-
-
-fn perform_merge(segment_ids: &[SegmentId],
-                 segment_updater: &SegmentUpdater,
-                 mut merged_segment: Segment,
-                 target_opstamp: u64)
-                 -> Result<SegmentEntry> {
+fn perform_merge(
+    segment_ids: &[SegmentId],
+    segment_updater: &SegmentUpdater,
+    mut merged_segment: Segment,
+    target_opstamp: u64,
+) -> Result<SegmentEntry> {
     // first we need to apply deletes to our segment.
     info!("Start merge: {:?}", segment_ids);
 
@@ -104,18 +100,21 @@ fn perform_merge(segment_ids: &[SegmentId],
     let mut file_protections: Vec<FileProtection> = vec![];
 
     for segment_id in segment_ids {
-        if let Some(mut segment_entry) =
-            segment_updater.0.segment_manager.segment_entry(segment_id) {
+        if let Some(mut segment_entry) = segment_updater.0.segment_manager.segment_entry(segment_id)
+        {
             let segment = index.segment(segment_entry.meta().clone());
             if let Some(file_protection) =
-                advance_deletes(segment, &mut segment_entry, target_opstamp)? {
+                advance_deletes(segment, &mut segment_entry, target_opstamp)?
+            {
                 file_protections.push(file_protection);
             }
             segment_entries.push(segment_entry);
         } else {
             error!("Error, had to abort merge as some of the segment is not managed anymore.");
-            let msg = format!("Segment {:?} requested for merge is not managed.",
-                              segment_id);
+            let msg = format!(
+                "Segment {:?} requested for merge is not managed.",
+                segment_id
+            );
             bail!(ErrorKind::InvalidArgument(msg));
         }
     }
@@ -127,7 +126,6 @@ fn perform_merge(segment_ids: &[SegmentId],
         .map(|segment_entry| index.segment(segment_entry.meta().clone()))
         .collect();
 
-
     // An IndexMerger is like a "view" of our merged segments.
     let merger: IndexMerger = IndexMerger::open(schema, &segments[..])?;
 
@@ -147,7 +145,6 @@ fn perform_merge(segment_ids: &[SegmentId],
     Ok(after_merge_segment_entry)
 }
 
-
 struct InnerSegmentUpdater {
     pool: CpuPool,
     index: Index,
@@ -161,23 +158,24 @@ struct InnerSegmentUpdater {
 }
 
 impl SegmentUpdater {
-    pub fn new(index: Index,
-               stamper: Stamper,
-               delete_cursor: DeleteCursor)
-               -> Result<SegmentUpdater> {
+    pub fn new(
+        index: Index,
+        stamper: Stamper,
+        delete_cursor: &DeleteCursor,
+    ) -> Result<SegmentUpdater> {
         let segments = index.searchable_segment_metas()?;
         let segment_manager = SegmentManager::from_segments(segments, delete_cursor);
         Ok(SegmentUpdater(Arc::new(InnerSegmentUpdater {
-                                       pool: CpuPool::new(1),
-                                       index: index,
-                                       segment_manager: segment_manager,
-                                       merge_policy: RwLock::new(box DefaultMergePolicy::default()),
-                                       merging_thread_id: AtomicUsize::default(),
-                                       merging_threads: RwLock::new(HashMap::new()),
-                                       generation: AtomicUsize::default(),
-                                       killed: AtomicBool::new(false),
-                                       stamper: stamper,
-                                   })))
+            pool: CpuPool::new(1),
+            index,
+            segment_manager,
+            merge_policy: RwLock::new(box DefaultMergePolicy::default()),
+            merging_thread_id: AtomicUsize::default(),
+            merging_threads: RwLock::new(HashMap::new()),
+            generation: AtomicUsize::default(),
+            killed: AtomicBool::new(false),
+            stamper,
+        })))
     }
 
     pub fn new_segment(&self) -> Segment {
@@ -199,23 +197,21 @@ impl SegmentUpdater {
         self.0.merging_thread_id.fetch_add(1, Ordering::SeqCst)
     }
 
-    fn run_async<T: 'static + Send, F: 'static + Send + FnOnce(SegmentUpdater) -> T>
-        (&self,
-         f: F)
-         -> CpuFuture<T, Error> {
+    fn run_async<T: 'static + Send, F: 'static + Send + FnOnce(SegmentUpdater) -> T>(
+        &self,
+        f: F,
+    ) -> CpuFuture<T, Error> {
         let me_clone = self.clone();
         self.0.pool.spawn_fn(move || Ok(f(me_clone)))
     }
 
-
     pub fn add_segment(&self, generation: usize, segment_entry: SegmentEntry) -> bool {
         if generation >= self.0.generation.load(Ordering::Acquire) {
             self.run_async(|segment_updater| {
-                               segment_updater.0.segment_manager.add_segment(segment_entry);
-                               segment_updater.consider_merge_options();
-                               true
-                           })
-                .forget();
+                segment_updater.0.segment_manager.add_segment(segment_entry);
+                segment_updater.consider_merge_options();
+                true
+            }).forget();
             true
         } else {
             false
@@ -230,7 +226,6 @@ impl SegmentUpdater {
         !self.0.killed.load(Ordering::Acquire)
     }
 
-
     /// Apply deletes up to the target opstamp to all segments.
     ///
     /// Tne method returns copies of the segment entries,
@@ -242,53 +237,53 @@ impl SegmentUpdater {
             advance_deletes(segment, segment_entry, target_opstamp)?;
         }
         Ok(segment_entries)
-
     }
 
     pub fn save_metas(&self, opstamp: u64) {
         if self.is_alive() {
             let index = &self.0.index;
             let directory = index.directory();
-            save_metas(self.0.segment_manager.committed_segment_metas(),
-                       index.schema(),
-                       opstamp,
-                       directory.box_clone().borrow_mut())
-                    .expect("Could not save metas.");
+            save_metas(
+                self.0.segment_manager.committed_segment_metas(),
+                index.schema(),
+                opstamp,
+                directory.box_clone().borrow_mut(),
+            ).expect("Could not save metas.");
         }
     }
 
     pub fn garbage_collect_files(&self) -> Result<()> {
         self.run_async(move |segment_updater| {
             segment_updater.garbage_collect_files_exec();
-        })
-        .wait()
+        }).wait()
     }
 
     fn garbage_collect_files_exec(&self) {
         info!("Running garbage collection");
-        let living_files = self.0.segment_manager.list_files();
         let mut index = self.0.index.clone();
-        index.directory_mut().garbage_collect(living_files);
+        index
+            .directory_mut()
+            .garbage_collect(|| self.0.segment_manager.list_files());
     }
 
     pub fn commit(&self, opstamp: u64) -> Result<()> {
-        self.run_async(move |segment_updater| if segment_updater.is_alive() {
-                       let segment_entries = segment_updater
-                           .purge_deletes(opstamp)
-                           .expect("Failed purge deletes");
-                       segment_updater.0.segment_manager.commit(segment_entries);
-                       segment_updater.save_metas(opstamp);
-                       segment_updater.garbage_collect_files_exec();
-                       segment_updater.consider_merge_options();
-                   })
-            .wait()
+        self.run_async(move |segment_updater| {
+            if segment_updater.is_alive() {
+                let segment_entries = segment_updater
+                    .purge_deletes(opstamp)
+                    .expect("Failed purge deletes");
+                segment_updater.0.segment_manager.commit(segment_entries);
+                segment_updater.save_metas(opstamp);
+                segment_updater.garbage_collect_files_exec();
+                segment_updater.consider_merge_options();
+            }
+        }).wait()
     }
 
-
-    pub fn start_merge(&self,
-                       segment_ids: &[SegmentId])
-                       -> impl Future<Item = SegmentMeta, Error = Canceled> {
-
+    pub fn start_merge(
+        &self,
+        segment_ids: &[SegmentId],
+    ) -> impl Future<Item = SegmentMeta, Error = Canceled> {
         self.0.segment_manager.start_merge(segment_ids);
         let segment_updater_clone = self.clone();
 
@@ -303,14 +298,15 @@ impl SegmentUpdater {
 
         let target_opstamp = self.0.stamper.stamp();
         let merging_join_handle = thread::spawn(move || {
-
             // first we need to apply deletes to our segment.
             let merged_segment = segment_updater_clone.new_segment();
             let merged_segment_id = merged_segment.id();
-            let merge_result = perform_merge(&segment_ids_vec,
-                                             &segment_updater_clone,
-                                             merged_segment,
-                                             target_opstamp);
+            let merge_result = perform_merge(
+                &segment_ids_vec,
+                &segment_updater_clone,
+                merged_segment,
+                target_opstamp,
+            );
 
             match merge_result {
                 Ok(after_merge_segment_entry) => {
@@ -352,7 +348,6 @@ impl SegmentUpdater {
         merging_future_recv
     }
 
-
     fn consider_merge_options(&self) {
         let (committed_segments, uncommitted_segments) =
             get_mergeable_segments(&self.0.segment_manager);
@@ -367,20 +362,21 @@ impl SegmentUpdater {
         }
     }
 
-    fn cancel_merge(&self,
-                    before_merge_segment_ids: &[SegmentId],
-                    after_merge_segment_entry: SegmentId) {
+    fn cancel_merge(
+        &self,
+        before_merge_segment_ids: &[SegmentId],
+        after_merge_segment_entry: SegmentId,
+    ) {
         self.0
             .segment_manager
             .cancel_merge(before_merge_segment_ids, after_merge_segment_entry);
     }
 
-
-    fn end_merge(&self,
-                 before_merge_segment_ids: Vec<SegmentId>,
-                 mut after_merge_segment_entry: SegmentEntry)
-                 -> Result<()> {
-
+    fn end_merge(
+        &self,
+        before_merge_segment_ids: Vec<SegmentId>,
+        mut after_merge_segment_entry: SegmentEntry,
+    ) -> Result<()> {
         self.run_async(move |segment_updater| {
             info!("End merge {:?}", after_merge_segment_entry.meta());
             let mut delete_cursor = after_merge_segment_entry.delete_cursor().clone();
@@ -390,28 +386,36 @@ impl SegmentUpdater {
                 if delete_operation.opstamp < committed_opstamp {
                     let index = &segment_updater.0.index;
                     let segment = index.segment(after_merge_segment_entry.meta().clone());
-                    match advance_deletes(segment,
-                                          &mut after_merge_segment_entry,
-                                          committed_opstamp) {
+                    match advance_deletes(
+                        segment,
+                        &mut after_merge_segment_entry,
+                        committed_opstamp,
+                    ) {
                         Ok(file_protection_opt_res) => {
                             _file_protection_opt = file_protection_opt_res;
                         }
                         Err(e) => {
-                            error!("Merge of {:?} was cancelled (advancing deletes failed): {:?}",
-                                   before_merge_segment_ids, e);
+                            error!(
+                                "Merge of {:?} was cancelled (advancing deletes failed): {:?}",
+                                before_merge_segment_ids, e
+                            );
                             // ... cancel merge
                             if cfg!(test) {
                                 panic!("Merge failed.");
                             }
-                            segment_updater.cancel_merge(&before_merge_segment_ids,
-                                                         after_merge_segment_entry.segment_id());
+                            segment_updater.cancel_merge(
+                                &before_merge_segment_ids,
+                                after_merge_segment_entry.segment_id(),
+                            );
                             return;
                         }
                     }
                 }
             }
-            segment_updater.0.segment_manager.end_merge(&before_merge_segment_ids,
-                                                        after_merge_segment_entry);
+            segment_updater
+                .0
+                .segment_manager
+                .end_merge(&before_merge_segment_ids, after_merge_segment_entry);
             segment_updater.consider_merge_options();
             info!("save metas");
             segment_updater.save_metas(segment_updater.0.index.opstamp());
@@ -419,7 +423,6 @@ impl SegmentUpdater {
         }).wait()
     }
 
-
     /// Wait for current merging threads.
     ///
     /// Upon termination of the current merging threads,
@@ -436,10 +439,8 @@ impl SegmentUpdater {
     /// Obsolete files will eventually be cleaned up
     /// by the directory garbage collector.
     pub fn wait_merging_thread(&self) -> Result<()> {
-
         let mut num_segments: usize;
         loop {
-
             num_segments = self.0.segment_manager.num_segments();
 
             let mut new_merging_threads = HashMap::new();
@@ -467,9 +468,6 @@ impl SegmentUpdater {
     }
 }
 
-
-
-
 #[cfg(test)]
 mod tests {
 

src/indexer/segment_writer.rs

@@ -14,7 +14,8 @@ use datastruct::stacker::Heap;
 use indexer::index_writer::MARGIN_IN_BYTES;
 use super::operation::AddOperation;
 use postings::MultiFieldPostingsWriter;
-
+use tokenizer::BoxedTokenizer;
+use schema::Value;
 
 /// A `SegmentWriter` is in charge of creating segment index from a
 /// documents.
@@ -29,9 +30,9 @@ pub struct SegmentWriter<'a> {
     fast_field_writers: FastFieldsWriter,
     fieldnorms_writer: FastFieldsWriter,
     doc_opstamps: Vec<u64>,
+    tokenizers: Vec<Option<Box<BoxedTokenizer>>>,
 }
 
-
 fn create_fieldnorms_writer(schema: &Schema) -> FastFieldsWriter {
     let u64_fields: Vec<Field> = schema
         .fields()
@@ -43,7 +44,6 @@ fn create_fieldnorms_writer(schema: &Schema) -> FastFieldsWriter {
     FastFieldsWriter::new(u64_fields)
 }
 
-
 impl<'a> SegmentWriter<'a> {
     /// Creates a new `SegmentWriter`
     ///
@@ -54,22 +54,38 @@ impl<'a> SegmentWriter<'a> {
     /// the flushing behavior as a buffer limit
     /// - segment: The segment being written
     /// - schema
-    pub fn for_segment(heap: &'a Heap,
-                       table_bits: usize,
-                       mut segment: Segment,
-                       schema: &Schema)
-                       -> Result<SegmentWriter<'a>> {
+    pub fn for_segment(
+        heap: &'a Heap,
+        table_bits: usize,
+        mut segment: Segment,
+        schema: &Schema,
+    ) -> Result<SegmentWriter<'a>> {
         let segment_serializer = SegmentSerializer::for_segment(&mut segment)?;
         let multifield_postings = MultiFieldPostingsWriter::new(schema, table_bits, heap);
+        let tokenizers = schema
+            .fields()
+            .iter()
+            .map(|field_entry| field_entry.field_type())
+            .map(|field_type| match *field_type {
+                FieldType::Str(ref text_options) => text_options.get_indexing_options().and_then(
+                    |text_index_option| {
+                        let tokenizer_name = &text_index_option.tokenizer();
+                        segment.index().tokenizers().get(tokenizer_name)
+                    },
+                ),
+                _ => None,
+            })
+            .collect();
         Ok(SegmentWriter {
-               heap: heap,
-               max_doc: 0,
-               multifield_postings: multifield_postings,
-               fieldnorms_writer: create_fieldnorms_writer(schema),
-               segment_serializer: segment_serializer,
-               fast_field_writers: FastFieldsWriter::from_schema(schema),
-               doc_opstamps: Vec::with_capacity(1_000),
-           })
+            heap,
+            max_doc: 0,
+            multifield_postings,
+            fieldnorms_writer: create_fieldnorms_writer(schema),
+            segment_serializer,
+            fast_field_writers: FastFieldsWriter::from_schema(schema),
+            doc_opstamps: Vec::with_capacity(1_000),
+            tokenizers,
+        })
     }
 
     /// Lay on disk the current content of the `SegmentWriter`
@@ -77,10 +93,12 @@ impl<'a> SegmentWriter<'a> {
     /// Finalize consumes the `SegmentWriter`, so that it cannot
     /// be used afterwards.
     pub fn finalize(self) -> Result<Vec<u64>> {
-        write(&self.multifield_postings,
-              &self.fast_field_writers,
-              &self.fieldnorms_writer,
-              self.segment_serializer)?;
+        write(
+            &self.multifield_postings,
+            &self.fast_field_writers,
+            &self.fieldnorms_writer,
+            self.segment_serializer,
+        )?;
         Ok(self.doc_opstamps)
     }
 
@@ -95,7 +113,6 @@ impl<'a> SegmentWriter<'a> {
         self.heap.num_free_bytes() <= MARGIN_IN_BYTES
     }
 
-
     /// Return true if the term dictionary hashmap is reaching capacity.
     /// It is one of the condition that triggers a `SegmentWriter` to
     /// be finalized.
@@ -103,51 +120,64 @@ impl<'a> SegmentWriter<'a> {
         self.multifield_postings.is_term_saturated()
     }
 
-
     /// Indexes a new document
     ///
     /// As a user, you should rather use `IndexWriter`'s add_document.
-    pub fn add_document(&mut self,
-                        add_operation: &AddOperation,
-                        schema: &Schema)
-                        -> io::Result<()> {
+    pub fn add_document(
+        &mut self,
+        add_operation: &AddOperation,
+        schema: &Schema,
+    ) -> io::Result<()> {
         let doc_id = self.max_doc;
         let doc = &add_operation.document;
         self.doc_opstamps.push(add_operation.opstamp);
         for (field, field_values) in doc.get_sorted_field_values() {
             let field_options = schema.get_field_entry(field);
+            if !field_options.is_indexed() {
+                continue;
+            }
             match *field_options.field_type() {
-                FieldType::Str(ref text_options) => {
-                    let num_tokens: u32 = if text_options.get_indexing_options().is_tokenized() {
-                        self.multifield_postings
-                            .index_text(doc_id, field, &field_values)
-                    } else {
-                        let num_field_values = field_values.len() as u32;
-                        for field_value in field_values {
-                            let term = Term::from_field_text(field, field_value.value().text());
-                            self.multifield_postings.suscribe(doc_id, &term);
-                        }
-                        num_field_values
-                    };
+                FieldType::Str(_) => {
+                    let num_tokens =
+                        if let Some(ref mut tokenizer) = self.tokenizers[field.0 as usize] {
+                            let texts: Vec<&str> = field_values
+                                .iter()
+                                .flat_map(|field_value| match *field_value.value() {
+                                    Value::Str(ref text) => Some(text.as_str()),
+                                    _ => None,
+                                })
+                                .collect();
+                            let mut token_stream = tokenizer.token_stream_texts(&texts[..]);
+                            self.multifield_postings
+                                .index_text(doc_id, field, &mut token_stream)
+                        } else {
+                            0
+                        };
                     self.fieldnorms_writer
                         .get_field_writer(field)
-                        .map(|field_norms_writer| field_norms_writer.add_val(num_tokens as u64));
+                        .map(|field_norms_writer| {
+                            field_norms_writer.add_val(u64::from(num_tokens))
+                        });
                 }
                 FieldType::U64(ref int_option) => {
                     if int_option.is_indexed() {
                         for field_value in field_values {
-                            let term = Term::from_field_u64(field_value.field(),
-                                                            field_value.value().u64_value());
-                            self.multifield_postings.suscribe(doc_id, &term);
+                            let term = Term::from_field_u64(
+                                field_value.field(),
+                                field_value.value().u64_value(),
+                            );
+                            self.multifield_postings.subscribe(doc_id, &term);
                         }
                     }
                 }
                 FieldType::I64(ref int_option) => {
                     if int_option.is_indexed() {
                         for field_value in field_values {
-                            let term = Term::from_field_i64(field_value.field(),
-                                                            field_value.value().i64_value());
-                            self.multifield_postings.suscribe(doc_id, &term);
+                            let term = Term::from_field_i64(
+                                field_value.field(),
+                                field_value.value().i64_value(),
+                            );
+                            self.multifield_postings.subscribe(doc_id, &term);
                         }
                     }
                 }
@@ -160,12 +190,11 @@ impl<'a> SegmentWriter<'a> {
             .filter(|field_value| schema.get_field_entry(field_value.field()).is_stored())
             .collect();
         let doc_writer = self.segment_serializer.get_store_writer();
-        try!(doc_writer.store(&stored_fieldvalues));
+        doc_writer.store(&stored_fieldvalues)?;
         self.max_doc += 1;
         Ok(())
     }
 
-
     /// Max doc is
     /// - the number of documents in the segment assuming there is no deletes
     /// - the maximum document id (including deleted documents) + 1
@@ -188,16 +217,16 @@ impl<'a> SegmentWriter<'a> {
 }
 
 // This method is used as a trick to workaround the borrow checker
-fn write(multifield_postings: &MultiFieldPostingsWriter,
-         fast_field_writers: &FastFieldsWriter,
-         fieldnorms_writer: &FastFieldsWriter,
-         mut serializer: SegmentSerializer)
-         -> Result<()> {
-
-    try!(multifield_postings.serialize(serializer.get_postings_serializer()));
-    try!(fast_field_writers.serialize(serializer.get_fast_field_serializer()));
-    try!(fieldnorms_writer.serialize(serializer.get_fieldnorms_serializer()));
-    try!(serializer.close());
+fn write(
+    multifield_postings: &MultiFieldPostingsWriter,
+    fast_field_writers: &FastFieldsWriter,
+    fieldnorms_writer: &FastFieldsWriter,
+    mut serializer: SegmentSerializer,
+) -> Result<()> {
+    multifield_postings.serialize(serializer.get_postings_serializer())?;
+    fast_field_writers.serialize(serializer.get_fast_field_serializer())?;
+    fieldnorms_writer.serialize(serializer.get_fieldnorms_serializer())?;
+    serializer.close()?;
 
     Ok(())
 }
@@ -205,10 +234,12 @@ fn write(multifield_postings: &MultiFieldPostingsWriter,
 impl<'a> SerializableSegment for SegmentWriter<'a> {
     fn write(&self, serializer: SegmentSerializer) -> Result<u32> {
         let max_doc = self.max_doc;
-        write(&self.multifield_postings,
-              &self.fast_field_writers,
-              &self.fieldnorms_writer,
-              serializer)?;
+        write(
+            &self.multifield_postings,
+            &self.fast_field_writers,
+            &self.fieldnorms_writer,
+            serializer,
+        )?;
         Ok(max_doc)
     }
 }

src/indexer/stamper.rs

@@ -1,7 +1,6 @@
 use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::Arc;
 
-
 #[derive(Clone, Default)]
 pub struct Stamper(Arc<AtomicU64>);
 

src/lib.rs

@@ -1,20 +1,15 @@
 #![doc(html_logo_url = "http://fulmicoton.com/tantivy-logo/tantivy-logo.png")]
 #![cfg_attr(feature = "cargo-clippy", allow(module_inception))]
 #![cfg_attr(feature = "cargo-clippy", allow(inline_always))]
-
 #![feature(box_syntax)]
 #![feature(optin_builtin_traits)]
 #![feature(conservative_impl_trait)]
 #![feature(integer_atomics)]
-
 #![cfg_attr(test, feature(test))]
 #![cfg_attr(test, feature(iterator_step_by))]
-
-
 #![doc(test(attr(allow(unused_variables), deny(warnings))))]
-
 #![allow(unknown_lints)]
-
+#![allow(new_without_default)]
 #![warn(missing_docs)]
 
 //! # `tantivy`
@@ -39,53 +34,50 @@ extern crate log;
 #[macro_use]
 extern crate error_chain;
 
-#[macro_use]
-extern crate version;
-extern crate fst;
-extern crate byteorder;
-extern crate memmap;
-extern crate regex;
-extern crate tempfile;
 extern crate atomicwrites;
-extern crate tempdir;
-extern crate serde;
-extern crate bincode;
-extern crate serde_json;
-extern crate time;
-extern crate lz4;
-extern crate uuid;
-extern crate num_cpus;
-extern crate combine;
-extern crate itertools;
-extern crate chan;
-extern crate crossbeam;
 extern crate bit_set;
+extern crate byteorder;
+extern crate chan;
+extern crate combine;
+extern crate crossbeam;
+extern crate fst;
 extern crate futures;
 extern crate futures_cpupool;
+extern crate itertools;
+extern crate lz4;
+extern crate memmap;
+extern crate num_cpus;
 extern crate owning_ref;
+extern crate regex;
+extern crate rust_stemmers;
+extern crate serde;
+extern crate serde_json;
 extern crate stable_deref_trait;
+extern crate tempdir;
+extern crate time;
+extern crate uuid;
+#[macro_use]
+extern crate version;
 
 #[cfg(test)]
 extern crate env_logger;
 
-#[cfg(feature="simdcompression")]
+#[cfg(feature = "simdcompression")]
 extern crate libc;
 
 #[cfg(windows)]
 extern crate winapi;
 
-#[cfg(test)]
-extern crate test;
 #[cfg(test)]
 extern crate rand;
+#[cfg(test)]
+extern crate test;
 
+extern crate tinysegmenter;
 
 #[cfg(test)]
 mod functional_test;
 
-
-
-
 #[macro_use]
 mod macros;
 
@@ -98,43 +90,31 @@ mod core;
 mod compression;
 mod indexer;
 mod common;
+
+#[allow(unused_doc_comment)]
 mod error;
-mod analyzer;
+pub mod tokenizer;
 mod datastruct;
 
 pub mod termdict;
-
-/// Row-oriented, slow, compressed storage of documents
 pub mod store;
-
-/// Query module
 pub mod query;
-
 pub mod directory;
-
-/// Collector module
 pub mod collector;
-
-/// Postings module (also called inverted index)
 pub mod postings;
-
-/// Schema
 pub mod schema;
-
 pub mod fastfield;
 
-
 pub use directory::Directory;
-pub use core::{Index, Segment, SegmentId, SegmentMeta, Searcher};
+pub use core::{Index, Searcher, Segment, SegmentId, SegmentMeta};
 pub use indexer::IndexWriter;
-pub use schema::{Term, Document};
-pub use core::SegmentReader;
+pub use schema::{Document, Term};
+pub use core::{InvertedIndexReader, SegmentReader};
 pub use self::common::TimerTree;
 
 pub use postings::DocSet;
 pub use postings::Postings;
 pub use core::SegmentComponent;
-pub use postings::SegmentPostingsOption;
 
 pub use common::{i64_to_u64, u64_to_i64};
 
@@ -156,15 +136,19 @@ pub mod merge_policy {
     pub use indexer::DefaultMergePolicy;
 }
 
-/// u32 identifying a document within a segment.
-/// Documents have their doc id assigned incrementally,
+/// A `u32` identifying a document within a segment.
+/// Documents have their `DocId` assigned incrementally,
 /// as they are added in the segment.
 pub type DocId = u32;
 
-/// f32 the score of a document.
+/// A f32 that represents the relevance of the document to the query
+///
+/// This is modelled internally as a `f32`. The
+/// larger the number, the more relevant the document
+/// to the search
 pub type Score = f32;
 
-/// A segment local id identifies a segment.
+/// A `SegmentLocalId` identifies a segment.
 /// It only makes sense for a given searcher.
 pub type SegmentLocalId = u32;
 
@@ -183,7 +167,6 @@ impl DocAddress {
     }
 }
 
-
 /// `DocAddress` contains all the necessary information
 /// to identify a document given a `Searcher` object.
 ///
@@ -195,7 +178,6 @@ impl DocAddress {
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 pub struct DocAddress(pub SegmentLocalId, pub DocId);
 
-
 #[cfg(test)]
 mod tests {
 
@@ -203,14 +185,13 @@ mod tests {
     use Index;
     use core::SegmentReader;
     use query::BooleanQuery;
-    use postings::SegmentPostingsOption;
+    use schema::IndexRecordOption;
     use schema::*;
     use DocSet;
     use IndexWriter;
-    use postings::SegmentPostingsOption::FreqAndPositions;
-    use fastfield::{FastFieldReader, U64FastFieldReader, I64FastFieldReader};
+    use fastfield::{FastFieldReader, I64FastFieldReader, U64FastFieldReader};
     use Postings;
-    use rand::{XorShiftRng, Rng, SeedableRng};
+    use rand::{Rng, SeedableRng, XorShiftRng};
 
     fn generate_array_with_seed(n: usize, ratio: f32, seed_val: u32) -> Vec<u32> {
         let seed: &[u32; 4] = &[1, 2, 3, seed_val];
@@ -258,11 +239,10 @@ mod tests {
             }
             assert!(index_writer.commit().is_ok());
         }
-
     }
 
     #[test]
-    fn test_docfreq() {
+    fn test_docfreq1() {
         let mut schema_builder = SchemaBuilder::default();
         let text_field = schema_builder.add_text_field("text", TEXT);
         let index = Index::create_in_ram(schema_builder.build());
@@ -301,7 +281,6 @@ mod tests {
         }
     }
 
-
     #[test]
     fn test_fieldnorm() {
         let mut schema_builder = SchemaBuilder::default();
@@ -334,7 +313,6 @@ mod tests {
         }
     }
 
-
     #[test]
     fn test_delete_postings1() {
         let mut schema_builder = SchemaBuilder::default();
@@ -390,15 +368,24 @@ mod tests {
             index.load_searchers().unwrap();
             let searcher = index.searcher();
             let reader = searcher.segment_reader(0);
-            assert!(reader.read_postings(&term_abcd, FreqAndPositions).is_none());
+            let inverted_index = reader.inverted_index(text_field);
+            assert!(
+                inverted_index
+                    .read_postings(&term_abcd, IndexRecordOption::WithFreqsAndPositions)
+                    .is_none()
+            );
             {
-                let mut postings = reader.read_postings(&term_a, FreqAndPositions).unwrap();
+                let mut postings = inverted_index
+                    .read_postings(&term_a, IndexRecordOption::WithFreqsAndPositions)
+                    .unwrap();
                 assert!(postings.advance());
                 assert_eq!(postings.doc(), 5);
                 assert!(!postings.advance());
             }
             {
-                let mut postings = reader.read_postings(&term_b, FreqAndPositions).unwrap();
+                let mut postings = inverted_index
+                    .read_postings(&term_b, IndexRecordOption::WithFreqsAndPositions)
+                    .unwrap();
                 assert!(postings.advance());
                 assert_eq!(postings.doc(), 3);
                 assert!(postings.advance());
@@ -424,16 +411,25 @@ mod tests {
             index.load_searchers().unwrap();
             let searcher = index.searcher();
             let reader = searcher.segment_reader(0);
+            let inverted_index = reader.inverted_index(term_abcd.field());
 
-            assert!(reader.read_postings(&term_abcd, FreqAndPositions).is_none());
+            assert!(
+                inverted_index
+                    .read_postings(&term_abcd, IndexRecordOption::WithFreqsAndPositions)
+                    .is_none()
+            );
             {
-                let mut postings = reader.read_postings(&term_a, FreqAndPositions).unwrap();
+                let mut postings = inverted_index
+                    .read_postings(&term_a, IndexRecordOption::WithFreqsAndPositions)
+                    .unwrap();
                 assert!(postings.advance());
                 assert_eq!(postings.doc(), 5);
                 assert!(!postings.advance());
             }
             {
-                let mut postings = reader.read_postings(&term_b, FreqAndPositions).unwrap();
+                let mut postings = inverted_index
+                    .read_postings(&term_b, IndexRecordOption::WithFreqsAndPositions)
+                    .unwrap();
                 assert!(postings.advance());
                 assert_eq!(postings.doc(), 3);
                 assert!(postings.advance());
@@ -459,13 +455,22 @@ mod tests {
             index.load_searchers().unwrap();
             let searcher = index.searcher();
             let reader = searcher.segment_reader(0);
-            assert!(reader.read_postings(&term_abcd, FreqAndPositions).is_none());
+            let inverted_index = reader.inverted_index(term_abcd.field());
+            assert!(
+                inverted_index
+                    .read_postings(&term_abcd, IndexRecordOption::WithFreqsAndPositions)
+                    .is_none()
+            );
             {
-                let mut postings = reader.read_postings(&term_a, FreqAndPositions).unwrap();
+                let mut postings = inverted_index
+                    .read_postings(&term_a, IndexRecordOption::WithFreqsAndPositions)
+                    .unwrap();
                 assert!(!postings.advance());
             }
             {
-                let mut postings = reader.read_postings(&term_b, FreqAndPositions).unwrap();
+                let mut postings = inverted_index
+                    .read_postings(&term_b, IndexRecordOption::WithFreqsAndPositions)
+                    .unwrap();
                 assert!(postings.advance());
                 assert_eq!(postings.doc(), 3);
                 assert!(postings.advance());
@@ -473,7 +478,9 @@ mod tests {
                 assert!(!postings.advance());
             }
             {
-                let mut postings = reader.read_postings(&term_c, FreqAndPositions).unwrap();
+                let mut postings = inverted_index
+                    .read_postings(&term_c, IndexRecordOption::WithFreqsAndPositions)
+                    .unwrap();
                 assert!(postings.advance());
                 assert_eq!(postings.doc(), 4);
                 assert!(!postings.advance());
@@ -481,7 +488,6 @@ mod tests {
         }
     }
 
-
     #[test]
     fn test_indexed_u64() {
         let mut schema_builder = SchemaBuilder::default();
@@ -497,7 +503,8 @@ mod tests {
         let term = Term::from_field_u64(field, 1u64);
         let mut postings = searcher
             .segment_reader(0)
-            .read_postings(&term, SegmentPostingsOption::NoFreq)
+            .inverted_index(term.field())
+            .read_postings(&term, IndexRecordOption::Basic)
             .unwrap();
         assert!(postings.advance());
         assert_eq!(postings.doc(), 0);
@@ -520,7 +527,8 @@ mod tests {
         let term = Term::from_field_i64(value_field, negative_val);
         let mut postings = searcher
             .segment_reader(0)
-            .read_postings(&term, SegmentPostingsOption::NoFreq)
+            .inverted_index(term.field())
+            .read_postings(&term, IndexRecordOption::Basic)
             .unwrap();
         assert!(postings.advance());
         assert_eq!(postings.doc(), 0);
@@ -582,10 +590,17 @@ mod tests {
             index.load_searchers().unwrap();
             let searcher = index.searcher();
             let reader = searcher.segment_reader(0);
+            let inverted_index = reader.inverted_index(text_field);
             let term_abcd = Term::from_field_text(text_field, "abcd");
-            assert!(reader.read_postings(&term_abcd, FreqAndPositions).is_none());
+            assert!(
+                inverted_index
+                    .read_postings(&term_abcd, IndexRecordOption::WithFreqsAndPositions)
+                    .is_none()
+            );
             let term_af = Term::from_field_text(text_field, "af");
-            let mut postings = reader.read_postings(&term_af, FreqAndPositions).unwrap();
+            let mut postings = inverted_index
+                .read_postings(&term_af, IndexRecordOption::WithFreqsAndPositions)
+                .unwrap();
             assert!(postings.advance());
             assert_eq!(postings.doc(), 0);
             assert_eq!(postings.term_freq(), 3);
@@ -627,29 +642,43 @@ mod tests {
                 collector.docs()
             };
             {
-                assert_eq!(get_doc_ids(vec![Term::from_field_text(text_field, "a")]),
-                           vec![1, 2]);
+                assert_eq!(
+                    get_doc_ids(vec![Term::from_field_text(text_field, "a")]),
+                    vec![1, 2]
+                );
             }
             {
-                assert_eq!(get_doc_ids(vec![Term::from_field_text(text_field, "af")]),
-                           vec![0]);
+                assert_eq!(
+                    get_doc_ids(vec![Term::from_field_text(text_field, "af")]),
+                    vec![0]
+                );
             }
             {
-                assert_eq!(get_doc_ids(vec![Term::from_field_text(text_field, "b")]),
-                           vec![0, 1, 2]);
+                assert_eq!(
+                    get_doc_ids(vec![Term::from_field_text(text_field, "b")]),
+                    vec![0, 1, 2]
+                );
             }
             {
-                assert_eq!(get_doc_ids(vec![Term::from_field_text(text_field, "c")]),
-                           vec![1, 2]);
+                assert_eq!(
+                    get_doc_ids(vec![Term::from_field_text(text_field, "c")]),
+                    vec![1, 2]
+                );
             }
             {
-                assert_eq!(get_doc_ids(vec![Term::from_field_text(text_field, "d")]),
-                           vec![2]);
+                assert_eq!(
+                    get_doc_ids(vec![Term::from_field_text(text_field, "d")]),
+                    vec![2]
+                );
             }
             {
-                assert_eq!(get_doc_ids(vec![Term::from_field_text(text_field, "b"),
-                                            Term::from_field_text(text_field, "a")]),
-                           vec![0, 1, 2]);
+                assert_eq!(
+                    get_doc_ids(vec![
+                        Term::from_field_text(text_field, "b"),
+                        Term::from_field_text(text_field, "a"),
+                    ]),
+                    vec![0, 1, 2]
+                );
             }
         }
     }
@@ -749,6 +778,5 @@ mod tests {
             let fast_field_reader = fast_field_reader_res.unwrap();
             assert_eq!(fast_field_reader.get(0), 4i64)
         }
-
     }
 }

src/macros.rs

@@ -1,9 +1,7 @@
-
 macro_rules! get(
     ($e:expr) => (match $e { Some(e) => e, None => return None })
 );
 
-
 /// `doc!` is a shortcut that helps building `Document`
 /// objects.
 ///

src/postings/docset.rs

@@ -3,7 +3,6 @@ use std::borrow::Borrow;
 use std::borrow::BorrowMut;
 use std::cmp::Ordering;
 
-
 /// Expresses the outcome of a call to `DocSet`'s `.skip_next(...)`.
 #[derive(PartialEq, Eq, Debug)]
 pub enum SkipResult {
@@ -16,7 +15,6 @@ pub enum SkipResult {
     End,
 }
 
-
 /// Represents an iterable set of sorted doc ids.
 pub trait DocSet {
     /// Goes to the next element.
@@ -52,6 +50,32 @@ pub trait DocSet {
         }
     }
 
+    /// Fills a given mutable buffer with the next doc ids from the
+    /// `DocSet`
+    ///
+    /// If that many `DocId`s are available, the method should
+    /// fill the entire buffer and return the length of the buffer.
+    ///
+    /// If we reach the end of the `DocSet` before filling
+    /// it entirely, then the buffer is filled up to this point, and
+    /// return value is the number of elements that were filled.
+    ///
+    /// # Warning
+    ///
+    /// This method is only here for specific high-performance
+    /// use case where batching. The normal way to
+    /// go through the `DocId`'s is to call `.advance()`.
+    fn fill_buffer(&mut self, buffer: &mut [DocId]) -> usize {
+        for (i, buffer_val) in buffer.iter_mut().enumerate() {
+            if self.advance() {
+                *buffer_val = self.doc();
+            } else {
+                return i;
+            }
+        }
+        buffer.len()
+    }
+
     /// Returns the current document
     fn doc(&self) -> DocId;
 
@@ -71,7 +95,6 @@ pub trait DocSet {
     fn size_hint(&self) -> usize;
 }
 
-
 impl<TDocSet: DocSet + ?Sized> DocSet for Box<TDocSet> {
     fn advance(&mut self) -> bool {
         let unboxed: &mut TDocSet = self.borrow_mut();

src/postings/freq_handler.rs

@@ -1,125 +0,0 @@
-use compression::BlockDecoder;
-use common::VInt;
-use common::BinarySerializable;
-use compression::{CompositeDecoder, VIntDecoder};
-use postings::SegmentPostingsOption;
-use compression::NUM_DOCS_PER_BLOCK;
-
-
-/// `FreqHandler`  is in charge of decompressing
-/// frequencies and/or positions.
-pub struct FreqHandler {
-    freq_decoder: BlockDecoder,
-    positions: Vec<u32>,
-    option: SegmentPostingsOption,
-    positions_offsets: [usize; NUM_DOCS_PER_BLOCK + 1],
-}
-
-
-fn read_positions(data: &[u8]) -> Vec<u32> {
-    let mut composite_reader = CompositeDecoder::new();
-    let mut readable: &[u8] = data;
-    let uncompressed_len = VInt::deserialize(&mut readable).unwrap().0 as usize;
-    composite_reader.uncompress_unsorted(readable, uncompressed_len);
-    composite_reader.into()
-}
-
-
-
-impl FreqHandler {
-    /// Returns a `FreqHandler` that just decodes `DocId`s.
-    pub fn new_without_freq() -> FreqHandler {
-        FreqHandler {
-            freq_decoder: BlockDecoder::with_val(1u32),
-            positions: Vec::new(),
-            option: SegmentPostingsOption::NoFreq,
-            positions_offsets: [0; NUM_DOCS_PER_BLOCK + 1],
-        }
-    }
-
-    /// Returns a `FreqHandler` that decodes `DocId`s and term frequencies.
-    pub fn new_with_freq() -> FreqHandler {
-        FreqHandler {
-            freq_decoder: BlockDecoder::new(),
-            positions: Vec::new(),
-            option: SegmentPostingsOption::Freq,
-            positions_offsets: [0; NUM_DOCS_PER_BLOCK + 1],
-        }
-    }
-
-    /// Returns a `FreqHandler` that decodes `DocId`s, term frequencies, and term positions.
-    pub fn new_with_freq_and_position(position_data: &[u8]) -> FreqHandler {
-        let positions = read_positions(position_data);
-        FreqHandler {
-            freq_decoder: BlockDecoder::new(),
-            positions: positions,
-            option: SegmentPostingsOption::FreqAndPositions,
-            positions_offsets: [0; NUM_DOCS_PER_BLOCK + 1],
-        }
-    }
-
-    fn fill_positions_offset(&mut self) {
-        let mut cur_position: usize = self.positions_offsets[NUM_DOCS_PER_BLOCK];
-        let mut i: usize = 0;
-        self.positions_offsets[i] = cur_position;
-        let mut last_cur_position = cur_position;
-        for &doc_freq in self.freq_decoder.output_array() {
-            i += 1;
-            let mut cumulated_pos = 0u32;
-            // this next loop decodes delta positions into normal positions.
-            for j in last_cur_position..(last_cur_position + (doc_freq as usize)) {
-                cumulated_pos += self.positions[j];
-                self.positions[j] = cumulated_pos;
-            }
-            cur_position += doc_freq as usize;
-            self.positions_offsets[i] = cur_position;
-            last_cur_position = cur_position;
-        }
-    }
-
-
-    /// Accessor to term frequency
-    ///
-    /// idx is the offset of the current doc in the block.
-    /// It takes value between 0 and 128.
-    pub fn freq(&self, idx: usize) -> u32 {
-        self.freq_decoder.output(idx)
-    }
-
-    /// Accessor to the positions
-    ///
-    /// idx is the offset of the current doc in the block.
-    /// It takes value between 0 and 128.
-    pub fn positions(&self, idx: usize) -> &[u32] {
-        let start = self.positions_offsets[idx];
-        let stop = self.positions_offsets[idx + 1];
-        &self.positions[start..stop]
-    }
-
-    /// Decompresses a complete frequency block
-    pub fn read_freq_block<'a>(&mut self, data: &'a [u8]) -> &'a [u8] {
-        match self.option {
-            SegmentPostingsOption::NoFreq => data,
-            SegmentPostingsOption::Freq => self.freq_decoder.uncompress_block_unsorted(data),
-            SegmentPostingsOption::FreqAndPositions => {
-                let remaining: &'a [u8] = self.freq_decoder.uncompress_block_unsorted(data);
-                self.fill_positions_offset();
-                remaining
-            }
-        }
-    }
-
-    /// Decompresses an incomplete frequency block
-    pub fn read_freq_vint(&mut self, data: &[u8], num_els: usize) {
-        match self.option {
-            SegmentPostingsOption::NoFreq => {}
-            SegmentPostingsOption::Freq => {
-                self.freq_decoder.uncompress_vint_unsorted(data, num_els);
-            }
-            SegmentPostingsOption::FreqAndPositions => {
-                self.freq_decoder.uncompress_vint_unsorted(data, num_els);
-                self.fill_positions_offset();
-            }
-        }
-    }
-}

src/postings/intersection.rs

@@ -14,7 +14,7 @@ impl<TDocSet: DocSet> From<Vec<TDocSet>> for IntersectionDocSet<TDocSet> {
         assert!(docsets.len() >= 2);
         docsets.sort_by_key(|docset| docset.size_hint());
         IntersectionDocSet {
-            docsets: docsets,
+            docsets,
             finished: false,
             doc: 0u32,
         }
@@ -30,7 +30,6 @@ impl<TDocSet: DocSet> IntersectionDocSet<TDocSet> {
     }
 }
 
-
 impl<TDocSet: DocSet> DocSet for IntersectionDocSet<TDocSet> {
     fn size_hint(&self) -> usize {
         self.docsets
@@ -50,7 +49,6 @@ impl<TDocSet: DocSet> DocSet for IntersectionDocSet<TDocSet> {
         let mut candidate_ord = self.docsets.len();
 
         'outer: loop {
-
             for (ord, docset) in self.docsets.iter_mut().enumerate() {
                 if ord != candidate_ord {
                     // `candidate_ord` is already at the
@@ -85,11 +83,10 @@ impl<TDocSet: DocSet> DocSet for IntersectionDocSet<TDocSet> {
     }
 }
 
-
 #[cfg(test)]
 mod tests {
 
-    use postings::{DocSet, VecPostings, IntersectionDocSet};
+    use postings::{DocSet, IntersectionDocSet, VecPostings};
 
     #[test]
     fn test_intersection() {

src/postings/mod.rs

@@ -1,9 +1,12 @@
+/*!
+Postings module (also called inverted index)
+*/
+
 /// Postings module
 ///
 /// Postings, also called inverted lists, is the key datastructure
 /// to full-text search.
 
-
 mod postings;
 mod recorder;
 mod serializer;
@@ -12,37 +15,33 @@ mod term_info;
 mod vec_postings;
 mod segment_postings;
 mod intersection;
-mod freq_handler;
 mod docset;
-mod segment_postings_option;
 
-pub use self::docset::{SkipResult, DocSet};
-use self::recorder::{Recorder, NothingRecorder, TermFrequencyRecorder, TFAndPositionRecorder};
-pub use self::serializer::PostingsSerializer;
+pub use self::docset::{DocSet, SkipResult};
+use self::recorder::{NothingRecorder, Recorder, TFAndPositionRecorder, TermFrequencyRecorder};
+pub use self::serializer::{FieldSerializer, InvertedIndexSerializer};
 pub(crate) use self::postings_writer::MultiFieldPostingsWriter;
+
 pub use self::term_info::TermInfo;
 pub use self::postings::Postings;
 
 #[cfg(test)]
 pub use self::vec_postings::VecPostings;
 
-pub use self::segment_postings::{SegmentPostings, BlockSegmentPostings};
+pub use self::segment_postings::{BlockSegmentPostings, SegmentPostings};
 pub use self::intersection::IntersectionDocSet;
-pub use self::freq_handler::FreqHandler;
-pub use self::segment_postings_option::SegmentPostingsOption;
 pub use common::HasLen;
 
-
 #[cfg(test)]
 mod tests {
 
     use super::*;
-    use schema::{Document, INT_INDEXED, TEXT, STRING, SchemaBuilder, Term};
+    use schema::{Document, SchemaBuilder, Term, INT_INDEXED, STRING, TEXT};
     use core::SegmentComponent;
     use indexer::SegmentWriter;
     use core::SegmentReader;
     use core::Index;
-    use postings::SegmentPostingsOption::FreqAndPositions;
+    use schema::IndexRecordOption;
     use std::iter;
     use datastruct::stacker::Heap;
     use fastfield::FastFieldReader;
@@ -51,7 +50,7 @@ mod tests {
     use test::{self, Bencher};
     use indexer::operation::AddOperation;
     use tests;
-    use rand::{XorShiftRng, Rng, SeedableRng};
+    use rand::{Rng, SeedableRng, XorShiftRng};
 
     #[test]
     pub fn test_position_write() {
@@ -60,21 +59,25 @@ mod tests {
         let schema = schema_builder.build();
         let index = Index::create_in_ram(schema);
         let mut segment = index.new_segment();
-        let mut posting_serializer = PostingsSerializer::open(&mut segment).unwrap();
-        posting_serializer.new_field(text_field);
-        posting_serializer.new_term("abc".as_bytes()).unwrap();
-        for doc_id in 0u32..3u32 {
-            let positions = vec![1, 2, 3, 2];
-            posting_serializer.write_doc(doc_id, 2, &positions).unwrap();
+        let mut posting_serializer = InvertedIndexSerializer::open(&mut segment).unwrap();
+        {
+            let mut field_serializer = posting_serializer.new_field(text_field).unwrap();
+            field_serializer.new_term("abc".as_bytes()).unwrap();
+            for doc_id in 0u32..120u32 {
+                let delta_positions = vec![1, 2, 3, 2];
+                field_serializer
+                    .write_doc(doc_id, 2, &delta_positions)
+                    .unwrap();
+            }
+            field_serializer.close_term().unwrap();
         }
-        posting_serializer.close_term().unwrap();
         posting_serializer.close().unwrap();
         let read = segment.open_read(SegmentComponent::POSITIONS).unwrap();
-        assert!(read.len() <= 16);
+        assert!(read.len() <= 140);
     }
 
     #[test]
-    pub fn test_position_and_fieldnorm() {
+    pub fn test_position_and_fieldnorm1() {
         let mut schema_builder = SchemaBuilder::default();
         let text_field = schema_builder.add_text_field("text", TEXT);
         let schema = schema_builder.build();
@@ -83,8 +86,8 @@ mod tests {
 
         let heap = Heap::with_capacity(10_000_000);
         {
-            let mut segment_writer = SegmentWriter::for_segment(&heap, 18, segment.clone(), &schema)
-                .unwrap();
+            let mut segment_writer =
+                SegmentWriter::for_segment(&heap, 18, segment.clone(), &schema).unwrap();
             {
                 let mut doc = Document::default();
                 // checking that position works if the field has two values
@@ -119,7 +122,7 @@ mod tests {
             segment_writer.finalize().unwrap();
         }
         {
-            let segment_reader = SegmentReader::open(segment).unwrap();
+            let segment_reader = SegmentReader::open(&segment).unwrap();
             {
                 let fieldnorm_reader = segment_reader.get_fieldnorms_reader(text_field).unwrap();
                 assert_eq!(fieldnorm_reader.get(0), 8 + 5);
@@ -130,20 +133,25 @@ mod tests {
             }
             {
                 let term_a = Term::from_field_text(text_field, "abcdef");
-                assert!(segment_reader
-                            .read_postings(&term_a, FreqAndPositions)
-                            .is_none());
+                assert!(
+                    segment_reader
+                        .inverted_index(term_a.field())
+                        .read_postings(&term_a, IndexRecordOption::WithFreqsAndPositions)
+                        .is_none()
+                );
             }
             {
                 let term_a = Term::from_field_text(text_field, "a");
                 let mut postings_a = segment_reader
-                    .read_postings(&term_a, FreqAndPositions)
+                    .inverted_index(term_a.field())
+                    .read_postings(&term_a, IndexRecordOption::WithFreqsAndPositions)
                     .unwrap();
                 assert_eq!(postings_a.len(), 1000);
                 assert!(postings_a.advance());
                 assert_eq!(postings_a.doc(), 0);
                 assert_eq!(postings_a.term_freq(), 6);
                 assert_eq!(postings_a.positions(), [0, 2, 4, 6, 7, 13]);
+                assert_eq!(postings_a.positions(), [0, 2, 4, 6, 7, 13]);
                 assert!(postings_a.advance());
                 assert_eq!(postings_a.doc(), 1u32);
                 assert_eq!(postings_a.term_freq(), 1);
@@ -158,7 +166,8 @@ mod tests {
             {
                 let term_e = Term::from_field_text(text_field, "e");
                 let mut postings_e = segment_reader
-                    .read_postings(&term_e, FreqAndPositions)
+                    .inverted_index(term_e.field())
+                    .read_postings(&term_e, IndexRecordOption::WithFreqsAndPositions)
                     .unwrap();
                 assert_eq!(postings_e.len(), 1000 - 2);
                 for i in 2u32..1000u32 {
@@ -197,11 +206,13 @@ mod tests {
             assert!(index_writer.commit().is_ok());
         }
         index.load_searchers().unwrap();
-        let term_query = TermQuery::new(Term::from_field_text(text_field, "a"),
-                                        SegmentPostingsOption::NoFreq);
+        let term_query = TermQuery::new(
+            Term::from_field_text(text_field, "a"),
+            IndexRecordOption::Basic,
+        );
         let searcher = index.searcher();
         let mut term_weight = term_query.specialized_weight(&*searcher);
-        term_weight.segment_postings_options = SegmentPostingsOption::FreqAndPositions;
+        term_weight.index_record_option = IndexRecordOption::WithFreqsAndPositions;
         let segment_reader = &searcher.segment_readers()[0];
         let mut term_scorer = term_weight.specialized_scorer(segment_reader).unwrap();
         assert!(term_scorer.advance());
@@ -245,7 +256,8 @@ mod tests {
         for i in 0..num_docs - 1 {
             for j in i + 1..num_docs {
                 let mut segment_postings = segment_reader
-                    .read_postings(&term_2, SegmentPostingsOption::NoFreq)
+                    .inverted_index(term_2.field())
+                    .read_postings(&term_2, IndexRecordOption::Basic)
                     .unwrap();
 
                 assert_eq!(segment_postings.skip_next(i), SkipResult::Reached);
@@ -258,7 +270,8 @@ mod tests {
 
         {
             let mut segment_postings = segment_reader
-                .read_postings(&term_2, SegmentPostingsOption::NoFreq)
+                .inverted_index(term_2.field())
+                .read_postings(&term_2, IndexRecordOption::Basic)
                 .unwrap();
 
             // check that `skip_next` advances the iterator
@@ -278,7 +291,8 @@ mod tests {
         // check that filtering works
         {
             let mut segment_postings = segment_reader
-                .read_postings(&term_0, SegmentPostingsOption::NoFreq)
+                .inverted_index(term_0.field())
+                .read_postings(&term_0, IndexRecordOption::Basic)
                 .unwrap();
 
             for i in 0..num_docs / 2 {
@@ -287,7 +301,8 @@ mod tests {
             }
 
             let mut segment_postings = segment_reader
-                .read_postings(&term_0, SegmentPostingsOption::NoFreq)
+                .inverted_index(term_0.field())
+                .read_postings(&term_0, IndexRecordOption::Basic)
                 .unwrap();
 
             for i in 0..num_docs / 2 - 1 {
@@ -311,7 +326,8 @@ mod tests {
         // make sure seeking still works
         for i in 0..num_docs {
             let mut segment_postings = segment_reader
-                .read_postings(&term_2, SegmentPostingsOption::NoFreq)
+                .inverted_index(term_2.field())
+                .read_postings(&term_2, IndexRecordOption::Basic)
                 .unwrap();
 
             if i % 2 == 0 {
@@ -326,7 +342,8 @@ mod tests {
         // now try with a longer sequence
         {
             let mut segment_postings = segment_reader
-                .read_postings(&term_2, SegmentPostingsOption::NoFreq)
+                .inverted_index(term_2.field())
+                .read_postings(&term_2, IndexRecordOption::Basic)
                 .unwrap();
 
             let mut last = 2; // start from 5 to avoid seeking to 3 twice
@@ -361,20 +378,21 @@ mod tests {
         // finally, check that it's empty
         {
             let mut segment_postings = segment_reader
-                .read_postings(&term_2, SegmentPostingsOption::NoFreq)
+                .inverted_index(term_2.field())
+                .read_postings(&term_2, IndexRecordOption::Basic)
                 .unwrap();
 
             assert_eq!(segment_postings.skip_next(0), SkipResult::End);
 
             let mut segment_postings = segment_reader
-                .read_postings(&term_2, SegmentPostingsOption::NoFreq)
+                .inverted_index(term_2.field())
+                .read_postings(&term_2, IndexRecordOption::Basic)
                 .unwrap();
 
             assert_eq!(segment_postings.skip_next(num_docs), SkipResult::End);
         }
     }
 
-
     lazy_static! {
         static ref TERM_A: Term = {
             let field = Field(0);
@@ -433,11 +451,12 @@ mod tests {
         let segment_reader = searcher.segment_reader(0);
 
         b.iter(|| {
-                   let mut segment_postings = segment_reader
-                       .read_postings(&*TERM_A, SegmentPostingsOption::NoFreq)
-                       .unwrap();
-                   while segment_postings.advance() {}
-               });
+            let mut segment_postings = segment_reader
+                .inverted_index(TERM_A.field())
+                .read_postings(&*TERM_A, IndexRecordOption::Basic)
+                .unwrap();
+            while segment_postings.advance() {}
+        });
     }
 
     #[bench]
@@ -446,21 +465,27 @@ mod tests {
         let segment_reader = searcher.segment_reader(0);
         b.iter(|| {
             let segment_postings_a = segment_reader
-                .read_postings(&*TERM_A, SegmentPostingsOption::NoFreq)
+                .inverted_index(TERM_A.field())
+                .read_postings(&*TERM_A, IndexRecordOption::Basic)
                 .unwrap();
             let segment_postings_b = segment_reader
-                .read_postings(&*TERM_B, SegmentPostingsOption::NoFreq)
+                .inverted_index(TERM_B.field())
+                .read_postings(&*TERM_B, IndexRecordOption::Basic)
                 .unwrap();
             let segment_postings_c = segment_reader
-                .read_postings(&*TERM_C, SegmentPostingsOption::NoFreq)
+                .inverted_index(TERM_C.field())
+                .read_postings(&*TERM_C, IndexRecordOption::Basic)
                 .unwrap();
             let segment_postings_d = segment_reader
-                .read_postings(&*TERM_D, SegmentPostingsOption::NoFreq)
+                .inverted_index(TERM_D.field())
+                .read_postings(&*TERM_D, IndexRecordOption::Basic)
                 .unwrap();
-            let mut intersection = IntersectionDocSet::from(vec![segment_postings_a,
-                                                                 segment_postings_b,
-                                                                 segment_postings_c,
-                                                                 segment_postings_d]);
+            let mut intersection = IntersectionDocSet::from(vec![
+                segment_postings_a,
+                segment_postings_b,
+                segment_postings_c,
+                segment_postings_d,
+            ]);
             while intersection.advance() {}
         });
     }
@@ -471,7 +496,8 @@ mod tests {
         let docs = tests::sample(segment_reader.num_docs(), p);
 
         let mut segment_postings = segment_reader
-            .read_postings(&*TERM_A, SegmentPostingsOption::NoFreq)
+            .inverted_index(TERM_A.field())
+            .read_postings(&*TERM_A, IndexRecordOption::Basic)
             .unwrap();
 
         let mut existing_docs = Vec::new();
@@ -487,7 +513,8 @@ mod tests {
 
         b.iter(|| {
             let mut segment_postings = segment_reader
-                .read_postings(&*TERM_A, SegmentPostingsOption::NoFreq)
+                .inverted_index(TERM_A.field())
+                .read_postings(&*TERM_A, IndexRecordOption::Basic)
                 .unwrap();
             for doc in &existing_docs {
                 if segment_postings.skip_next(*doc) == SkipResult::End {
@@ -524,7 +551,8 @@ mod tests {
         b.iter(|| {
             let n: u32 = test::black_box(17);
             let mut segment_postings = segment_reader
-                .read_postings(&*TERM_A, SegmentPostingsOption::NoFreq)
+                .inverted_index(TERM_A.field())
+                .read_postings(&*TERM_A, IndexRecordOption::Basic)
                 .unwrap();
             let mut s = 0u32;
             while segment_postings.advance() {

src/postings/postings_writer.rs

@@ -1,42 +1,45 @@
 use DocId;
 use schema::Term;
-use schema::FieldValue;
-use postings::PostingsSerializer;
+use postings::{FieldSerializer, InvertedIndexSerializer};
 use std::io;
 use postings::Recorder;
-use analyzer::SimpleTokenizer;
 use Result;
-use schema::{Schema, Field};
-use analyzer::StreamingIterator;
+use schema::{Field, Schema};
+use tokenizer::Token;
 use std::marker::PhantomData;
 use std::ops::DerefMut;
 use datastruct::stacker::{HashMap, Heap};
-use postings::{NothingRecorder, TermFrequencyRecorder, TFAndPositionRecorder};
+use postings::{NothingRecorder, TFAndPositionRecorder, TermFrequencyRecorder};
 use schema::FieldEntry;
 use schema::FieldType;
-use schema::TextIndexingOptions;
+use tokenizer::TokenStream;
+use schema::IndexRecordOption;
 
-fn posting_from_field_entry<'a>(field_entry: &FieldEntry,
-                                heap: &'a Heap)
-                                -> Box<PostingsWriter + 'a> {
+fn posting_from_field_entry<'a>(
+    field_entry: &FieldEntry,
+    heap: &'a Heap,
+) -> Box<PostingsWriter + 'a> {
     match *field_entry.field_type() {
-        FieldType::Str(ref text_options) => {
-            match text_options.get_indexing_options() {
-                TextIndexingOptions::TokenizedWithFreq => {
+        FieldType::Str(ref text_options) => text_options
+            .get_indexing_options()
+            .map(|indexing_options| match indexing_options.index_option() {
+                IndexRecordOption::Basic => {
+                    SpecializedPostingsWriter::<NothingRecorder>::new_boxed(heap)
+                }
+                IndexRecordOption::WithFreqs => {
                     SpecializedPostingsWriter::<TermFrequencyRecorder>::new_boxed(heap)
                 }
-                TextIndexingOptions::TokenizedWithFreqAndPosition => {
+                IndexRecordOption::WithFreqsAndPositions => {
                     SpecializedPostingsWriter::<TFAndPositionRecorder>::new_boxed(heap)
                 }
-                _ => SpecializedPostingsWriter::<NothingRecorder>::new_boxed(heap),
-            }
+            })
+            .unwrap_or_else(|| SpecializedPostingsWriter::<NothingRecorder>::new_boxed(heap)),
+        FieldType::U64(_) | FieldType::I64(_) => {
+            SpecializedPostingsWriter::<NothingRecorder>::new_boxed(heap)
         }
-        FieldType::U64(_) |
-        FieldType::I64(_) => SpecializedPostingsWriter::<NothingRecorder>::new_boxed(heap),
     }
 }
 
-
 pub struct MultiFieldPostingsWriter<'a> {
     heap: &'a Heap,
     term_index: HashMap<'a>,
@@ -51,34 +54,31 @@ impl<'a> MultiFieldPostingsWriter<'a> {
         let per_field_postings_writers: Vec<_> = schema
             .fields()
             .iter()
-            .map(|field_entry| {
-                posting_from_field_entry(field_entry, heap)
-            })
+            .map(|field_entry| posting_from_field_entry(field_entry, heap))
             .collect();
 
         MultiFieldPostingsWriter {
-            heap: heap,
-            term_index: term_index,
-            per_field_postings_writers: per_field_postings_writers,
+            heap,
+            term_index,
+            per_field_postings_writers,
         }
     }
 
-    pub fn index_text(&mut self, doc: DocId, field: Field, field_values: &[&FieldValue]) -> u32 {
+    pub fn index_text(&mut self, doc: DocId, field: Field, token_stream: &mut TokenStream) -> u32 {
         let postings_writer = self.per_field_postings_writers[field.0 as usize].deref_mut();
-        postings_writer.index_text(&mut self.term_index, doc, field, field_values, self.heap)
+        postings_writer.index_text(&mut self.term_index, doc, field, token_stream, self.heap)
     }
 
-    pub fn suscribe(&mut self, doc: DocId, term: &Term) {
+    pub fn subscribe(&mut self, doc: DocId, term: &Term) {
         let postings_writer = self.per_field_postings_writers[term.field().0 as usize].deref_mut();
         postings_writer.suscribe(&mut self.term_index, doc, 0u32, term, self.heap)
     }
 
-
     /// Serialize the inverted index.
     /// It pushes all term, one field at a time, towards the
     /// postings serializer.
     #[allow(needless_range_loop)]
-    pub fn serialize(&self, serializer: &mut PostingsSerializer) -> Result<()> {
+    pub fn serialize(&self, serializer: &mut InvertedIndexSerializer) -> Result<()> {
         let mut term_offsets: Vec<(&[u8], u32)> = self.term_index.iter().collect();
         term_offsets.sort_by_key(|&(k, _v)| k);
 
@@ -101,8 +101,13 @@ impl<'a> MultiFieldPostingsWriter<'a> {
             let (field, start) = offsets[i];
             let (_, stop) = offsets[i + 1];
             let postings_writer = &self.per_field_postings_writers[field.0 as usize];
-            postings_writer
-                .serialize(field, &term_offsets[start..stop], serializer, self.heap)?;
+            let mut field_serializer = serializer.new_field(field)?;
+            postings_writer.serialize(
+                &term_offsets[start..stop],
+                &mut field_serializer,
+                self.heap,
+            )?;
+            field_serializer.close()?;
         }
         Ok(())
     }
@@ -113,7 +118,6 @@ impl<'a> MultiFieldPostingsWriter<'a> {
     }
 }
 
-
 /// The `PostingsWriter` is in charge of receiving documenting
 /// and building a `Segment` in anonymous memory.
 ///
@@ -126,49 +130,41 @@ pub trait PostingsWriter {
     /// * term - the term
     /// * heap - heap used to store the postings informations as well as the terms
     /// in the hashmap.
-    fn suscribe(&mut self,
-                term_index: &mut HashMap,
-                doc: DocId,
-                pos: u32,
-                term: &Term,
-                heap: &Heap);
+    fn suscribe(
+        &mut self,
+        term_index: &mut HashMap,
+        doc: DocId,
+        pos: u32,
+        term: &Term,
+        heap: &Heap,
+    );
 
     /// Serializes the postings on disk.
     /// The actual serialization format is handled by the `PostingsSerializer`.
-    fn serialize(&self,
-                 field: Field,
-                 term_addrs: &[(&[u8], u32)],
-                 serializer: &mut PostingsSerializer,
-                 heap: &Heap)
-                 -> io::Result<()>;
+    fn serialize(
+        &self,
+        term_addrs: &[(&[u8], u32)],
+        serializer: &mut FieldSerializer,
+        heap: &Heap,
+    ) -> io::Result<()>;
 
     /// Tokenize a text and suscribe all of its token.
-    fn index_text<'a>(&mut self,
-                      term_index: &mut HashMap,
-                      doc_id: DocId,
-                      field: Field,
-                      field_values: &[&'a FieldValue],
-                      heap: &Heap)
-                      -> u32 {
-        let mut pos = 0u32;
-        let mut num_tokens: u32 = 0u32;
+    fn index_text(
+        &mut self,
+        term_index: &mut HashMap,
+        doc_id: DocId,
+        field: Field,
+        token_stream: &mut TokenStream,
+        heap: &Heap,
+    ) -> u32 {
         let mut term = unsafe { Term::with_capacity(100) };
         term.set_field(field);
-        for field_value in field_values {
-            let mut tokens = SimpleTokenizer.tokenize(field_value.value().text());
-            // right now num_tokens and pos are redundant, but it should
-            // change when we get proper analyzers
-            while let Some(token) = tokens.next() {
-                term.set_text(token);
-                self.suscribe(term_index, doc_id, pos, &term, heap);
-                pos += 1u32;
-                num_tokens += 1u32;
-            }
-            pos += 1;
-            // THIS is to avoid phrase query accross field repetition.
-            // span queries might still match though :|
-        }
-        num_tokens
+        let mut sink = |token: &Token| {
+            term.set_text(token.text.as_str());
+            self.suscribe(term_index, doc_id, token.position as u32, &term, heap);
+        };
+
+        token_stream.process(&mut sink)
     }
 }
 
@@ -183,7 +179,7 @@ impl<'a, Rec: Recorder + 'static> SpecializedPostingsWriter<'a, Rec> {
     /// constructor
     pub fn new(heap: &'a Heap) -> SpecializedPostingsWriter<'a, Rec> {
         SpecializedPostingsWriter {
-            heap: heap,
+            heap,
             _recorder_type: PhantomData,
         }
     }
@@ -195,12 +191,14 @@ impl<'a, Rec: Recorder + 'static> SpecializedPostingsWriter<'a, Rec> {
 }
 
 impl<'a, Rec: Recorder + 'static> PostingsWriter for SpecializedPostingsWriter<'a, Rec> {
-    fn suscribe(&mut self,
-                term_index: &mut HashMap,
-                doc: DocId,
-                position: u32,
-                term: &Term,
-                heap: &Heap) {
+    fn suscribe(
+        &mut self,
+        term_index: &mut HashMap,
+        doc: DocId,
+        position: u32,
+        term: &Term,
+        heap: &Heap,
+    ) {
         debug_assert!(term.as_slice().len() >= 4);
         let recorder: &mut Rec = term_index.get_or_create(term);
         let current_doc = recorder.current_doc();
@@ -213,20 +211,18 @@ impl<'a, Rec: Recorder + 'static> PostingsWriter for SpecializedPostingsWriter<'
         recorder.record_position(position, heap);
     }
 
-    fn serialize(&self,
-                 field: Field,
-                 term_addrs: &[(&[u8], u32)],
-                 serializer: &mut PostingsSerializer,
-                 heap: &Heap)
-                 -> io::Result<()> {
-        serializer.new_field(field);
+    fn serialize(
+        &self,
+        term_addrs: &[(&[u8], u32)],
+        serializer: &mut FieldSerializer,
+        heap: &Heap,
+    ) -> io::Result<()> {
         for &(term_bytes, addr) in term_addrs {
             let recorder: &mut Rec = self.heap.get_mut_ref(addr);
-            try!(serializer.new_term(term_bytes));
-            try!(recorder.serialize(addr, serializer, heap));
-            try!(serializer.close_term());
+            serializer.new_term(term_bytes)?;
+            recorder.serialize(addr, serializer, heap)?;
+            serializer.close_term()?;
         }
         Ok(())
     }
 }
-

src/postings/recorder.rs

@@ -1,10 +1,10 @@
 use DocId;
-use std::io;
-use postings::PostingsSerializer;
+use std::{self, io};
+use postings::FieldSerializer;
 use datastruct::stacker::{ExpUnrolledLinkedList, Heap, HeapAllocable};
 
 const EMPTY_ARRAY: [u32; 0] = [0u32; 0];
-const POSITION_END: u32 = 4294967295;
+const POSITION_END: u32 = std::u32::MAX;
 
 /// Recorder is in charge of recording relevant information about
 /// the presence of a term in a document.
@@ -27,15 +27,15 @@ pub trait Recorder: HeapAllocable {
     /// Close the document. It will help record the term frequency.
     fn close_doc(&mut self, heap: &Heap);
     /// Pushes the postings information to the serializer.
-    fn serialize(&self,
-                 self_addr: u32,
-                 serializer: &mut PostingsSerializer,
-                 heap: &Heap)
-                 -> io::Result<()>;
+    fn serialize(
+        &self,
+        self_addr: u32,
+        serializer: &mut FieldSerializer,
+        heap: &Heap,
+    ) -> io::Result<()>;
 }
 
 /// Only records the doc ids
-#[repr(C, packed)]
 pub struct NothingRecorder {
     stack: ExpUnrolledLinkedList,
     current_doc: DocId,
@@ -64,21 +64,20 @@ impl Recorder for NothingRecorder {
 
     fn close_doc(&mut self, _heap: &Heap) {}
 
-    fn serialize(&self,
-                 self_addr: u32,
-                 serializer: &mut PostingsSerializer,
-                 heap: &Heap)
-                 -> io::Result<()> {
+    fn serialize(
+        &self,
+        self_addr: u32,
+        serializer: &mut FieldSerializer,
+        heap: &Heap,
+    ) -> io::Result<()> {
         for doc in self.stack.iter(self_addr, heap) {
-            try!(serializer.write_doc(doc, 0u32, &EMPTY_ARRAY));
+            serializer.write_doc(doc, 0u32, &EMPTY_ARRAY)?;
         }
         Ok(())
     }
 }
 
-
 /// Recorder encoding document ids, and term frequencies
-#[repr(C, packed)]
 pub struct TermFrequencyRecorder {
     stack: ExpUnrolledLinkedList,
     current_doc: DocId,
@@ -115,12 +114,12 @@ impl Recorder for TermFrequencyRecorder {
         self.current_tf = 0;
     }
 
-
-    fn serialize(&self,
-                 self_addr: u32,
-                 serializer: &mut PostingsSerializer,
-                 heap: &Heap)
-                 -> io::Result<()> {
+    fn serialize(
+        &self,
+        self_addr: u32,
+        serializer: &mut FieldSerializer,
+        heap: &Heap,
+    ) -> io::Result<()> {
         // the last document has not been closed...
         // its term freq is self.current_tf.
         let mut doc_iter = self.stack
@@ -138,7 +137,6 @@ impl Recorder for TermFrequencyRecorder {
 }
 
 /// Recorder encoding term frequencies as well as positions.
-#[repr(C, packed)]
 pub struct TFAndPositionRecorder {
     stack: ExpUnrolledLinkedList,
     current_doc: DocId,
@@ -171,11 +169,12 @@ impl Recorder for TFAndPositionRecorder {
         self.stack.push(POSITION_END, heap);
     }
 
-    fn serialize(&self,
-                 self_addr: u32,
-                 serializer: &mut PostingsSerializer,
-                 heap: &Heap)
-                 -> io::Result<()> {
+    fn serialize(
+        &self,
+        self_addr: u32,
+        serializer: &mut FieldSerializer,
+        heap: &Heap,
+    ) -> io::Result<()> {
         let mut doc_positions = Vec::with_capacity(100);
         let mut positions_iter = self.stack.iter(self_addr, heap);
         while let Some(doc) = positions_iter.next() {
@@ -189,7 +188,7 @@ impl Recorder for TFAndPositionRecorder {
                     prev_position = position;
                 }
             }
-            try!(serializer.write_doc(doc, doc_positions.len() as u32, &doc_positions));
+            serializer.write_doc(doc, doc_positions.len() as u32, &doc_positions)?;
         }
         Ok(())
     }

src/postings/segment_postings.rs

@@ -1,55 +1,116 @@
-use compression::{NUM_DOCS_PER_BLOCK, BlockDecoder, VIntDecoder};
+use compression::{BlockDecoder, CompressedIntStream, VIntDecoder, COMPRESSION_BLOCK_SIZE};
 use DocId;
-use postings::{Postings, FreqHandler, DocSet, HasLen, SkipResult};
+use postings::{DocSet, HasLen, Postings, SkipResult};
 use std::cmp;
-use fastfield::DeleteBitSet;
 use fst::Streamer;
+use fastfield::DeleteBitSet;
+use std::cell::UnsafeCell;
+use directory::{ReadOnlySource, SourceRead};
 
+const EMPTY_POSITIONS: [u32; 0] = [0u32; 0];
 
-const EMPTY_DATA: [u8; 0] = [0u8; 0];
+struct PositionComputer {
+    // store the amount of position int
+    // before reading positions.
+    //
+    // if none, position are already loaded in
+    // the positions vec.
+    position_to_skip: Option<usize>,
+    positions: Vec<u32>,
+    positions_stream: CompressedIntStream,
+}
 
+impl PositionComputer {
+    pub fn new(positions_stream: CompressedIntStream) -> PositionComputer {
+        PositionComputer {
+            position_to_skip: None,
+            positions: vec![],
+            positions_stream,
+        }
+    }
+
+    pub fn add_skip(&mut self, num_skip: usize) {
+        self.position_to_skip = Some(
+            self.position_to_skip
+                .map(|prev_skip| prev_skip + num_skip)
+                .unwrap_or(0),
+        );
+    }
+
+    pub fn positions(&mut self, term_freq: usize) -> &[u32] {
+        if let Some(num_skip) = self.position_to_skip {
+            self.positions.resize(term_freq, 0u32);
+
+            self.positions_stream.skip(num_skip);
+            self.positions_stream.read(&mut self.positions[..term_freq]);
+
+            let mut cum = 0u32;
+            for i in 0..term_freq as usize {
+                cum += self.positions[i];
+                self.positions[i] = cum;
+            }
+            self.position_to_skip = None;
+        }
+        &self.positions[..term_freq]
+    }
+}
 
 /// `SegmentPostings` represents the inverted list or postings associated to
 /// a term in a `Segment`.
 ///
 /// As we iterate through the `SegmentPostings`, the frequencies are optionally decoded.
 /// Positions on the other hand, are optionally entirely decoded upfront.
-pub struct SegmentPostings<'a> {
-    block_cursor: BlockSegmentPostings<'a>,
+pub struct SegmentPostings {
+    block_cursor: BlockSegmentPostings,
     cur: usize,
     delete_bitset: DeleteBitSet,
+    position_computer: Option<UnsafeCell<PositionComputer>>,
 }
 
-impl<'a> SegmentPostings<'a> {
+impl SegmentPostings {
     /// Reads a Segment postings from an &[u8]
     ///
     /// * `len` - number of document in the posting lists.
     /// * `data` - data array. The complete data is not necessarily used.
     /// * `freq_handler` - the freq handler is in charge of decoding
     ///   frequencies and/or positions
-    pub fn from_block_postings(segment_block_postings: BlockSegmentPostings<'a>,
-                               delete_bitset: DeleteBitSet)
-                               -> SegmentPostings<'a> {
+    pub fn from_block_postings(
+        segment_block_postings: BlockSegmentPostings,
+        delete_bitset: DeleteBitSet,
+        positions_stream_opt: Option<CompressedIntStream>,
+    ) -> SegmentPostings {
+        let position_computer =
+            positions_stream_opt.map(|stream| UnsafeCell::new(PositionComputer::new(stream)));
         SegmentPostings {
             block_cursor: segment_block_postings,
-            cur: NUM_DOCS_PER_BLOCK, // cursor within the block
-            delete_bitset: delete_bitset,
+            cur: COMPRESSION_BLOCK_SIZE, // cursor within the block
+            delete_bitset,
+            position_computer,
         }
     }
 
     /// Returns an empty segment postings object
-    pub fn empty() -> SegmentPostings<'static> {
+    pub fn empty() -> SegmentPostings {
         let empty_block_cursor = BlockSegmentPostings::empty();
         SegmentPostings {
             block_cursor: empty_block_cursor,
             delete_bitset: DeleteBitSet::empty(),
-            cur: NUM_DOCS_PER_BLOCK,
+            cur: COMPRESSION_BLOCK_SIZE,
+            position_computer: None,
+        }
+    }
+
+    fn position_add_skip<F: FnOnce() -> usize>(&self, num_skips_fn: F) {
+        if let Some(position_computer) = self.position_computer.as_ref() {
+            let num_skips = num_skips_fn();
+            unsafe {
+                (*position_computer.get()).add_skip(num_skips);
+            }
         }
     }
 }
 
-
-impl<'a> DocSet for SegmentPostings<'a> {
+impl DocSet for SegmentPostings {
     // goes to the next element.
     // next needs to be called a first time to point to the correct element.
     #[inline]
@@ -59,22 +120,26 @@ impl<'a> DocSet for SegmentPostings<'a> {
             if self.cur >= self.block_cursor.block_len() {
                 self.cur = 0;
                 if !self.block_cursor.advance() {
-                    self.cur = NUM_DOCS_PER_BLOCK;
+                    self.cur = COMPRESSION_BLOCK_SIZE;
                     return false;
                 }
             }
+            self.position_add_skip(|| self.term_freq() as usize);
             if !self.delete_bitset.is_deleted(self.doc()) {
                 return true;
             }
         }
     }
 
-
     fn skip_next(&mut self, target: DocId) -> SkipResult {
         if !self.advance() {
             return SkipResult::End;
         }
 
+        // in the following, thanks to the call to advance above,
+        // we know that the position is not loaded and we need
+        // to skip every doc_freq we cross.
+
         // skip blocks until one that might contain the target
         loop {
             // check if we need to go to the next block
@@ -83,13 +148,25 @@ impl<'a> DocSet for SegmentPostings<'a> {
                 (block_docs[self.cur], block_docs[block_docs.len() - 1])
             };
             if target > last_doc_in_block {
+                // we add skip for the current term independantly,
+                // so that position_add_skip will decide if it should
+                // just set itself to Some(0) or effectively
+                // add the term freq.
+                //let num_skips: u32 = ;
+                self.position_add_skip(|| {
+                    let freqs_skipped = &self.block_cursor.freqs()[self.cur..];
+                    let sum_freq: u32 = freqs_skipped.iter().cloned().sum();
+                    sum_freq as usize
+                });
+
                 if !self.block_cursor.advance() {
                     return SkipResult::End;
                 }
+
                 self.cur = 0;
             } else {
                 if target < current_doc {
-                    // We've overpassed the target after the first `advance` call
+                    // We've passed the target after the first `advance` call
                     // or we're at the beginning of a block.
                     // Either way, we're on the first `DocId` greater than `target`
                     return SkipResult::OverStep;
@@ -135,6 +212,13 @@ impl<'a> DocSet for SegmentPostings<'a> {
 
             // `doc` is now >= `target`
             let doc = block_docs[start];
+
+            self.position_add_skip(|| {
+                let freqs_skipped = &self.block_cursor.freqs()[self.cur..start];
+                let sum_freqs: u32 = freqs_skipped.iter().sum();
+                sum_freqs as usize
+            });
+
             self.cur = start;
 
             if !self.delete_bitset.is_deleted(doc) {
@@ -156,28 +240,37 @@ impl<'a> DocSet for SegmentPostings<'a> {
         self.len()
     }
 
+    /// Return the current document's `DocId`.
     #[inline]
     fn doc(&self) -> DocId {
         let docs = self.block_cursor.docs();
-        assert!(self.cur < docs.len(),
-                "Have you forgotten to call `.advance()` at least once before calling .doc().");
+        debug_assert!(
+            self.cur < docs.len(),
+            "Have you forgotten to call `.advance()` at least once before calling .doc()."
+        );
         docs[self.cur]
     }
 }
 
-impl<'a> HasLen for SegmentPostings<'a> {
+impl HasLen for SegmentPostings {
     fn len(&self) -> usize {
         self.block_cursor.doc_freq()
     }
 }
 
-impl<'a> Postings for SegmentPostings<'a> {
+impl Postings for SegmentPostings {
     fn term_freq(&self) -> u32 {
-        self.block_cursor.freq_handler().freq(self.cur)
+        self.block_cursor.freq(self.cur)
     }
 
     fn positions(&self) -> &[u32] {
-        self.block_cursor.freq_handler().positions(self.cur)
+        let term_freq = self.term_freq();
+        self.position_computer
+            .as_ref()
+            .map(|position_computer| unsafe {
+                (&mut *position_computer.get()).positions(term_freq as usize)
+            })
+            .unwrap_or(&EMPTY_POSITIONS[..])
     }
 }
 
@@ -188,31 +281,35 @@ impl<'a> Postings for SegmentPostings<'a> {
 ///
 /// While it is useful for some very specific high-performance
 /// use cases, you should prefer using `SegmentPostings` for most usage.
-pub struct BlockSegmentPostings<'a> {
-    block_decoder: BlockDecoder,
+pub struct BlockSegmentPostings {
+    doc_decoder: BlockDecoder,
+    freq_decoder: BlockDecoder,
+    has_freq: bool,
+
     doc_freq: usize,
     doc_offset: DocId,
-    num_binpacked_blocks: usize,
+    num_bitpacked_blocks: usize,
     num_vint_docs: usize,
-    remaining_data: &'a [u8],
-    freq_handler: FreqHandler,
+    remaining_data: SourceRead,
 }
 
-impl<'a> BlockSegmentPostings<'a> {
-    pub(crate) fn from_data(doc_freq: usize,
-                            data: &'a [u8],
-                            freq_handler: FreqHandler)
-                            -> BlockSegmentPostings<'a> {
-        let num_binpacked_blocks: usize = (doc_freq as usize) / NUM_DOCS_PER_BLOCK;
-        let num_vint_docs = (doc_freq as usize) - NUM_DOCS_PER_BLOCK * num_binpacked_blocks;
+impl BlockSegmentPostings {
+    pub(crate) fn from_data(
+        doc_freq: usize,
+        data: SourceRead,
+        has_freq: bool,
+    ) -> BlockSegmentPostings {
+        let num_bitpacked_blocks: usize = (doc_freq as usize) / COMPRESSION_BLOCK_SIZE;
+        let num_vint_docs = (doc_freq as usize) - COMPRESSION_BLOCK_SIZE * num_bitpacked_blocks;
         BlockSegmentPostings {
-            num_binpacked_blocks: num_binpacked_blocks,
-            num_vint_docs: num_vint_docs,
-            block_decoder: BlockDecoder::new(),
-            freq_handler: freq_handler,
+            num_bitpacked_blocks,
+            num_vint_docs,
+            doc_decoder: BlockDecoder::new(),
+            freq_decoder: BlockDecoder::with_val(1),
+            has_freq,
             remaining_data: data,
             doc_offset: 0,
-            doc_freq: doc_freq,
+            doc_freq,
         }
     }
 
@@ -226,10 +323,10 @@ impl<'a> BlockSegmentPostings<'a> {
     // # Warning
     //
     // This does not reset the positions list.
-    pub(crate) fn reset(&mut self, doc_freq: usize, postings_data: &'a [u8]) {
-        let num_binpacked_blocks: usize = doc_freq / NUM_DOCS_PER_BLOCK;
-        let num_vint_docs = doc_freq & (NUM_DOCS_PER_BLOCK - 1);
-        self.num_binpacked_blocks = num_binpacked_blocks;
+    pub(crate) fn reset(&mut self, doc_freq: usize, postings_data: SourceRead) {
+        let num_binpacked_blocks: usize = doc_freq / COMPRESSION_BLOCK_SIZE;
+        let num_vint_docs = doc_freq & (COMPRESSION_BLOCK_SIZE - 1);
+        self.num_bitpacked_blocks = num_binpacked_blocks;
         self.num_vint_docs = num_vint_docs;
         self.remaining_data = postings_data;
         self.doc_offset = 0;
@@ -250,7 +347,25 @@ impl<'a> BlockSegmentPostings<'a> {
     /// returned by `.docs()` is empty.
     #[inline]
     pub fn docs(&self) -> &[DocId] {
-        self.block_decoder.output_array()
+        self.doc_decoder.output_array()
+    }
+
+    /// Return the document at index `idx` of the block.
+    #[inline]
+    pub fn doc(&self, idx: usize) -> u32 {
+        self.doc_decoder.output(idx)
+    }
+
+    /// Return the array of `term freq` in the block.
+    #[inline]
+    pub fn freqs(&self) -> &[u32] {
+        self.freq_decoder.output_array()
+    }
+
+    /// Return the frequency at index `idx` of the block.
+    #[inline]
+    pub fn freq(&self, idx: usize) -> u32 {
+        self.freq_decoder.output(idx)
     }
 
     /// Returns the length of the current block.
@@ -260,35 +375,38 @@ impl<'a> BlockSegmentPostings<'a> {
     /// of any number between 1 and `NUM_DOCS_PER_BLOCK - 1`
     #[inline]
     fn block_len(&self) -> usize {
-        self.block_decoder.output_len
-    }
-
-
-    /// Returns a reference to the frequency handler.
-    pub fn freq_handler(&self) -> &FreqHandler {
-        &self.freq_handler
+        self.doc_decoder.output_len
     }
 
     /// Advance to the next block.
     ///
     /// Returns false iff there was no remaining blocks.
     pub fn advance(&mut self) -> bool {
-        if self.num_binpacked_blocks > 0 {
-            self.remaining_data =
-                self.block_decoder
-                    .uncompress_block_sorted(self.remaining_data, self.doc_offset);
-            self.remaining_data = self.freq_handler.read_freq_block(self.remaining_data);
-            self.doc_offset = self.block_decoder.output(NUM_DOCS_PER_BLOCK - 1);
-            self.num_binpacked_blocks -= 1;
+        if self.num_bitpacked_blocks > 0 {
+            let num_consumed_bytes = self.doc_decoder
+                .uncompress_block_sorted(self.remaining_data.as_ref(), self.doc_offset);
+            self.remaining_data.advance(num_consumed_bytes);
+
+            if self.has_freq {
+                let num_consumed_bytes = self.freq_decoder
+                    .uncompress_block_unsorted(self.remaining_data.as_ref());
+                self.remaining_data.advance(num_consumed_bytes);
+            }
+            // it will be used as the next offset.
+            self.doc_offset = self.doc_decoder.output(COMPRESSION_BLOCK_SIZE - 1);
+            self.num_bitpacked_blocks -= 1;
             true
         } else if self.num_vint_docs > 0 {
-            self.remaining_data =
-                self.block_decoder
-                    .uncompress_vint_sorted(self.remaining_data,
-                                            self.doc_offset,
-                                            self.num_vint_docs);
-            self.freq_handler
-                .read_freq_vint(self.remaining_data, self.num_vint_docs);
+            let num_compressed_bytes = self.doc_decoder.uncompress_vint_sorted(
+                self.remaining_data.as_ref(),
+                self.doc_offset,
+                self.num_vint_docs,
+            );
+            self.remaining_data.advance(num_compressed_bytes);
+            if self.has_freq {
+                self.freq_decoder
+                    .uncompress_vint_unsorted(self.remaining_data.as_ref(), self.num_vint_docs);
+            }
             self.num_vint_docs = 0;
             true
         } else {
@@ -297,20 +415,23 @@ impl<'a> BlockSegmentPostings<'a> {
     }
 
     /// Returns an empty segment postings object
-    pub fn empty() -> BlockSegmentPostings<'static> {
+    pub fn empty() -> BlockSegmentPostings {
         BlockSegmentPostings {
-            num_binpacked_blocks: 0,
+            num_bitpacked_blocks: 0,
             num_vint_docs: 0,
-            block_decoder: BlockDecoder::new(),
-            freq_handler: FreqHandler::new_without_freq(),
-            remaining_data: &EMPTY_DATA,
+
+            doc_decoder: BlockDecoder::new(),
+            freq_decoder: BlockDecoder::with_val(1),
+            has_freq: false,
+
+            remaining_data: From::from(ReadOnlySource::empty()),
             doc_offset: 0,
             doc_freq: 0,
         }
     }
 }
 
-impl<'a, 'b> Streamer<'b> for BlockSegmentPostings<'a> {
+impl<'b> Streamer<'b> for BlockSegmentPostings {
     type Item = &'b [DocId];
 
     fn next(&'b mut self) -> Option<&'b [DocId]> {
@@ -332,7 +453,7 @@ mod tests {
     use schema::INT_INDEXED;
     use schema::Term;
     use fst::Streamer;
-    use postings::SegmentPostingsOption;
+    use schema::IndexRecordOption;
     use common::HasLen;
     use super::BlockSegmentPostings;
 
@@ -366,11 +487,11 @@ mod tests {
         index.load_searchers().unwrap();
         let searcher = index.searcher();
         let segment_reader = searcher.segment_reader(0);
+        let inverted_index = segment_reader.inverted_index(int_field);
         let term = Term::from_field_u64(int_field, 0u64);
-        let term_info = segment_reader.get_term_info(&term).unwrap();
+        let term_info = inverted_index.get_term_info(&term).unwrap();
         let mut block_segments =
-            segment_reader
-                .read_block_postings_from_terminfo(&term_info, SegmentPostingsOption::NoFreq);
+            inverted_index.read_block_postings_from_terminfo(&term_info, IndexRecordOption::Basic);
         let mut offset: u32 = 0u32;
         // checking that the block before calling advance is empty
         assert!(block_segments.docs().is_empty());
@@ -384,7 +505,6 @@ mod tests {
         }
     }
 
-
     #[test]
     fn test_reset_block_segment_postings() {
         let mut schema_builder = SchemaBuilder::default();
@@ -406,19 +526,20 @@ mod tests {
         let mut block_segments;
         {
             let term = Term::from_field_u64(int_field, 0u64);
-            let term_info = segment_reader.get_term_info(&term).unwrap();
-            block_segments =
-                segment_reader
-                    .read_block_postings_from_terminfo(&term_info, SegmentPostingsOption::NoFreq);
+            let inverted_index = segment_reader.inverted_index(int_field);
+            let term_info = inverted_index.get_term_info(&term).unwrap();
+            block_segments = inverted_index
+                .read_block_postings_from_terminfo(&term_info, IndexRecordOption::Basic);
         }
         assert!(block_segments.advance());
-        assert!(block_segments.docs() == &[0, 2, 4]);
+        assert_eq!(block_segments.docs(), &[0, 2, 4]);
         {
             let term = Term::from_field_u64(int_field, 1u64);
-            let term_info = segment_reader.get_term_info(&term).unwrap();
-            segment_reader.reset_block_postings_from_terminfo(&term_info, &mut block_segments);
+            let inverted_index = segment_reader.inverted_index(int_field);
+            let term_info = inverted_index.get_term_info(&term).unwrap();
+            inverted_index.reset_block_postings_from_terminfo(&term_info, &mut block_segments);
         }
         assert!(block_segments.advance());
-        assert!(block_segments.docs() == &[1, 3, 5]);
+        assert_eq!(block_segments.docs(), &[1, 3, 5]);
     }
 }

src/postings/segment_postings_option.rs

@@ -1,29 +0,0 @@
-
-
-/// Object describing the amount of information required when reading a postings.
-///
-/// Since decoding information is not free, this makes it possible to
-/// avoid this extra cost when the information is not required.
-/// For instance, positions are useful when running phrase queries
-/// but useless in other queries.
-#[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Ord, Eq)]
-pub enum SegmentPostingsOption {
-    /// Only the doc ids are decoded
-    NoFreq,
-    /// DocIds and term frequencies are decoded
-    Freq,
-    /// DocIds, term frequencies and positions will be decoded.
-    FreqAndPositions,
-}
-
-#[cfg(test)]
-mod tests {
-
-    use super::SegmentPostingsOption;
-
-    #[test]
-    fn test_cmp_segment_postings_option() {
-        assert!(SegmentPostingsOption::FreqAndPositions > SegmentPostingsOption::Freq);
-        assert!(SegmentPostingsOption::Freq > SegmentPostingsOption::NoFreq);
-    }
-}

src/postings/serializer.rs

@@ -5,19 +5,16 @@ use schema::Field;
 use schema::FieldEntry;
 use schema::FieldType;
 use schema::Schema;
-use schema::TextIndexingOptions;
 use directory::WritePtr;
-use compression::{NUM_DOCS_PER_BLOCK, BlockEncoder, CompositeEncoder};
+use compression::{BlockEncoder, COMPRESSION_BLOCK_SIZE};
 use DocId;
 use core::Segment;
 use std::io::{self, Write};
 use compression::VIntEncoder;
-use common::VInt;
-use common::BinarySerializable;
 use common::CountingWriter;
+use common::CompositeWrite;
 use termdict::TermDictionaryBuilder;
 
-
 /// `PostingsSerializer` is in charge of serializing
 /// postings on disk, in the
 /// * `.idx` (inverted index)
@@ -49,74 +46,126 @@ use termdict::TermDictionaryBuilder;
 ///
 /// A description of the serialization format is
 /// [available here](https://fulmicoton.gitbooks.io/tantivy-doc/content/inverted-index.html).
-pub struct PostingsSerializer {
-    terms_fst_builder: TermDictionaryBuilderImpl<WritePtr, TermInfo>,
-    postings_write: CountingWriter<WritePtr>,
-    positions_write: CountingWriter<WritePtr>,
-    last_doc_id_encoded: u32,
-    positions_encoder: CompositeEncoder,
-    block_encoder: BlockEncoder,
-    doc_ids: Vec<DocId>,
-    term_freqs: Vec<u32>,
-    position_deltas: Vec<u32>,
+pub struct InvertedIndexSerializer {
+    terms_write: CompositeWrite<WritePtr>,
+    postings_write: CompositeWrite<WritePtr>,
+    positions_write: CompositeWrite<WritePtr>,
     schema: Schema,
-    text_indexing_options: TextIndexingOptions,
-    term_open: bool,
-    current_term_info: TermInfo,
 }
 
-impl PostingsSerializer {
+impl InvertedIndexSerializer {
     /// Open a new `PostingsSerializer` for the given segment
-    pub fn new(terms_write: WritePtr,
-               postings_write: WritePtr,
-               positions_write: WritePtr,
-               schema: Schema)
-               -> Result<PostingsSerializer> {
-        let terms_fst_builder = try!(TermDictionaryBuilderImpl::new(terms_write));
-        Ok(PostingsSerializer {
-               terms_fst_builder: terms_fst_builder,
-               postings_write: CountingWriter::wrap(postings_write),
-               positions_write: CountingWriter::wrap(positions_write),
-               last_doc_id_encoded: 0u32,
-               positions_encoder: CompositeEncoder::new(),
-               block_encoder: BlockEncoder::new(),
-               doc_ids: Vec::new(),
-               term_freqs: Vec::new(),
-               position_deltas: Vec::new(),
-               schema: schema,
-               text_indexing_options: TextIndexingOptions::Unindexed,
-               term_open: false,
-               current_term_info: TermInfo::default(),
-           })
+    fn new(
+        terms_write: CompositeWrite<WritePtr>,
+        postings_write: CompositeWrite<WritePtr>,
+        positions_write: CompositeWrite<WritePtr>,
+        schema: Schema,
+    ) -> Result<InvertedIndexSerializer> {
+        Ok(InvertedIndexSerializer {
+            terms_write,
+            postings_write,
+            positions_write,
+            schema,
+        })
     }
 
-
     /// Open a new `PostingsSerializer` for the given segment
-    pub fn open(segment: &mut Segment) -> Result<PostingsSerializer> {
-        use SegmentComponent::{TERMS, POSTINGS, POSITIONS};
-        PostingsSerializer::new(segment.open_write(TERMS)?,
-                                segment.open_write(POSTINGS)?,
-                                segment.open_write(POSITIONS)?,
-                                segment.schema())
+    pub fn open(segment: &mut Segment) -> Result<InvertedIndexSerializer> {
+        use SegmentComponent::{POSITIONS, POSTINGS, TERMS};
+        InvertedIndexSerializer::new(
+            CompositeWrite::wrap(segment.open_write(TERMS)?),
+            CompositeWrite::wrap(segment.open_write(POSTINGS)?),
+            CompositeWrite::wrap(segment.open_write(POSITIONS)?),
+            segment.schema(),
+        )
     }
 
     /// Must be called before starting pushing terms of
     /// a given field.
     ///
     /// Loads the indexing options for the given field.
-    pub fn new_field(&mut self, field: Field) {
+    pub fn new_field(&mut self, field: Field) -> io::Result<FieldSerializer> {
         let field_entry: &FieldEntry = self.schema.get_field_entry(field);
-        self.text_indexing_options = match *field_entry.field_type() {
-            FieldType::Str(ref text_options) => text_options.get_indexing_options(),
-            FieldType::U64(ref int_options) |
-            FieldType::I64(ref int_options) => {
-                if int_options.is_indexed() {
-                    TextIndexingOptions::Unindexed
+        let term_dictionary_write = self.terms_write.for_field(field);
+        let postings_write = self.postings_write.for_field(field);
+        let positions_write = self.positions_write.for_field(field);
+        FieldSerializer::new(
+            field_entry.field_type().clone(),
+            term_dictionary_write,
+            postings_write,
+            positions_write,
+        )
+    }
+
+    /// Closes the serializer.
+    pub fn close(self) -> io::Result<()> {
+        self.terms_write.close()?;
+        self.postings_write.close()?;
+        self.positions_write.close()?;
+        Ok(())
+    }
+}
+
+/// The field serializer is in charge of
+/// the serialization of a specific field.
+pub struct FieldSerializer<'a> {
+    term_dictionary_builder: TermDictionaryBuilderImpl<&'a mut CountingWriter<WritePtr>>,
+    postings_serializer: PostingsSerializer<&'a mut CountingWriter<WritePtr>>,
+    positions_serializer_opt: Option<PositionSerializer<&'a mut CountingWriter<WritePtr>>>,
+    current_term_info: TermInfo,
+    term_open: bool,
+}
+
+impl<'a> FieldSerializer<'a> {
+    fn new(
+        field_type: FieldType,
+        term_dictionary_write: &'a mut CountingWriter<WritePtr>,
+        postings_write: &'a mut CountingWriter<WritePtr>,
+        positions_write: &'a mut CountingWriter<WritePtr>,
+    ) -> io::Result<FieldSerializer<'a>> {
+        let (term_freq_enabled, position_enabled): (bool, bool) = match field_type {
+            FieldType::Str(ref text_options) => {
+                if let Some(text_indexing_options) = text_options.get_indexing_options() {
+                    let index_option = text_indexing_options.index_option();
+                    (
+                        index_option.is_termfreq_enabled(),
+                        index_option.is_position_enabled(),
+                    )
                 } else {
-                    TextIndexingOptions::Untokenized
+                    (false, false)
                 }
             }
+            _ => (false, false),
         };
+        let term_dictionary_builder =
+            TermDictionaryBuilderImpl::new(term_dictionary_write, field_type)?;
+        let postings_serializer = PostingsSerializer::new(postings_write, term_freq_enabled);
+        let positions_serializer_opt = if position_enabled {
+            Some(PositionSerializer::new(positions_write))
+        } else {
+            None
+        };
+
+        Ok(FieldSerializer {
+            term_dictionary_builder,
+            postings_serializer,
+            positions_serializer_opt,
+            current_term_info: TermInfo::default(),
+            term_open: false,
+        })
+    }
+
+    fn current_term_info(&self) -> TermInfo {
+        let (filepos, offset) = self.positions_serializer_opt
+            .as_ref()
+            .map(|positions_serializer| positions_serializer.addr())
+            .unwrap_or((0u64, 0u8));
+        TermInfo {
+            doc_freq: 0,
+            postings_offset: self.postings_serializer.addr(),
+            positions_offset: filepos,
+            positions_inner_offset: offset,
+        }
     }
 
     /// Starts the postings for a new term.
@@ -124,72 +173,16 @@ impl PostingsSerializer {
     ///   to the lexicographical order.
     /// * doc_freq - return the number of document containing the term.
     pub fn new_term(&mut self, term: &[u8]) -> io::Result<()> {
-        if self.term_open {
-            panic!("Called new_term, while the previous term was not closed.");
-        }
+        assert!(
+            !self.term_open,
+            "Called new_term, while the previous term was not closed."
+        );
         self.term_open = true;
-        self.doc_ids.clear();
-        self.last_doc_id_encoded = 0;
-        self.term_freqs.clear();
-        self.position_deltas.clear();
-        self.current_term_info = TermInfo {
-            doc_freq: 0,
-            postings_offset: self.postings_write.written_bytes() as u32,
-            positions_offset: self.positions_write.written_bytes() as u32,
-        };
-        self.terms_fst_builder.insert_key(term)
+        self.postings_serializer.clear();
+        self.current_term_info = self.current_term_info();
+        self.term_dictionary_builder.insert_key(term)
     }
 
-    /// Finish the serialization for this term postings.
-    ///
-    /// If the current block is incomplete, it need to be encoded
-    /// using `VInt` encoding.
-    pub fn close_term(&mut self) -> io::Result<()> {
-        if self.term_open {
-
-            self.terms_fst_builder
-                .insert_value(&self.current_term_info)?;
-
-            if !self.doc_ids.is_empty() {
-                // we have doc ids waiting to be written
-                // this happens when the number of doc ids is
-                // not a perfect multiple of our block size.
-                //
-                // In that case, the remaining part is encoded
-                // using variable int encoding.
-                {
-                    let block_encoded =
-                        self.block_encoder
-                            .compress_vint_sorted(&self.doc_ids, self.last_doc_id_encoded);
-                    self.postings_write.write_all(block_encoded)?;
-                    self.doc_ids.clear();
-                }
-                // ... Idem for term frequencies
-                if self.text_indexing_options.is_termfreq_enabled() {
-                    let block_encoded = self.block_encoder
-                        .compress_vint_unsorted(&self.term_freqs[..]);
-                    for num in block_encoded {
-                        num.serialize(&mut self.postings_write)?;
-                    }
-                    self.term_freqs.clear();
-                }
-            }
-            // On the other hand, positions are entirely buffered until the
-            // end of the term, at which point they are compressed and written.
-            if self.text_indexing_options.is_position_enabled() {
-                let posdelta_len = VInt(self.position_deltas.len() as u64);
-                posdelta_len.serialize(&mut self.positions_write)?;
-                let positions_encoded: &[u8] = self.positions_encoder
-                    .compress_unsorted(&self.position_deltas[..]);
-                self.positions_write.write_all(positions_encoded)?;
-                self.position_deltas.clear();
-            }
-            self.term_open = false;
-        }
-        Ok(())
-    }
-
-
     /// Serialize the information that a document contains the current term,
     /// its term frequency, and the position deltas.
     ///
@@ -199,32 +192,88 @@ impl PostingsSerializer {
     ///
     /// Term frequencies and positions may be ignored by the serializer depending
     /// on the configuration of the field in the `Schema`.
-    pub fn write_doc(&mut self,
-                     doc_id: DocId,
-                     term_freq: u32,
-                     position_deltas: &[u32])
-                     -> io::Result<()> {
+    pub fn write_doc(
+        &mut self,
+        doc_id: DocId,
+        term_freq: u32,
+        position_deltas: &[u32],
+    ) -> io::Result<()> {
         self.current_term_info.doc_freq += 1;
+        self.postings_serializer.write_doc(doc_id, term_freq)?;
+        if let Some(ref mut positions_serializer) = self.positions_serializer_opt.as_mut() {
+            positions_serializer.write(position_deltas)?;
+        }
+        Ok(())
+    }
+
+    /// Finish the serialization for this term postings.
+    ///
+    /// If the current block is incomplete, it need to be encoded
+    /// using `VInt` encoding.
+    pub fn close_term(&mut self) -> io::Result<()> {
+        if self.term_open {
+            self.term_dictionary_builder
+                .insert_value(&self.current_term_info)?;
+            self.postings_serializer.close_term()?;
+            self.term_open = false;
+        }
+        Ok(())
+    }
+
+    /// Closes the current current field.
+    pub fn close(mut self) -> io::Result<()> {
+        self.close_term()?;
+        if let Some(positions_serializer) = self.positions_serializer_opt {
+            positions_serializer.close()?;
+        }
+        self.postings_serializer.close()?;
+        self.term_dictionary_builder.finish()?;
+        Ok(())
+    }
+}
+
+struct PostingsSerializer<W: Write> {
+    postings_write: CountingWriter<W>,
+    last_doc_id_encoded: u32,
+
+    block_encoder: BlockEncoder,
+    doc_ids: Vec<DocId>,
+    term_freqs: Vec<u32>,
+
+    termfreq_enabled: bool,
+}
+
+impl<W: Write> PostingsSerializer<W> {
+    fn new(write: W, termfreq_enabled: bool) -> PostingsSerializer<W> {
+        PostingsSerializer {
+            postings_write: CountingWriter::wrap(write),
+
+            block_encoder: BlockEncoder::new(),
+            doc_ids: vec![],
+            term_freqs: vec![],
+
+            last_doc_id_encoded: 0u32,
+            termfreq_enabled,
+        }
+    }
+
+    fn write_doc(&mut self, doc_id: DocId, term_freq: u32) -> io::Result<()> {
         self.doc_ids.push(doc_id);
-        if self.text_indexing_options.is_termfreq_enabled() {
+        if self.termfreq_enabled {
             self.term_freqs.push(term_freq as u32);
         }
-        if self.text_indexing_options.is_position_enabled() {
-            self.position_deltas.extend_from_slice(position_deltas);
-        }
-        if self.doc_ids.len() == NUM_DOCS_PER_BLOCK {
+        if self.doc_ids.len() == COMPRESSION_BLOCK_SIZE {
             {
                 // encode the doc ids
-                let block_encoded: &[u8] =
-                    self.block_encoder
-                        .compress_block_sorted(&self.doc_ids, self.last_doc_id_encoded);
+                let block_encoded: &[u8] = self.block_encoder
+                    .compress_block_sorted(&self.doc_ids, self.last_doc_id_encoded);
                 self.last_doc_id_encoded = self.doc_ids[self.doc_ids.len() - 1];
                 self.postings_write.write_all(block_encoded)?;
             }
-            if self.text_indexing_options.is_termfreq_enabled() {
+            if self.termfreq_enabled {
                 // encode the term_freqs
-                let block_encoded: &[u8] = self.block_encoder
-                    .compress_block_unsorted(&self.term_freqs);
+                let block_encoded: &[u8] =
+                    self.block_encoder.compress_block_unsorted(&self.term_freqs);
                 self.postings_write.write_all(block_encoded)?;
                 self.term_freqs.clear();
             }
@@ -233,12 +282,89 @@ impl PostingsSerializer {
         Ok(())
     }
 
-    /// Closes the serializer.
-    pub fn close(mut self) -> io::Result<()> {
-        try!(self.close_term());
-        try!(self.terms_fst_builder.finish());
-        try!(self.postings_write.flush());
-        try!(self.positions_write.flush());
+    fn close_term(&mut self) -> io::Result<()> {
+        if !self.doc_ids.is_empty() {
+            // we have doc ids waiting to be written
+            // this happens when the number of doc ids is
+            // not a perfect multiple of our block size.
+            //
+            // In that case, the remaining part is encoded
+            // using variable int encoding.
+            {
+                let block_encoded = self.block_encoder
+                    .compress_vint_sorted(&self.doc_ids, self.last_doc_id_encoded);
+                self.postings_write.write_all(block_encoded)?;
+                self.doc_ids.clear();
+            }
+            // ... Idem for term frequencies
+            if self.termfreq_enabled {
+                let block_encoded = self.block_encoder
+                    .compress_vint_unsorted(&self.term_freqs[..]);
+                self.postings_write.write_all(block_encoded)?;
+                self.term_freqs.clear();
+            }
+        }
         Ok(())
     }
+
+    fn close(mut self) -> io::Result<()> {
+        self.postings_write.flush()
+    }
+
+    fn addr(&self) -> u64 {
+        self.postings_write.written_bytes() as u64
+    }
+
+    fn clear(&mut self) {
+        self.doc_ids.clear();
+        self.term_freqs.clear();
+        self.last_doc_id_encoded = 0;
+    }
+}
+
+struct PositionSerializer<W: Write> {
+    buffer: Vec<u32>,
+    write: CountingWriter<W>, // See if we can offset the original counting writer.
+    block_encoder: BlockEncoder,
+}
+
+impl<W: Write> PositionSerializer<W> {
+    fn new(write: W) -> PositionSerializer<W> {
+        PositionSerializer {
+            buffer: Vec::with_capacity(COMPRESSION_BLOCK_SIZE),
+            write: CountingWriter::wrap(write),
+            block_encoder: BlockEncoder::new(),
+        }
+    }
+
+    fn addr(&self) -> (u64, u8) {
+        (self.write.written_bytes() as u64, self.buffer.len() as u8)
+    }
+
+    fn write_block(&mut self) -> io::Result<()> {
+        assert_eq!(self.buffer.len(), COMPRESSION_BLOCK_SIZE);
+        let block_compressed: &[u8] = self.block_encoder.compress_block_unsorted(&self.buffer);
+        self.write.write_all(block_compressed)?;
+        self.buffer.clear();
+        Ok(())
+    }
+
+    fn write(&mut self, mut vals: &[u32]) -> io::Result<()> {
+        let mut buffer_len = self.buffer.len();
+        while vals.len() + buffer_len >= COMPRESSION_BLOCK_SIZE {
+            let len_to_completion = COMPRESSION_BLOCK_SIZE - buffer_len;
+            self.buffer.extend_from_slice(&vals[..len_to_completion]);
+            self.write_block()?;
+            vals = &vals[len_to_completion..];
+            buffer_len = self.buffer.len();
+        }
+        self.buffer.extend_from_slice(vals);
+        Ok(())
+    }
+
+    fn close(mut self) -> io::Result<()> {
+        self.buffer.resize(COMPRESSION_BLOCK_SIZE, 0u32);
+        self.write_block()?;
+        self.write.flush()
+    }
 }

src/postings/term_info.rs

@@ -1,7 +1,6 @@
 use common::BinarySerializable;
 use std::io;
 
-
 /// `TermInfo` contains all of the information
 /// associated to terms in the `.term` file.
 ///
@@ -12,32 +11,36 @@ use std::io;
 /// * `postings_offset` : an offset in the `.idx` file
 /// addressing the start of the posting list associated
 /// to this term.
-#[derive(Debug,Default,Ord,PartialOrd,Eq,PartialEq,Clone)]
+#[derive(Debug, Default, Ord, PartialOrd, Eq, PartialEq, Clone)]
 pub struct TermInfo {
     /// Number of documents in the segment containing the term
     pub doc_freq: u32,
     /// Offset within the postings (`.idx`) file.
-    pub postings_offset: u32,
+    pub postings_offset: u64,
     /// Offset within the position (`.pos`) file.
-    pub positions_offset: u32,
+    pub positions_offset: u64,
+    /// Offset within the position block.
+    pub positions_inner_offset: u8,
 }
 
-
 impl BinarySerializable for TermInfo {
     fn serialize<W: io::Write>(&self, writer: &mut W) -> io::Result<()> {
         self.doc_freq.serialize(writer)?;
         self.postings_offset.serialize(writer)?;
-        self.positions_offset.serialize(writer)
+        self.positions_offset.serialize(writer)?;
+        self.positions_inner_offset.serialize(writer)
     }
 
     fn deserialize<R: io::Read>(reader: &mut R) -> io::Result<Self> {
-        let doc_freq = try!(u32::deserialize(reader));
-        let postings_offset = try!(u32::deserialize(reader));
-        let positions_offset = try!(u32::deserialize(reader));
+        let doc_freq = u32::deserialize(reader)?;
+        let postings_offset = u64::deserialize(reader)?;
+        let positions_offset = u64::deserialize(reader)?;
+        let positions_inner_offset = u8::deserialize(reader)?;
         Ok(TermInfo {
-               doc_freq: doc_freq,
-               postings_offset: postings_offset,
-               positions_offset: positions_offset,
-           })
+            doc_freq,
+            postings_offset,
+            positions_offset,
+            positions_inner_offset,
+        })
     }
 }

src/postings/vec_postings.rs

@@ -1,7 +1,7 @@
 #![allow(dead_code)]
 
 use DocId;
-use postings::{Postings, DocSet, HasLen};
+use postings::{DocSet, HasLen, Postings};
 use std::num::Wrapping;
 
 const EMPTY_ARRAY: [u32; 0] = [];
@@ -19,7 +19,7 @@ pub struct VecPostings {
 impl From<Vec<DocId>> for VecPostings {
     fn from(doc_ids: Vec<DocId>) -> VecPostings {
         VecPostings {
-            doc_ids: doc_ids,
+            doc_ids,
             cursor: Wrapping(usize::max_value()),
         }
     }
@@ -61,8 +61,7 @@ pub mod tests {
 
     use super::*;
     use DocId;
-    use postings::{Postings, SkipResult, DocSet};
-
+    use postings::{DocSet, Postings, SkipResult};
 
     #[test]
     pub fn test_vec_postings() {

src/query/boolean_query/boolean_query.rs

@@ -6,7 +6,7 @@ use Searcher;
 use query::Query;
 use schema::Term;
 use query::TermQuery;
-use postings::SegmentPostingsOption;
+use schema::IndexRecordOption;
 use query::Occur;
 use query::OccurFilter;
 
@@ -27,7 +27,7 @@ pub struct BooleanQuery {
 
 impl From<Vec<(Occur, Box<Query>)>> for BooleanQuery {
     fn from(subqueries: Vec<(Occur, Box<Query>)>) -> BooleanQuery {
-        BooleanQuery { subqueries: subqueries }
+        BooleanQuery { subqueries }
     }
 }
 
@@ -37,10 +37,10 @@ impl Query for BooleanQuery {
     }
 
     fn weight(&self, searcher: &Searcher) -> Result<Box<Weight>> {
-        let sub_weights = try!(self.subqueries
-                     .iter()
-                     .map(|&(ref _occur, ref subquery)| subquery.weight(searcher))
-                     .collect());
+        let sub_weights = self.subqueries
+            .iter()
+            .map(|&(ref _occur, ref subquery)| subquery.weight(searcher))
+            .collect::<Result<_>>()?;
         let occurs: Vec<Occur> = self.subqueries
             .iter()
             .map(|&(ref occur, ref _subquery)| *occur)
@@ -57,10 +57,9 @@ impl BooleanQuery {
         let occur_term_queries: Vec<(Occur, Box<Query>)> = terms
             .into_iter()
             .map(|term| {
-                     let term_query: Box<Query> = box TermQuery::new(term,
-                                                                     SegmentPostingsOption::Freq);
-                     (Occur::Should, term_query)
-                 })
+                let term_query: Box<Query> = box TermQuery::new(term, IndexRecordOption::WithFreqs);
+                (Occur::Should, term_query)
+            })
             .collect();
         BooleanQuery::from(occur_term_queries)
     }

src/query/boolean_query/boolean_scorer.rs

@@ -6,7 +6,6 @@ use postings::DocSet;
 use query::OccurFilter;
 use query::boolean_query::ScoreCombiner;
 
-
 /// Each `HeapItem` represents the head of
 /// one of scorer being merged.
 ///
@@ -54,19 +53,17 @@ impl<TScorer: Scorer> BooleanScorer<TScorer> {
             .iter()
             .map(|posting| posting.doc())
             .enumerate()
-            .map(|(ord, doc)| {
-                     HeapItem {
-                         doc: doc,
-                         ord: ord as u32,
-                     }
-                 })
+            .map(|(ord, doc)| HeapItem {
+                doc,
+                ord: ord as u32,
+            })
             .collect();
         BooleanScorer {
             scorers: non_empty_scorers,
             queue: BinaryHeap::from(heap_items),
             doc: 0u32,
-            score_combiner: score_combiner,
-            occur_filter: occur_filter,
+            score_combiner,
+            occur_filter,
         }
     }
 
@@ -104,7 +101,6 @@ impl<TScorer: Scorer> DocSet for BooleanScorer<TScorer> {
             .unwrap()
     }
 
-
     fn advance(&mut self) -> bool {
         loop {
             self.score_combiner.clear();

src/query/boolean_query/boolean_weight.rs

@@ -13,20 +13,18 @@ pub struct BooleanWeight {
 impl BooleanWeight {
     pub fn new(weights: Vec<Box<Weight>>, occur_filter: OccurFilter) -> BooleanWeight {
         BooleanWeight {
-            weights: weights,
-            occur_filter: occur_filter,
+            weights,
+            occur_filter,
         }
     }
 }
 
-
 impl Weight for BooleanWeight {
     fn scorer<'a>(&'a self, reader: &'a SegmentReader) -> Result<Box<Scorer + 'a>> {
-        let sub_scorers: Vec<Box<Scorer + 'a>> =
-            try!(self.weights
-                                                          .iter()
-                                                          .map(|weight| weight.scorer(reader))
-                                                          .collect());
+        let sub_scorers: Vec<Box<Scorer + 'a>> = self.weights
+            .iter()
+            .map(|weight| weight.scorer(reader))
+            .collect::<Result<_>>()?;
         let boolean_scorer = BooleanScorer::new(sub_scorers, self.occur_filter);
         Ok(box boolean_scorer)
     }

src/query/boolean_query/mod.rs

@@ -7,8 +7,6 @@ pub use self::boolean_query::BooleanQuery;
 pub use self::boolean_scorer::BooleanScorer;
 pub use self::score_combiner::ScoreCombiner;
 
-
-
 #[cfg(test)]
 mod tests {
 
@@ -24,13 +22,12 @@ mod tests {
     use Index;
     use schema::*;
     use fastfield::U64FastFieldReader;
-    use postings::SegmentPostingsOption;
+    use schema::IndexRecordOption;
 
     fn abs_diff(left: f32, right: f32) -> f32 {
         (right - left).abs()
     }
 
-
     #[test]
     pub fn test_boolean_query() {
         let mut schema_builder = SchemaBuilder::default();
@@ -64,8 +61,10 @@ mod tests {
         }
 
         let make_term_query = |text: &str| {
-            let term_query = TermQuery::new(Term::from_field_text(text_field, text),
-                                            SegmentPostingsOption::NoFreq);
+            let term_query = TermQuery::new(
+                Term::from_field_text(text_field, text),
+                IndexRecordOption::Basic,
+            );
             let query: Box<Query> = box term_query;
             query
         };
@@ -87,19 +86,25 @@ mod tests {
             assert_eq!(matching_docs(&boolean_query), vec![0, 1, 3]);
         }
         {
-            let boolean_query = BooleanQuery::from(vec![(Occur::Should, make_term_query("a")),
-                                                        (Occur::Should, make_term_query("b"))]);
+            let boolean_query = BooleanQuery::from(vec![
+                (Occur::Should, make_term_query("a")),
+                (Occur::Should, make_term_query("b")),
+            ]);
             assert_eq!(matching_docs(&boolean_query), vec![0, 1, 2, 3]);
         }
         {
-            let boolean_query = BooleanQuery::from(vec![(Occur::Must, make_term_query("a")),
-                                                        (Occur::Should, make_term_query("b"))]);
+            let boolean_query = BooleanQuery::from(vec![
+                (Occur::Must, make_term_query("a")),
+                (Occur::Should, make_term_query("b")),
+            ]);
             assert_eq!(matching_docs(&boolean_query), vec![0, 1, 3]);
         }
         {
-            let boolean_query = BooleanQuery::from(vec![(Occur::Must, make_term_query("a")),
-                                                        (Occur::Should, make_term_query("b")),
-                                                        (Occur::MustNot, make_term_query("d"))]);
+            let boolean_query = BooleanQuery::from(vec![
+                (Occur::Must, make_term_query("a")),
+                (Occur::Should, make_term_query("b")),
+                (Occur::MustNot, make_term_query("d")),
+            ]);
             assert_eq!(matching_docs(&boolean_query), vec![0, 1]);
         }
         {
@@ -144,6 +149,4 @@ mod tests {
         assert!(!boolean_scorer.advance());
     }
 
-
-
 }

src/query/boolean_query/score_combiner.rs

@@ -37,7 +37,7 @@ impl ScoreCombiner {
 impl From<Vec<Score>> for ScoreCombiner {
     fn from(coords: Vec<Score>) -> ScoreCombiner {
         ScoreCombiner {
-            coords: coords,
+            coords,
             num_fields: 0,
             score: 0f32,
         }

src/query/mod.rs

@@ -1,7 +1,6 @@
-/// Query module
-///
-/// The query module regroups all of tantivy's query objects
-///
+/*!
+Query
+*/
 
 mod query;
 mod boolean_query;

src/query/occur_filter.rs

@@ -1,8 +1,7 @@
 use query::Occur;
 
-
 /// An `OccurFilter` represents a filter over a bitset of
-// at most 64 elements.
+/// at most 64 elements.
 ///
 /// It wraps some simple bitmask to compute the filter
 /// rapidly.
@@ -35,9 +34,6 @@ impl OccurFilter {
                 Occur::Should => {}
             }
         }
-        OccurFilter {
-            and_mask: and_mask,
-            result: result,
-        }
+        OccurFilter { and_mask, result }
     }
 }

src/query/phrase_query/mod.rs

@@ -6,18 +6,16 @@ pub use self::phrase_query::PhraseQuery;
 pub use self::phrase_weight::PhraseWeight;
 pub use self::phrase_scorer::PhraseScorer;
 
-
 #[cfg(test)]
 mod tests {
 
     use super::*;
     use core::Index;
-    use schema::{Term, SchemaBuilder, TEXT};
+    use schema::{SchemaBuilder, Term, TEXT};
     use collector::tests::TestCollector;
 
     #[test]
     pub fn test_phrase_query() {
-
         let mut schema_builder = SchemaBuilder::default();
         let text_field = schema_builder.add_text_field("text", TEXT);
         let schema = schema_builder.build();