Experimental do not merge

src/schema/document/default_document.rs

@@ -1,15 +1,16 @@
 use std::collections::{BTreeMap, HashMap, HashSet};
 use std::net::Ipv6Addr;
 
-use common::DateTime;
+use common::{BinarySerializable, DateTime, VInt};
 use serde_json::Map;
 
+use crate::schema::document::se::BinaryValueSerializer;
 use crate::schema::document::{
-    DeserializeError, Document, DocumentDeserialize, DocumentDeserializer,
+    BinaryDocumentDeserializer, BinaryDocumentSerializer, DeserializeError, Document, DocumentDeserialize, DocumentDeserializer, ReferenceValue, ReferenceValueLeaf
 };
 use crate::schema::field_type::ValueParsingError;
 use crate::schema::field_value::FieldValueIter;
-use crate::schema::{Facet, Field, FieldValue, NamedFieldDocument, OwnedValue, Schema};
+use crate::schema::{Facet, Field, FieldValue, NamedFieldDocument, OwnedValue, Schema, Value};
 use crate::tokenizer::PreTokenizedString;
 
 /// TantivyDocument provides a default implementation of the `Document` trait.
@@ -85,6 +86,36 @@ impl IntoIterator for TantivyDocument {
 }
 
 impl TantivyDocument {
+
+    pub fn to_bytes(&self, buffer: &mut Vec<u8>) -> std::io::Result<()> {
+        buffer.clear();
+        let num_field_values = self.field_values.len();
+
+        VInt(num_field_values as u64).serialize(buffer)?;
+        for (field, value_access) in self.iter_fields_and_values() {
+            field.serialize(buffer)?;
+            let mut serializer = BinaryValueSerializer::new(buffer);
+            match value_access.as_value() {
+                ReferenceValue::Leaf(ReferenceValueLeaf::PreTokStr(pre_tokenized_text)) => {
+                    serializer.serialize_value(ReferenceValue::Leaf::<&'_ OwnedValue>(
+                        ReferenceValueLeaf::Str(&pre_tokenized_text.text),
+                    ))?;
+                }
+                _ => {
+                    serializer.serialize_value(value_access.as_value())?;
+                }
+            }
+        }
+        Ok(())
+    }
+
+
+    pub fn from_bytes(&self, mut payload: &[u8]) -> Self {
+        let deserializer = BinaryDocumentDeserializer::from_reader(&mut payload).unwrap();
+        Self::deserialize(deserializer).unwrap()
+
+    }
+
     /// Creates a new, empty document object
     pub fn new() -> TantivyDocument {
         TantivyDocument::default()

src/schema/document/owned_value.rs

@@ -1,4 +1,4 @@
-use std::collections::{btree_map, BTreeMap};
+use std::collections::BTreeMap;
 use std::fmt;
 use std::net::Ipv6Addr;
 
@@ -45,7 +45,7 @@ pub enum OwnedValue {
     /// A set of values.
     Array(Vec<Self>),
     /// Dynamic object value.
-    Object(BTreeMap<String, Self>),
+    Object(Vec<(String, Self)>),
     /// IpV6 Address. Internally there is no IpV4, it needs to be converted to `Ipv6Addr`.
     IpAddr(Ipv6Addr),
 }
@@ -148,10 +148,10 @@ impl ValueDeserialize for OwnedValue {
 
             fn visit_object<'de, A>(&self, mut access: A) -> Result<Self::Value, DeserializeError>
             where A: ObjectAccess<'de> {
-                let mut elements = BTreeMap::new();
+                let mut elements = Vec::with_capacity(access.size_hint());
 
                 while let Some((key, value)) = access.next_entry()? {
-                    elements.insert(key, value);
+                    elements.push((key, value));
                 }
 
                 Ok(OwnedValue::Object(elements))
@@ -248,12 +248,13 @@ impl<'de> serde::Deserialize<'de> for OwnedValue {
 
             fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
             where A: MapAccess<'de> {
-                let mut object = BTreeMap::new();
+                let mut object =
-
+                    map.size_hint()
+                       .map(Vec::with_capacity)
+                       .unwrap_or_default();
                 while let Some((key, value)) = map.next_entry()? {
-                    object.insert(key, value);
+                    object.push((key, value));
                 }
-
                 Ok(OwnedValue::Object(object))
             }
         }
@@ -363,7 +364,8 @@ impl From<PreTokenizedString> for OwnedValue {
 
 impl From<BTreeMap<String, OwnedValue>> for OwnedValue {
     fn from(object: BTreeMap<String, OwnedValue>) -> OwnedValue {
-        OwnedValue::Object(object)
+        let key_values = object.into_iter().collect();
+        OwnedValue::Object(key_values)
     }
 }
 
@@ -417,18 +419,15 @@ impl From<serde_json::Value> for OwnedValue {
 
 impl From<serde_json::Map<String, serde_json::Value>> for OwnedValue {
     fn from(map: serde_json::Map<String, serde_json::Value>) -> Self {
-        let mut object = BTreeMap::new();
+        let object: Vec<(String, OwnedValue)> = map.into_iter()
-
+            .map(|(key, value)| (key, OwnedValue::from(value)))
-        for (key, value) in map {
+            .collect();
-            object.insert(key, OwnedValue::from(value));
-        }
-
         OwnedValue::Object(object)
     }
 }
 
 /// A wrapper type for iterating over a serde_json object producing reference values.
-pub struct ObjectMapIter<'a>(btree_map::Iter<'a, String, OwnedValue>);
+pub struct ObjectMapIter<'a>(std::slice::Iter<'a, (String, OwnedValue)>);
 
 impl<'a> Iterator for ObjectMapIter<'a> {
     type Item = (&'a str, &'a OwnedValue);