issue/65 Switching to u64.

1 files changed, 40 insertions, 42 deletions

diff --git a/src/fastfield/reader.rs b/src/fastfield/reader.rs
index 1ceac85..f466f2c 100644
--- a/src/fastfield/reader.rs
+++ b/src/fastfield/reader.rs
@@ -1,7 +1,5 @@
 use std::io;
 use std::collections::HashMap;
-use std::ops::Deref;
-
 use directory::ReadOnlySource;
 use common::BinarySerializable;
 use DocId;
@@ -10,36 +8,36 @@ use std::path::Path;
 use schema::FAST;
 use directory::{WritePtr, RAMDirectory, Directory};
 use fastfield::FastFieldSerializer;
-use fastfield::U32FastFieldsWriter;
+use fastfield::U64FastFieldsWriter;
 use common::bitpacker::compute_num_bits;
 use common::bitpacker::BitUnpacker;
 
 
 lazy_static! {
-    static ref U32_FAST_FIELD_EMPTY: ReadOnlySource = {
-        let u32_fast_field = U32FastFieldReader::from(Vec::new());
-        u32_fast_field._data.clone()
+    static ref U64_FAST_FIELD_EMPTY: ReadOnlySource = {
+        let u64_fast_field = U64FastFieldReader::from(Vec::new());
+        u64_fast_field._data.clone()
     };
 }
 
-pub struct U32FastFieldReader {
+pub struct U64FastFieldReader {
     _data: ReadOnlySource,
     bit_unpacker: BitUnpacker,
-    min_val: u32,
-    max_val: u32,
+    min_val: u64,
+    max_val: u64,
 }
 
-impl U32FastFieldReader {
+impl U64FastFieldReader {
 
-    pub fn empty() -> U32FastFieldReader {
-        U32FastFieldReader::open(U32_FAST_FIELD_EMPTY.clone())
+    pub fn empty() -> U64FastFieldReader {
+        U64FastFieldReader::open(U64_FAST_FIELD_EMPTY.clone())
     }
 
-    pub fn min_val(&self,) -> u32 {
+    pub fn min_val(&self,) -> u64 {
         self.min_val
     }
 
-    pub fn max_val(&self,) -> u32 {
+    pub fn max_val(&self,) -> u64 {
         self.max_val
     }
 
@@ -47,22 +45,22 @@ impl U32FastFieldReader {
     ///
     /// # Panics
     /// Panics if the data is corrupted.
-    pub fn open(data: ReadOnlySource) -> U32FastFieldReader {
-        let min_val;
-        let amplitude;
-        let max_val;
+    pub fn open(data: ReadOnlySource) -> U64FastFieldReader {
+        
+        let min_val: u64;
+        let max_val: u64;
+        let bit_unpacker: BitUnpacker;
+        
         {
-            let mut cursor = data.as_slice();
-            min_val = u32::deserialize(&mut cursor).unwrap();
-            amplitude = u32::deserialize(&mut cursor).unwrap();
+            let mut cursor: &[u8] = data.as_slice();
+            min_val = u64::deserialize(&mut cursor).expect("Failed to read the min_val of fast field.");
+            let amplitude = u64::deserialize(&mut cursor).expect("Failed to read the amplitude of fast field.");
             max_val = min_val + amplitude;
+            let num_bits = compute_num_bits(amplitude);
+            bit_unpacker = BitUnpacker::new(cursor, num_bits as usize)
         }
-        let num_bits = compute_num_bits(amplitude);
-        let bit_unpacker = {
-            let data_arr = &(data.deref()[8..]);
-            BitUnpacker::new(data_arr, num_bits as usize)
-        };
-        U32FastFieldReader {
+
+        U64FastFieldReader {
             _data: data,
             bit_unpacker: bit_unpacker,
             min_val: min_val,
@@ -70,23 +68,23 @@ impl U32FastFieldReader {
         }
     }
 
-    pub fn get(&self, doc: DocId) -> u32 {
+    pub fn get(&self, doc: DocId) -> u64 {
         self.min_val + self.bit_unpacker.get(doc as usize)
     }
 }
 
 
-impl From<Vec<u32>> for U32FastFieldReader {
-    fn from(vals: Vec<u32>) -> U32FastFieldReader {
+impl From<Vec<u64>> for U64FastFieldReader {
+    fn from(vals: Vec<u64>) -> U64FastFieldReader {
         let mut schema_builder = SchemaBuilder::default();
-        let field = schema_builder.add_u32_field("field", FAST);
+        let field = schema_builder.add_u64_field("field", FAST);
         let schema = schema_builder.build();
         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 fast_field_writers = U32FastFieldsWriter::from_schema(&schema);
+            let mut fast_field_writers = U64FastFieldsWriter::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);
@@ -95,18 +93,18 @@ impl From<Vec<u32>> for U32FastFieldReader {
             serializer.close().unwrap();
         }
         let source = directory.open_read(&path).unwrap();
-        let fast_field_readers = U32FastFieldsReader::open(source).unwrap();
+        let fast_field_readers = U64FastFieldsReader::open(source).unwrap();
         fast_field_readers.get_field(field).unwrap()
      }
 }
 
-pub struct U32FastFieldsReader {
+pub struct U64FastFieldsReader {
     source: ReadOnlySource,
     field_offsets: HashMap<Field, (u32, u32)>,
 }
 
-impl U32FastFieldsReader {
-    pub fn open(source: ReadOnlySource) -> io::Result<U32FastFieldsReader> {
+impl U64FastFieldsReader {
+    pub fn open(source: ReadOnlySource) -> io::Result<U64FastFieldsReader> {
         let header_offset;
         let field_offsets: Vec<(Field, u32)>;
         {
@@ -130,26 +128,26 @@ impl U32FastFieldsReader {
             let (field, start_offset) = *field_start_offsets;
             field_offsets_map.insert(field, (start_offset, *stop_offset));
         }
-        Ok(U32FastFieldsReader {
+        Ok(U64FastFieldsReader {
             field_offsets: field_offsets_map,
             source: source,
         })
     }
     
-    /// Returns the u32 fast value reader if the field
-    /// is a u32 field indexed as "fast".
+    /// Returns the u64 fast value reader if the field
+    /// is a u64 field indexed as "fast".
     ///
-    /// Return None if the field is not a u32 field
+    /// 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 get_field(&self, field: Field) -> Option<U32FastFieldReader> {
+    pub fn get_field(&self, field: Field) -> Option<U64FastFieldReader> {
         self.field_offsets
             .get(&field)
             .map(|&(start, stop)| {
                 let field_source = self.source.slice(start as usize, stop as usize);
-                U32FastFieldReader::open(field_source)
+                U64FastFieldReader::open(field_source)
             })
     }
 }