Merge with panicks.

src/collector/mod.rs

@@ -147,7 +147,7 @@ pub mod tests {
         
     impl Collector for FastFieldTestCollector {
         fn set_segment(&mut self, _: SegmentLocalId, reader: &SegmentReader) -> Result<()> {
-            self.ff_reader = reader.get_fast_field_reader(self.field);
+            self.ff_reader = Some(reader.get_fast_field_reader(self.field)?);
             Ok(())
         }
 

src/core/segment_reader.rs

@@ -5,6 +5,7 @@ use core::SegmentComponent;
 use schema::Term;
 use common::HasLen;
 use core::SegmentMeta;
+use fastfield::{self, FastFieldNotAvailableError};
 use fastfield::delete::DeleteBitSet;
 use store::StoreReader;
 use schema::Document;
@@ -84,13 +85,17 @@ impl SegmentReader {
     /// # Panics
     /// May panic if the index is corrupted.
     /// TODO return Err
-    pub fn get_fast_field_reader<TFastFieldReader: FastFieldReader>(&self, field: Field) -> Option<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()) {
-            None
+            Err(FastFieldNotAvailableError::new(field_entry))
         }
         else {
-            self.fast_fields_reader.open_reader(field)
+            Ok(
+                self.fast_fields_reader
+                .open_reader(field)
+                .expect("Fast field file corrupted.")
+            )
         }
         // match field_entry.field_type() {
         //     &FieldType::Str(_) => {

src/error.rs

@@ -10,8 +10,7 @@ use std::sync::PoisonError;
 use directory::error::{OpenReadError, OpenWriteError, OpenDirectoryError};
 use query;
 use schema;
-
-
+use fastfield::FastFieldNotAvailableError;
 
 
 
@@ -38,7 +37,14 @@ pub enum Error {
     ErrorInThread(String),
     /// An Error appeared related to the lack of a field.
     SchemaError(String),
-    
+    /// Tried to access a fastfield reader for a field not configured accordingly.
+    FastFieldError(FastFieldNotAvailableError)
+}
+
+impl From<FastFieldNotAvailableError> for Error {
+    fn from(fastfield_error: FastFieldNotAvailableError) -> Error {
+        Error::FastFieldError(fastfield_error)
+    }
 }
 
 impl From<io::Error> for Error {

src/fastfield/error.rs

@@ -0,0 +1,19 @@
+use std::result;
+use schema::FieldEntry;
+
+#[derive(Debug)]
+pub struct FastFieldNotAvailableError {
+    field_name: String,
+}
+
+pub type Result<R> = result::Result<R, FastFieldNotAvailableError>; 
+
+impl FastFieldNotAvailableError {
+
+    pub fn new(field_entry: &FieldEntry) -> FastFieldNotAvailableError {
+        FastFieldNotAvailableError {
+            field_name: field_entry.name().clone(),
+        }
+    }
+
+}

src/fastfield/mod.rs

@@ -13,12 +13,14 @@
 mod reader;
 mod writer;
 mod serializer;
+mod error;
 pub mod delete;
 
 pub use self::writer::{U64FastFieldsWriter, U64FastFieldWriter};
 pub use self::reader::{FastFieldsReader, U64FastFieldReader};
 pub use self::reader::FastFieldReader;
 pub use self::serializer::FastFieldSerializer;
+pub use self::error::{Result, FastFieldNotAvailableError};
 
 #[cfg(test)]
 mod tests {

src/indexer/merger.rs

@@ -72,11 +72,15 @@ fn compute_min_max_val(u64_reader: &U64FastFieldReader, max_doc: DocId, delete_b
 }
 
 fn extract_fieldnorm_reader(segment_reader: &SegmentReader, field: Field) -> Option<U64FastFieldReader> {
-    segment_reader.get_fieldnorms_reader(field)
+    // TODO
+    // segment_reader.get_fieldnorms_reader(field)
+    panic!("extract_fieldnorm_reader");
 }
 
 fn extract_fast_field_reader(segment_reader: &SegmentReader, field: Field) -> Option<U64FastFieldReader> {
-    segment_reader.get_fast_field_reader(field)
+    // segment_reader.get_fast_field_reader(field)
+    // TODO
+    panic!("extract_fast_field_reader");
 }
 
 impl IndexMerger {
@@ -296,6 +300,7 @@ mod tests {
     use query::TermQuery;
     use schema::{Field, FieldValue};
     use core::Index;
+    use fastfield::U64FastFieldReader;
     use Searcher;
     use DocAddress;
     use collector::tests::FastFieldTestCollector;
@@ -507,11 +512,11 @@ mod tests {
             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 = searcher.segment_reader(0).get_fast_field_reader(score_field).unwrap();
+            let score_field_reader: U64FastFieldReader = searcher.segment_reader(0).get_fast_field_reader(score_field).unwrap();
             assert_eq!(score_field_reader.min_val(), 1);
             assert_eq!(score_field_reader.max_val(), 3);
 
-            let score_field_reader = searcher.segment_reader(1).get_fast_field_reader(score_field).unwrap();
+            let score_field_reader: U64FastFieldReader = searcher.segment_reader(1).get_fast_field_reader(score_field).unwrap();
             assert_eq!(score_field_reader.min_val(), 4000);
             assert_eq!(score_field_reader.max_val(), 7000);
         }
@@ -533,7 +538,7 @@ mod tests {
             assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "e")), 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 = searcher.segment_reader(0).get_fast_field_reader(score_field).unwrap();
+            let score_field_reader: U64FastFieldReader = searcher.segment_reader(0).get_fast_field_reader(score_field).unwrap();
             assert_eq!(score_field_reader.min_val(), 3);
             assert_eq!(score_field_reader.max_val(), 7000);
         }
@@ -555,7 +560,7 @@ mod tests {
             assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "e")), 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 = searcher.segment_reader(0).get_fast_field_reader(score_field).unwrap();
+            let score_field_reader: U64FastFieldReader = searcher.segment_reader(0).get_fast_field_reader(score_field).unwrap();
             assert_eq!(score_field_reader.min_val(), 3);
             assert_eq!(score_field_reader.max_val(), 7000);
         }
@@ -578,7 +583,7 @@ mod tests {
             assert_eq!(search_term(&searcher, Term::from_field_text(text_field, "e")), 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 = searcher.segment_reader(0).get_fast_field_reader(score_field).unwrap();
+            let score_field_reader: U64FastFieldReader = searcher.segment_reader(0).get_fast_field_reader(score_field).unwrap();
             assert_eq!(score_field_reader.min_val(), 6000);
             assert_eq!(score_field_reader.max_val(), 7000);
         }