feat(preserve_order): integrate IndexMap support across Value types and deserializers

Author: lmmx

src/serde/value/borrowed/de.rs

@@ -176,17 +176,32 @@ impl<'de> SeqAccess<'de> for ArrayRef<'de> {
     }
 }
 
+#[cfg(not(feature = "preserve_order"))]
 struct ObjectAccess<'de, const N: usize = 32> {
     i: halfbrown::IntoIter<Cow<'de, str>, Value<'de>, N>,
     v: Option<Value<'de>>,
 }
 
+#[cfg(feature = "preserve_order")]
+struct ObjectAccess<'de> {
+    i: indexmap::map::IntoIter<Cow<'de, str>, Value<'de>>,
+    v: Option<Value<'de>>,
+}
+
+#[cfg(not(feature = "preserve_order"))]
 impl<'de, const N: usize> ObjectAccess<'de, N> {
     fn new(i: halfbrown::IntoIter<Cow<'de, str>, Value<'de>, N>) -> Self {
         Self { i, v: None }
     }
 }
 
+#[cfg(feature = "preserve_order")]
+impl<'de> ObjectAccess<'de> {
+    fn new(i: indexmap::map::IntoIter<Cow<'de, str>, Value<'de>>) -> Self {
+        Self { i, v: None }
+    }
+}
+
 // `MapAccess` is provided to the `Visitor` to give it the ability to iterate
 // through entries of the map.
 impl<'de> MapAccess<'de> for ObjectAccess<'de> {
@@ -216,16 +231,32 @@ impl<'de> MapAccess<'de> for ObjectAccess<'de> {
     }
 }
 
+#[cfg(not(feature = "preserve_order"))]
 struct ObjectRefAccess<'de> {
     i: halfbrown::Iter<'de, Cow<'de, str>, Value<'de>>,
     v: Option<&'de Value<'de>>,
 }
+
+#[cfg(feature = "preserve_order")]
+struct ObjectRefAccess<'de> {
+    i: indexmap::map::Iter<'de, Cow<'de, str>, Value<'de>>,
+    v: Option<&'de Value<'de>>,
+}
+
+#[cfg(not(feature = "preserve_order"))]
 impl<'de> ObjectRefAccess<'de> {
     fn new(i: halfbrown::Iter<'de, Cow<'de, str>, Value<'de>>) -> Self {
         Self { i, v: None }
     }
 }
 
+#[cfg(feature = "preserve_order")]
+impl<'de> ObjectRefAccess<'de> {
+    fn new(i: indexmap::map::Iter<'de, Cow<'de, str>, Value<'de>>) -> Self {
+        Self { i, v: None }
+    }
+}
+
 // `MapAccess` is provided to the `Visitor` to give it the ability to iterate
 // through entries of the map.
 impl<'de> MapAccess<'de> for ObjectRefAccess<'de> {

src/serde/value/owned/de.rs

@@ -164,16 +164,32 @@ impl<'de> SeqAccess<'de> for ArrayRef<'de> {
     }
 }
 
+#[cfg(not(feature = "preserve_order"))]
 struct ObjectAccess<const N: usize = 32> {
     i: halfbrown::IntoIter<String, Value, N>,
     v: Option<Value>,
 }
 
+#[cfg(feature = "preserve_order")]
+struct ObjectAccess {
+    i: indexmap::map::IntoIter<String, Value>,
+    v: Option<Value>,
+}
+
+#[cfg(not(feature = "preserve_order"))]
 impl<const N: usize> ObjectAccess<N> {
     fn new(i: halfbrown::IntoIter<String, Value, N>) -> Self {
         Self { i, v: None }
     }
 }
+
+#[cfg(feature = "preserve_order")]
+impl ObjectAccess {
+    fn new(i: indexmap::map::IntoIter<String, Value>) -> Self {
+        Self { i, v: None }
+    }
+}
+
 // `MapAccess` is provided to the `Visitor` to give it the ability to iterate
 // through entries of the map.
 impl<'de> MapAccess<'de> for ObjectAccess {
@@ -203,17 +219,32 @@ impl<'de> MapAccess<'de> for ObjectAccess {
     }
 }
 
+#[cfg(not(feature = "preserve_order"))]
 struct ObjectRefAccess<'de> {
     i: halfbrown::Iter<'de, String, Value>,
     v: Option<&'de Value>,
 }
 
+#[cfg(feature = "preserve_order")]
+struct ObjectRefAccess<'de> {
+    i: indexmap::map::Iter<'de, String, Value>,
+    v: Option<&'de Value>,
+}
+
+#[cfg(not(feature = "preserve_order"))]
 impl<'de> ObjectRefAccess<'de> {
     fn new(i: halfbrown::Iter<'de, String, Value>) -> Self {
         Self { i, v: None }
     }
 }
 
