feat: Implement De/Serialize on Blob

src/data/doc_ids.rs

@@ -7,31 +7,32 @@ use std::{io, mem};
 
 use byteorder::{NativeEndian, WriteBytesExt};
 use fst::raw::MmapReadOnly;
+use serde::ser::{Serialize, Serializer};
 
 use crate::DocumentId;
 use crate::data::Data;
 
 #[derive(Clone)]
 pub struct DocIds {
-    doc_ids: Data,
+    data: Data,
 }
 
 impl DocIds {
     pub unsafe fn from_path<P: AsRef<Path>>(path: P) -> io::Result<Self> {
         let mmap = MmapReadOnly::open_path(path)?;
-        let doc_ids = Data::Mmap(mmap);
-        Ok(DocIds { doc_ids })
+        let data = Data::Mmap(mmap);
+        Ok(DocIds { data })
     }
 
     pub fn from_bytes(vec: Vec<u8>) -> Result<Self, Box<Error>> {
         // FIXME check if modulo DocumentId
         let len = vec.len();
-        let doc_ids = Data::Shared {
+        let data = Data::Shared {
             vec: Arc::new(vec),
             offset: 0,
             len: len
         };
-        Ok(DocIds { doc_ids })
+        Ok(DocIds { data })
     }
 
     pub fn contains(&self, doc: DocumentId) -> bool {
@@ -40,13 +41,19 @@ impl DocIds {
     }
 
     pub fn doc_ids(&self) -> &[DocumentId] {
-        let slice = &self.doc_ids;
+        let slice = &self.data;
         let ptr = slice.as_ptr() as *const DocumentId;
         let len = slice.len() / mem::size_of::<DocumentId>();
         unsafe { from_raw_parts(ptr, len) }
     }
 }
 
+impl Serialize for DocIds {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        self.data.as_ref().serialize(serializer)
+    }
+}
+
 pub struct DocIdsBuilder<W> {
     doc_ids: BTreeSet<DocumentId>, // TODO: prefer a linked-list
     wrt: W,

src/data/doc_indexes.rs

@@ -8,6 +8,7 @@ use std::mem;
 
 use fst::raw::MmapReadOnly;
 use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
+use serde::ser::{Serialize, Serializer, SerializeTuple};
 
 use crate::DocIndex;
 use crate::data::Data;
@@ -84,6 +85,15 @@ impl DocIndexes {
     }
 }
 
+impl Serialize for DocIndexes {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        let mut tuple = serializer.serialize_tuple(2)?;
+        tuple.serialize_element(self.ranges.as_ref())?;
+        tuple.serialize_element(self.indexes.as_ref())?;
+        tuple.end()
+    }
+}
+
 pub struct DocIndexesBuilder<W> {
     keys: BTreeMap<String, u64>,
     indexes: Vec<Vec<DocIndex>>,

src/data/mod.rs

@@ -23,6 +23,12 @@ impl Deref for Data {
     type Target = [u8];
 
     fn deref(&self) -> &Self::Target {
+        self.as_ref()
+    }
+}
+
+impl AsRef<[u8]> for Data {
+    fn as_ref(&self) -> &[u8] {
         match self {
             Data::Shared { vec, offset, len } => {
                 &vec[*offset..offset + len]