moved common

src/common/mod.rs

@@ -0,0 +1,9 @@
+mod serialize;
+mod timer;
+mod vint;
+
+pub use self::serialize::BinarySerializable;
+pub use self::timer::Timing;
+pub use self::timer::TimerTree;
+pub use self::timer::OpenTimer;
+pub use self::vint::VInt;

src/common/serialize.rs

@@ -4,6 +4,7 @@ use std::fmt;
 use std::io::Write;
 use std::io::Read;
 use std::io;
+use common::VInt;
 use byteorder;
 
 pub trait BinarySerializable : fmt::Debug + Sized {
@@ -11,61 +12,6 @@ pub trait BinarySerializable : fmt::Debug + Sized {
     fn deserialize(reader: &mut Read) -> io::Result<Self>;
 }
 
-#[derive(Debug, Eq, PartialEq)]
-pub struct VInt(pub u64);
-
-impl VInt {
-    pub fn val(&self,) -> u64 {
-        self.0.clone()
-    }
-}
-
-impl BinarySerializable for VInt {
-    fn serialize(&self, writer: &mut Write) -> io::Result<usize> {
-        let mut remaining = self.0.clone();
-        let mut written: usize = 0;
-        let mut buffer = [0u8; 10];
-        loop {
-            let mut next_byte: u8 = (remaining % 128u64) as u8;
-            remaining /= 128u64;
-            if remaining == 0u64 {
-                buffer[written] = next_byte;
-                written += 1;
-                break;
-            }
-            else {
-                next_byte |= 128u8;
-                buffer[written] = next_byte;
-                written += 1;
-            }
-        }
-        try!(writer.write_all(&buffer[0..written]));
-        Ok(written)
-    }
-
-    fn deserialize(reader: &mut Read) -> io::Result<Self> {
-        let mut bytes = reader.bytes();
-        let mut result = 0u64;
-        let mut shift = 0u64;
-        loop {
-            match bytes.next() {
-                Some(Ok(b)) => {
-                    result += ((b % 128u8) as u64) << shift;
-                    if b & 128 == 0u8 {
-                        break;
-                    }
-                    shift += 7;
-                }
-                _ => {
-                    return Err(io::Error::new(io::ErrorKind::InvalidData, "Reach end of buffer"))
-                }
-            }
-        }
-        Ok(VInt(result))
-    }
-}
-
-
 fn convert_byte_order_error(byteorder_error: byteorder::Error) -> io::Error {
     match byteorder_error {
         byteorder::Error::UnexpectedEOF => io::Error::new(io::ErrorKind::InvalidData, "Reached EOF unexpectedly"),
@@ -171,6 +117,11 @@ impl BinarySerializable for String {
 #[cfg(test)]
 mod test {
 
+
+    use std::io::Cursor;
+    use common::VInt;
+    use super::*;
+
     fn serialize_test<T: BinarySerializable + Eq>(v: T, num_bytes: usize) {
         let mut buffer: Vec<u8> = Vec::new();
         assert_eq!(v.serialize(&mut buffer).unwrap(), num_bytes);
@@ -180,9 +131,6 @@ mod test {
         assert_eq!(deser, v);
     }
 
-    use std::io::Cursor;
-    use super::*;
-
     #[test]
     fn test_serialize_u8() {
         serialize_test(3u8, 1);

src/common/vint.rs

@@ -0,0 +1,58 @@
+use super::BinarySerializable;
+use std::io;
+use std::io::Write;
+use std::io::Read;
+
+#[derive(Debug, Eq, PartialEq)]
+pub struct VInt(pub u64);
+
+impl VInt {
+    pub fn val(&self,) -> u64 {
+        self.0.clone()
+    }
+}
+
+impl BinarySerializable for VInt {
+    fn serialize(&self, writer: &mut Write) -> io::Result<usize> {
+        let mut remaining = self.0.clone();
+        let mut written: usize = 0;
+        let mut buffer = [0u8; 10];
+        loop {
+            let mut next_byte: u8 = (remaining % 128u64) as u8;
+            remaining /= 128u64;
+            if remaining == 0u64 {
+                buffer[written] = next_byte;
+                written += 1;
+                break;
+            }
+            else {
+                next_byte |= 128u8;
+                buffer[written] = next_byte;
+                written += 1;
+            }
+        }
+        try!(writer.write_all(&buffer[0..written]));
+        Ok(written)
+    }
+
+    fn deserialize(reader: &mut Read) -> io::Result<Self> {
+        let mut bytes = reader.bytes();
+        let mut result = 0u64;
+        let mut shift = 0u64;
+        loop {
+            match bytes.next() {
+                Some(Ok(b)) => {
+                    result += ((b % 128u8) as u64) << shift;
+                    if b & 128 == 0u8 {
+                        break;
+                    }
+                    shift += 7;
+                }
+                _ => {
+                    return Err(io::Error::new(io::ErrorKind::InvalidData, "Reach end of buffer"))
+                }
+            }
+        }
+        Ok(VInt(result))
+    }
+}

src/core/mod.rs

@@ -4,10 +4,8 @@ pub mod reader;
 pub mod codec;
 pub mod searcher;
 pub mod collector;
-pub mod serialize;
 pub mod index;
 pub mod merger;
-pub mod timer;
 
 use std::error;
 use std::io;

src/core/reader.rs

@@ -13,10 +13,10 @@ use datastruct::FstMap;
 use std::fmt;
 use rustc_serialize::json;
 use core::index::SegmentInfo;
-use core::timer::OpenTimer;
+use common::OpenTimer;
 use schema::U32Field;
 use core::convert_to_ioerror;
-use core::serialize::BinarySerializable;
+use common::BinarySerializable;
 use fastfield::{U32FastFieldsReader, U32FastFieldReader};
 use compression;
 use std::mem;

src/core/searcher.rs

@@ -5,7 +5,7 @@ use DocId;
 use schema::{Document, Term};
 use core::collector::Collector;
 use std::io;
-use core::timer::TimerTree;
+use common::TimerTree;
 
 #[derive(Debug)]
 pub struct Searcher {

src/datastruct/fstmap.rs

@@ -7,7 +7,7 @@ use fst::raw::Fst;
 use fst::Streamer;
 
 use directory::ReadOnlySource;
-use core::serialize::BinarySerializable;
+use common::BinarySerializable;
 use std::marker::PhantomData;
 
 fn convert_fst_error(e: fst::Error) -> io::Error {

src/fastfield/reader.rs

@@ -1,12 +1,14 @@
 use std::io;
+use std::io::{SeekFrom, Seek};
+use std::collections::HashMap;
+use std::ops::Deref;
+
 use directory::ReadOnlySource;
 use fastfield::DividerU32;
-use core::serialize::BinarySerializable;
+use common::BinarySerializable;
 use DocId;
-use std::collections::HashMap;
 use schema::U32Field;
-use std::io::{SeekFrom, Seek};
-use std::ops::Deref;
+
 use super::compute_num_bits;
 
 pub struct U32FastFieldReader {

src/fastfield/serializer.rs

@@ -1,4 +1,4 @@
-use core::serialize::BinarySerializable;
+use common::BinarySerializable;
 use directory::WritePtr;
 use schema::U32Field;
 use std::io;

src/lib.rs

@@ -34,6 +34,8 @@ mod directory;
 mod compression;
 mod fastfield;
 mod store;
+mod common;
+
 pub mod schema;
 
 pub use directory::Directory;

src/postings/serializer.rs

@@ -7,7 +7,7 @@ use DocId;
 use core::index::Segment;
 use std::io;
 use core::index::SegmentComponent;
-use core::serialize::BinarySerializable;
+use common::BinarySerializable;
 
 pub struct PostingsSerializer {
     terms_fst_builder: FstMapBuilder<WritePtr, TermInfo>, // TODO find an alternative to work around the "move"

src/postings/term_info.rs

@@ -1,4 +1,4 @@
-use core::serialize::BinarySerializable;
+use common::BinarySerializable;
 use std::io;
 
 #[derive(Debug,Ord,PartialOrd,Eq,PartialEq,Clone)]

src/schema/term.rs

@@ -1,7 +1,7 @@
 use std::io::Write;
 use std::fmt;
 
-use core::serialize::BinarySerializable;
+use common::BinarySerializable;
 use super::U32Field;
 use super::TextField;
 

src/schema/text_field.rs

@@ -2,7 +2,7 @@ use std::io::Write;
 use std::io;
 
 use std::io::Read;
-use core::serialize::BinarySerializable;
+use common::BinarySerializable;
 use rustc_serialize::Encodable;
 use rustc_serialize::Decoder;
 use rustc_serialize::Encoder;

src/schema/u32_field.rs

@@ -2,7 +2,7 @@ use std::io;
 use std::io::Write;
 use std::io::Read;
 
-use core::serialize::BinarySerializable;
+use common::BinarySerializable;
 use rustc_serialize::Encodable;
 use rustc_serialize::Decoder;
 use rustc_serialize::Encoder;

src/store/reader.rs

@@ -3,7 +3,7 @@ use std::cell::RefCell;
 use DocId;
 use schema::Document;
 use schema::TextFieldValue;
-use core::serialize::BinarySerializable;
+use common::BinarySerializable;
 
 use std::io::Read;
 use std::io::Cursor;

src/store/writer.rs

@@ -1,7 +1,7 @@
 use directory::WritePtr;
 use DocId;
 use schema::TextFieldValue;
-use core::serialize::BinarySerializable;
+use common::BinarySerializable;
 use std::io::Write;
 use std::io::Read;
 use std::io;