From de60540e062a4fcc824afcd0501a4039b7e98b4e Mon Sep 17 00:00:00 2001
From: Paul Masurel <paul.masurel@gmail.com>
Date: Wed, 9 Dec 2020 17:14:41 +0900
Subject: [PATCH] fixing compilation

---
 src/collector/filter_collector_wrapper.rs | 17 +++++++----------
 src/fastfield/reader.rs                   |  9 +++++++++
 src/fastfield/readers.rs                  |  6 +++++-
 3 files changed, 21 insertions(+), 11 deletions(-)

diff --git a/src/collector/filter_collector_wrapper.rs b/src/collector/filter_collector_wrapper.rs
index 276823031..4722d5899 100644
--- a/src/collector/filter_collector_wrapper.rs
+++ b/src/collector/filter_collector_wrapper.rs
@@ -144,22 +144,19 @@ where
             ))
         };
         let fast_fields = segment_reader.fast_fields();
-        let fast_filed_reader: crate::Result<FastFieldReader<TPredicateValue>> = match schema_type {
-            crate::schema::Type::U64 => {fast_fields.u64(self.field).ok_or_else(err_closure)}
-            crate::schema::Type::I64 => {fast_fields.i64(self.field).ok_or_else(err_closure)}
-            crate::schema::Type::F64 => {fast_fields.f64(self.field).ok_or_else(err_closure)}
-            crate::schema::Type::Date => {fast_fields.date(self.field).ok_or_else(err_closure)}
-            crate::schema::Type::Bytes => {fast_fields.bytes(self.field).ok_or_else(err_closure)}
-            crate::schema::Type::Str | crate::schema::Type::HierarchicalFacet => {Err(TantivyError::SchemaError(format!("Field {:?} uses an unsupported type", segment_reader.schema().get_field_name(self.field))))}
-        };
 
+        let fast_value_type = TPredicateValue::to_type();
+        // TODO  do a runtime check of `fast_value_type` against the schema.
+
+        let fast_field_reader_opt = fast_fields.typed_fast_field_reader(self.field);
+        let fast_field_reader = fast_field_reader_opt
+            .ok_or_else(|| TantivyError::SchemaError(format!("{:?} is not declared as a fast field in the schema.", self.field)))?;
         let segment_collector = self
             .collector
             .for_segment(segment_local_id, segment_reader)?;
 
-        let a = fast_filed_reader?;
         Ok(FilterSegmentCollector {
-            fast_field_reader: a,
+            fast_field_reader ,
             segment_collector: segment_collector,
             predicate: self.predicate,
             t_predicate_value: PhantomData,
diff --git a/src/fastfield/reader.rs b/src/fastfield/reader.rs
index 37a7e449a..34cccc8a1 100644
--- a/src/fastfield/reader.rs
+++ b/src/fastfield/reader.rs
@@ -51,6 +51,15 @@ impl<Item: FastValue> FastFieldReader<Item> {
         }
     }
 
+    pub(crate) fn cast<TFastValue: FastValue>(self) -> FastFieldReader<TFastValue> {
+        FastFieldReader {
+            bit_unpacker: self.bit_unpacker,
+            min_value_u64: self.min_value_u64,
+            max_value_u64: self.max_value_u64,
+            _phantom: PhantomData,
+        }
+    }
+
     /// Return the value associated to the given document.
     ///
     /// This accessor should return as fast as possible.
diff --git a/src/fastfield/readers.rs b/src/fastfield/readers.rs
index 177f23cd2..86ad932bf 100644
--- a/src/fastfield/readers.rs
+++ b/src/fastfield/readers.rs
@@ -1,5 +1,5 @@
 use crate::common::CompositeFile;
-use crate::fastfield::BytesFastFieldReader;
+use crate::fastfield::{BytesFastFieldReader, FastValue};
 use crate::fastfield::MultiValueIntFastFieldReader;
 use crate::fastfield::{FastFieldNotAvailableError, FastFieldReader};
 use crate::schema::{Cardinality, Field, FieldType, Schema};
@@ -201,6 +201,10 @@ impl FastFieldReaders {
         None
     }
 
+    pub(crate) fn typed_fast_field_reader<TFastValue: FastValue>(&self, field: Field) -> Option<FastFieldReader<TFastValue>> {
+        self.u64_lenient(field).map(|fast_field_reader| fast_field_reader.cast())
+    }
+
     /// Returns the `i64` fast field reader reader associated to `field`.
     ///
     /// If `field` is not a i64 fast field, this method returns `None`.