+#[cfg(feature = "preserve_order")]
+impl<'de> ObjectRefAccess<'de> {
+    fn new(i: indexmap::map::Iter<'de, String, Value>) -> Self {
+        Self { i, v: None }
+    }
+}
+
 // `MapAccess` is provided to the `Visitor` to give it the ability to iterate
 // through entries of the map.
 impl<'de> MapAccess<'de> for ObjectRefAccess<'de> {

src/value.rs

@@ -68,7 +68,10 @@ pub use self::owned::{
     to_value_with_buffers as to_owned_value_with_buffers,
 };
 use crate::{Buffers, Deserializer, Result};
+#[cfg(not(feature = "preserve_order"))]
 use halfbrown::HashMap;
+#[cfg(feature = "preserve_order")]
+use indexmap::IndexMap;
 use std::hash::Hash;
 use std::marker::PhantomData;
 use tape::Node;
@@ -78,8 +81,18 @@ pub use value_trait::*;
 #[cfg(feature = "known-key")]
 pub type ObjectHasher = crate::known_key::NotSoRandomState;
 /// Hasher used for objects
-#[cfg(not(feature = "known-key"))]
+#[cfg(all(not(feature = "known-key"), not(feature = "preserve_order")))]
 pub type ObjectHasher = halfbrown::DefaultHashBuilder;
+/// Hasher used for objects
+#[cfg(all(not(feature = "known-key"), feature = "preserve_order"))]
+pub type ObjectHasher = std::hash::RandomState;
+
+/// Hashmap used for objects
+#[cfg(not(feature = "preserve_order"))]
+type ObjectMap<K, V> = HashMap<K, V, ObjectHasher>;
+/// Hashmap used for objects
+#[cfg(feature = "preserve_order")]
+type ObjectMap<K, V> = IndexMap<K, V, ObjectHasher>;
 
 /// Parses a slice of bytes into a Value dom.
 ///
@@ -92,7 +105,7 @@ pub type ObjectHasher = halfbrown::DefaultHashBuilder;
 /// Will return `Err` if `s` is invalid JSON.
 pub fn deserialize<'de, Value, Key>(s: &'de mut [u8]) -> Result<Value>
 where
