Feature/reader (#517)

Adding IndexReader to the API. Making it possible to watch for changes.

* Closes #500

3 files changed, 87 insertions, 61 deletions

diff --git a/src/fastfield/bytes/mod.rs b/src/fastfield/bytes/mod.rs
index 1a551ec..b3e73a5 100644
--- a/src/fastfield/bytes/mod.rs
+++ b/src/fastfield/bytes/mod.rs
@@ -22,9 +22,7 @@ mod tests {
         index_writer.add_document(doc!(field=>vec![1u8, 3, 5, 7, 9]));
         index_writer.add_document(doc!(field=>vec![0u8; 1000]));
         assert!(index_writer.commit().is_ok());
-
-        index.load_searchers().unwrap();
-        let searcher = index.searcher();
+        let searcher = index.reader().unwrap().searcher();
         let reader = searcher.segment_reader(0);
         let bytes_reader = reader.bytes_fast_field_reader(field).unwrap();
 
diff --git a/src/fastfield/multivalued/mod.rs b/src/fastfield/multivalued/mod.rs
index b8e288f..3e2a30e 100644
--- a/src/fastfield/multivalued/mod.rs
+++ b/src/fastfield/multivalued/mod.rs
@@ -9,14 +9,14 @@ mod tests {
 
     extern crate time;
 
-    use query::QueryParser;
+    use self::time::Duration;
     use collector::TopDocs;
+    use query::QueryParser;
     use schema::Cardinality;
     use schema::Facet;
     use schema::IntOptions;
     use schema::Schema;
     use Index;
-    use self::time::Duration;
 
     #[test]
     fn test_multivalued_u64() {
@@ -34,11 +34,12 @@ mod tests {
         index_writer.add_document(doc!(field=>5u64, field=>20u64,field=>1u64));
         assert!(index_writer.commit().is_ok());
 
-        index.load_searchers().unwrap();
-        let searcher = index.searcher();
-        let reader = searcher.segment_reader(0);
+        let searcher = index.reader().unwrap().searcher();
+        let segment_reader = searcher.segment_reader(0);
         let mut vals = Vec::new();
-        let multi_value_reader = reader.multi_fast_field_reader::<u64>(field).unwrap();
+        let multi_value_reader = segment_reader
+            .multi_fast_field_reader::<u64>(field)
+            .unwrap();
         {
             multi_value_reader.get_vals(2, &mut vals);
             assert_eq!(&vals, &[4u64]);
@@ -63,92 +64,121 @@ mod tests {
                 .set_indexed()
                 .set_stored(),
         );
-        let time_i = schema_builder.add_i64_field(
-            "time_stamp_i",
-            IntOptions::default()
-                .set_stored(),
-        );
+        let time_i =
+            schema_builder.add_i64_field("time_stamp_i", IntOptions::default().set_stored());
         let schema = schema_builder.build();
         let index = Index::create_in_ram(schema);
         let mut index_writer = index.writer_with_num_threads(1, 3_000_000).unwrap();
         let first_time_stamp = chrono::Utc::now();
-        index_writer.add_document(doc!(date_field=>first_time_stamp, date_field=>first_time_stamp, time_i=>1i64));
+        index_writer.add_document(
+            doc!(date_field=>first_time_stamp, date_field=>first_time_stamp, time_i=>1i64),
+        );
         index_writer.add_document(doc!(time_i=>0i64));
         // add one second
-        index_writer.add_document(doc!(date_field=>first_time_stamp + Duration::seconds(1), time_i=>2i64));
+        index_writer
+            .add_document(doc!(date_field=>first_time_stamp + Duration::seconds(1), time_i=>2i64));
         // add another second
         let two_secs_ahead = first_time_stamp + Duration::seconds(2);
         index_writer.add_document(doc!(date_field=>two_secs_ahead, date_field=>two_secs_ahead,date_field=>two_secs_ahead, time_i=>3i64));
         assert!(index_writer.commit().is_ok());
 
-        index.load_searchers().unwrap();
-        let searcher = index.searcher();
+        let reader = index.reader().unwrap();
+        let searcher = reader.searcher();
         let reader = searcher.segment_reader(0);
         assert_eq!(reader.num_docs(), 4);
 
         {
             let parser = QueryParser::for_index(&index, vec![date_field]);
-            let query = parser.parse_query(&format!("\"{}\"", first_time_stamp.to_rfc3339()).to_string())
+            let query = parser
+                .parse_query(&format!("\"{}\"", first_time_stamp.to_rfc3339()).to_string())
                 .expect("could not parse query");
-            let results = searcher.search(&query, &TopDocs::with_limit(5))
+            let results = searcher
+                .search(&query, &TopDocs::with_limit(5))
                 .expect("could not query index");
 
             assert_eq!(results.len(), 1);
             for (_score, doc_address) in results {
                 let retrieved_doc = searcher.doc(doc_address).expect("cannot fetch doc");
-                assert_eq!(retrieved_doc.get_first(date_field).expect("cannot find value").date_value().timestamp(), first_time_stamp.timestamp());
-                assert_eq!(retrieved_doc.get_first(time_i).expect("cannot find value").i64_value(), 1i64);
+                assert_eq!(
+                    retrieved_doc
+                        .get_first(date_field)
+                        .expect("cannot find value")
+                        .date_value()
+                        .timestamp(),
+                    first_time_stamp.timestamp()
+                );
+                assert_eq!(
+                    retrieved_doc
+                        .get_first(time_i)
+                        .expect("cannot find value")
+                        .i64_value(),
+                    1i64
+                );
             }
         }
 
         {
             let parser = QueryParser::for_index(&index, vec![date_field]);
-            let query = parser.parse_query(&format!("\"{}\"", two_secs_ahead.to_rfc3339()).to_string())
+            let query = parser
+                .parse_query(&format!("\"{}\"", two_secs_ahead.to_rfc3339()).to_string())
                 .expect("could not parse query");
-            let results = searcher.search(&query, &TopDocs::with_limit(5))
+            let results = searcher
+                .search(&query, &TopDocs::with_limit(5))
                 .expect("could not query index");
 
             assert_eq!(results.len(), 1);
 
             for (_score, doc_address) in results {
                 let retrieved_doc = searcher.doc(doc_address).expect("cannot fetch doc");
-                assert_eq!(retrieved_doc.get_first(date_field).expect("cannot find value").date_value().timestamp(), two_secs_ahead.timestamp());
-                assert_eq!(retrieved_doc.get_first(time_i).expect("cannot find value").i64_value(), 3i64);
+                assert_eq!(
+                    retrieved_doc
+                        .get_first(date_field)
+                        .expect("cannot find value")
+                        .date_value()
+                        .timestamp(),
+                    two_secs_ahead.timestamp()
+                );
+                assert_eq!(
+                    retrieved_doc
+                        .get_first(time_i)
+                        .expect("cannot find value")
+                        .i64_value(),
+                    3i64
+                );
             }
         }
 
-
         // TODO: support Date range queries
-//        {
-//            let parser = QueryParser::for_index(&index, vec![date_field]);
-//            let range_q = format!("\"{}\"..\"{}\"",
-//                                  (first_time_stamp + Duration::seconds(1)).to_rfc3339(),
-//                                  (first_time_stamp + Duration::seconds(3)).to_rfc3339()
-//            );
-//            let query = parser.parse_query(&range_q)
-//                .expect("could not parse query");
-//            let results = searcher.search(&query, &TopDocs::with_limit(5))
-//                .expect("could not query index");
-//
-//
-//            assert_eq!(results.len(), 2);
-//            for (i, doc_pair) in results.iter().enumerate() {
-//                let retrieved_doc = searcher.doc(doc_pair.1).expect("cannot fetch doc");
-//                let offset_sec = match i {
-//                    0 => 1,
-//                    1 => 3,
-//                    _ => panic!("should not have more than 2 docs")
-//                };
-//                let time_i_val = match i {
-//                    0 => 2,
-//                    1 => 3,
-//                    _ => panic!("should not have more than 2 docs")
-//                };
-//                assert_eq!(retrieved_doc.get_first(date_field).expect("cannot find value").date_value().timestamp(),
-//                           (first_time_stamp + Duration::seconds(offset_sec)).timestamp());
-//                assert_eq!(retrieved_doc.get_first(time_i).expect("cannot find value").i64_value(), time_i_val);
-//            }
-//        }
+        //        {
+        //            let parser = QueryParser::for_index(&index, vec![date_field]);
+        //            let range_q = format!("\"{}\"..\"{}\"",
+        //                                  (first_time_stamp + Duration::seconds(1)).to_rfc3339(),
+        //                                  (first_time_stamp + Duration::seconds(3)).to_rfc3339()
+        //            );
+        //            let query = parser.parse_query(&range_q)
+        //                .expect("could not parse query");
+        //            let results = searcher.search(&query, &TopDocs::with_limit(5))
+        //                .expect("could not query index");
+        //
+        //
+        //            assert_eq!(results.len(), 2);
+        //            for (i, doc_pair) in results.iter().enumerate() {
+        //                let retrieved_doc = searcher.doc(doc_pair.1).expect("cannot fetch doc");
+        //                let offset_sec = match i {
+        //                    0 => 1,
+        //                    1 => 3,
+        //                    _ => panic!("should not have more than 2 docs")
+        //                };
+        //                let time_i_val = match i {
+        //                    0 => 2,
+        //                    1 => 3,
+        //                    _ => panic!("should not have more than 2 docs")
+        //                };
+        //                assert_eq!(retrieved_doc.get_first(date_field).expect("cannot find value").date_value().timestamp(),
+        //                           (first_time_stamp + Duration::seconds(offset_sec)).timestamp());
+        //                assert_eq!(retrieved_doc.get_first(time_i).expect("cannot find value").i64_value(), time_i_val);
+        //            }
+        //        }
     }
 
     #[test]
@@ -167,8 +197,7 @@ mod tests {
         index_writer.add_document(doc!(field=> -5i64, field => -20i64, field=>1i64));
         assert!(index_writer.commit().is_ok());
 
-        index.load_searchers().unwrap();
-        let searcher = index.searcher();
+        let searcher = index.reader().unwrap().searcher();
         let reader = searcher.segment_reader(0);
         let mut vals = Vec::new();
         let multi_value_reader = reader.multi_fast_field_reader::<i64>(field).unwrap();
diff --git a/src/fastfield/multivalued/reader.rs b/src/fastfield/multivalued/reader.rs
index d7df15a..3456de5 100644
--- a/src/fastfield/multivalued/reader.rs
+++ b/src/fastfield/multivalued/reader.rs
@@ -75,8 +75,7 @@ mod tests {
             index_writer.add_document(doc);
         }
         index_writer.commit().expect("Commit failed");
-        index.load_searchers().expect("Reloading searchers");
-        let searcher = index.searcher();
+        let searcher = index.reader().unwrap().searcher();
         let segment_reader = searcher.segment_reader(0);
         let mut facet_reader = segment_reader.facet_reader(facet_field).unwrap();