-    Value: ValueBuilder<'de> + From<Vec<Value>> + From<HashMap<Key, Value, ObjectHasher>> + 'de,
+    Value: ValueBuilder<'de> + From<Vec<Value>> + From<ObjectMap<Key, Value>> + 'de,
     Key: Hash + Eq + From<&'de str>,
 {
     match Deserializer::from_slice(s) {
@@ -117,7 +130,7 @@ pub fn deserialize_with_buffers<'de, Value, Key>(
     buffers: &mut Buffers,
 ) -> Result<Value>
 where
-    Value: ValueBuilder<'de> + From<Vec<Value>> + From<HashMap<Key, Value, ObjectHasher>> + 'de,
+    Value: ValueBuilder<'de> + From<Vec<Value>> + From<ObjectMap<Key, Value>> + 'de,
     Key: Hash + Eq + From<&'de str>,
 {
     match Deserializer::from_slice_with_buffers(s, buffers) {
@@ -128,7 +141,7 @@ where
 
 struct ValueDeserializer<'de, Value, Key>
 where
-    Value: ValueBuilder<'de> + From<Vec<Value>> + From<HashMap<Key, Value, ObjectHasher>> + 'de,
+    Value: ValueBuilder<'de> + From<Vec<Value>> + From<ObjectMap<Key, Value>> + 'de,
     Key: Hash + Eq + From<&'de str>,
 {
     de: Deserializer<'de>,
@@ -140,7 +153,7 @@ where
     Value: ValueBuilder<'de>
         + From<&'de str>
         + From<Vec<Value>>
-        + From<HashMap<Key, Value, ObjectHasher>>
+        + From<ObjectMap<Key, Value>>
         + 'de,
     Key: Hash + Eq + From<&'de str>,
 {
@@ -179,8 +192,8 @@ where
 
     #[cfg_attr(not(feature = "no-inline"), inline)]
     fn parse_map(&mut self, len: usize) -> Value {
-        let mut res: HashMap<Key, Value, ObjectHasher> =
-            HashMap::with_capacity_and_hasher(len, ObjectHasher::default());
+        let mut res: ObjectMap<Key, Value> =
+            ObjectMap::with_capacity_and_hasher(len, ObjectHasher::default());
 
         // Since we checked if it's empty we know that we at least have one
         // element so we eat this

src/value/borrowed.rs

@@ -38,6 +38,7 @@ use std::ops::{Index, IndexMut};
 /// Representation of a JSON object
 #[cfg(not(feature = "preserve_order"))]
 pub type Object<'value> = HashMap<Cow<'value, str>, Value<'value>, ObjectHasher>;
+/// Representation of a JSON object
 #[cfg(feature = "preserve_order")]
 pub type Object<'value> = IndexMap<Cow<'value, str>, Value<'value>, ObjectHasher>;
 

src/value/borrowed/from.rs

@@ -1,6 +1,5 @@
 use super::{Object, Value};
-use crate::OwnedValue;
-use crate::StaticNode;
+use crate::{ObjectHasher, OwnedValue, StaticNode};
 use crate::cow::Cow;
 
 impl From<OwnedValue> for Value<'_> {
@@ -202,11 +201,13 @@ impl<'value, K: Into<Cow<'value, str>>, V: Into<Value<'value>>> FromIterator<(K,
 {
     #[cfg_attr(not(feature = "no-inline"), inline)]
     fn from_iter<I: IntoIterator<Item = (K, V)>>(iter: I) -> Self {
-        Value::Object(Box::new(
-            iter.into_iter()
-                .map(|(k, v)| (Into::into(k), Into::into(v)))
-                .collect(),
-        ))
+        let iter = iter.into_iter();
+        let (lower, _) = iter.size_hint();
+        let mut map = Object::with_capacity_and_hasher(lower, ObjectHasher::default());
+        for (k, v) in iter {
+            map.insert(k.into(), v.into());
+        }
+        Value::Object(Box::new(map))
     }
 }
 

src/value/lazy/object.rs

@@ -18,22 +18,34 @@ pub enum Iter<'borrow, 'tape, 'input> {
     /// Tape variant
     Tape(tape::object::Iter<'tape, 'input>),
     /// Value variant
+    #[cfg(not(feature = "preserve_order"))]
     Value(halfbrown::Iter<'borrow, crate::cow::Cow<'input, str>, borrowed::Value<'input>>),
+    /// Value variant
+    #[cfg(feature = "preserve_order")]
+    Value(indexmap::map::Iter<'borrow, crate::cow::Cow<'input, str>, borrowed::Value<'input>>),
 }
 
 /// Iterator over the keys of an object
 pub enum Keys<'borrow, 'tape, 'input> {
     /// Tape variant
     Tape(tape::object::Keys<'tape, 'input>),
     /// Value variant
+    #[cfg(not(feature = "preserve_order"))]
     Value(halfbrown::Keys<'borrow, crate::cow::Cow<'input, str>, borrowed::Value<'input>>),
+    /// Value variant
+    #[cfg(feature = "preserve_order")]
+    Value(indexmap::map::Keys<'borrow, crate::cow::Cow<'input, str>, borrowed::Value<'input>>),
 }
 /// Iterator over the values of an object
 pub enum Values<'borrow, 'tape, 'input> {
     /// Tape variant
     Tape(tape::object::Values<'tape, 'input>),
     /// Value variant
+    #[cfg(not(feature = "preserve_order"))]
     Value(halfbrown::Values<'borrow, crate::cow::Cow<'input, str>, borrowed::Value<'input>>),
+    /// Value variant
+    #[cfg(feature = "preserve_order")]
+    Value(indexmap::map::Values<'borrow, crate::cow::Cow<'input, str>, borrowed::Value<'input>>),
 }
 
 //value_trait::Object for

src/value/owned.rs

@@ -26,12 +26,19 @@ mod serialize;
 use super::ObjectHasher;
 use crate::{Buffers, prelude::*};
 use crate::{Deserializer, Node, Result};
+#[cfg(not(feature = "preserve_order"))]
 use halfbrown::HashMap;
+#[cfg(feature = "preserve_order")]
+use indexmap::IndexMap;
 use std::fmt;
 use std::ops::{Index, IndexMut};
 
 /// Representation of a JSON object
+#[cfg(not(feature = "preserve_order"))]
 pub type Object = HashMap<String, Value, ObjectHasher>;
+/// Representation of a JSON object
+#[cfg(feature = "preserve_order")]
+pub type Object = IndexMap<String, Value, ObjectHasher>;
 
 /// Parses a slice of bytes into a Value dom.
 ///

src/value/owned/from.rs

@@ -1,5 +1,5 @@
 use super::{Object, Value};
-use crate::{BorrowedValue, StaticNode};
+use crate::{BorrowedValue, ObjectHasher, StaticNode};
 
 impl From<crate::BorrowedValue<'_>> for Value {
     #[cfg_attr(not(feature = "no-inline"), inline)]
@@ -199,11 +199,13 @@ impl<V: Into<Value>> FromIterator<V> for Value {
 impl<K: ToString, V: Into<Value>> FromIterator<(K, V)> for Value {
     #[cfg_attr(not(feature = "no-inline"), inline)]
     fn from_iter<I: IntoIterator<Item = (K, V)>>(iter: I) -> Self {
-        Self::Object(Box::new(
-            iter.into_iter()
-                .map(|(k, v)| (k.to_string(), Into::into(v)))
-                .collect(),
-        ))
+        let iter = iter.into_iter();
+        let (lower, _) = iter.size_hint();
+        let mut map = Object::with_capacity_and_hasher(lower, ObjectHasher::default());
+        for (k, v) in iter {
+            map.insert(k.to_string(), v.into());
+        }
+        Self::Object(Box::new(map))
     }
 }