Back out "Revert D91571261"

Summary:
Original commit changeset: 541d141ecbf6

Original Phabricator Diff: D91780392

Reviewed By: christolliday

Differential Revision: D91840579

fbshipit-source-id: 274541f23606a8c3afd9b928d2d94d7e3663d587

Author: cjhopman

pagable/BUCK

@@ -16,6 +16,7 @@ rust_library(
         "fbsource//third-party/rust:dashmap",
         "fbsource//third-party/rust:either",
         "fbsource//third-party/rust:erased-serde",
+        "fbsource//third-party/rust:indexmap",
         "fbsource//third-party/rust:num-bigint",
         "fbsource//third-party/rust:parking_lot",
         "fbsource//third-party/rust:postcard",

pagable/Cargo.toml

@@ -16,6 +16,7 @@ dupe = { workspace = true }
 either = { workspace = true }
 erased-serde = { workspace = true }
 gazebo = { workspace = true }
+indexmap = { workspace = true }
 num-bigint = { workspace = true }
 pagable_derive = { path = "../pagable_derive" }
 parking_lot = { workspace = true }

pagable/src/impls/collections.rs

@@ -135,6 +135,38 @@ impl<'de, K: Ord + PagableDeserialize<'de>, V: PagableDeserialize<'de>> PagableD
     }
 }
 
+impl<K: PagableSerialize, V: PagableSerialize, H> PagableSerialize for indexmap::IndexMap<K, V, H> {
+    fn pagable_serialize(&self, serializer: &mut dyn PagableSerializer) -> crate::Result<()> {
+        usize::serialize(&self.len(), serializer.serde())?;
+        for (k, v) in self {
+            k.pagable_serialize(serializer)?;
+            v.pagable_serialize(serializer)?;
+        }
+        Ok(())
+    }
+}
+
+impl<
+    'de,
+    K: std::hash::Hash + Eq + PagableDeserialize<'de>,
+    V: PagableDeserialize<'de>,
+    H: std::default::Default + std::hash::BuildHasher,
+> PagableDeserialize<'de> for indexmap::IndexMap<K, V, H>
+{
+    fn pagable_deserialize<D: PagableDeserializer<'de> + ?Sized>(
+        deserializer: &mut D,
+    ) -> crate::Result<Self> {
+        let items = usize::deserialize(deserializer.serde())?;
+        let mut map: indexmap::IndexMap<K, V, H> = indexmap::IndexMap::default();
+        for _ in 0..items {
+            let k = K::pagable_deserialize(deserializer)?;
+            let v = V::pagable_deserialize(deserializer)?;
+            map.insert(k, v);
+        }
+        Ok(map)
+    }
+}
+
 impl<V: PagableSerialize> PagableSerialize for std::collections::BTreeSet<V> {
     fn pagable_serialize(&self, serializer: &mut dyn PagableSerializer) -> crate::Result<()> {
         usize::serialize(&self.len(), serializer.serde())?;
@@ -160,6 +192,31 @@ impl<'de, V: Ord + PagableDeserialize<'de>> PagableDeserialize<'de>
     }
 }
 
+impl<V: PagableSerialize> PagableSerialize for indexmap::IndexSet<V> {
+    fn pagable_serialize(&self, serializer: &mut dyn PagableSerializer) -> crate::Result<()> {
+        usize::serialize(&self.len(), serializer.serde())?;
+        for v in self {
+            v.pagable_serialize(serializer)?;
+        }
+        Ok(())
+    }
+}
+impl<'de, V: std::hash::Hash + Eq + PagableDeserialize<'de>> PagableDeserialize<'de>
+    for indexmap::IndexSet<V>
+{
+    fn pagable_deserialize<D: PagableDeserializer<'de> + ?Sized>(
+        deserializer: &mut D,
+    ) -> crate::Result<Self> {
+        let items = usize::deserialize(deserializer.serde())?;
+        let mut set = indexmap::IndexSet::new();
+        for _ in 0..items {
+            let v = V::pagable_deserialize(deserializer)?;
+            set.insert(v);
+        }
+        Ok(set)
+    }
+}
+
 impl<T: PagableSerialize> PagableSerialize for Vec<T> {
     fn pagable_serialize(&self, serializer: &mut dyn PagableSerializer) -> crate::Result<()> {
         usize::serialize(&self.len(), serializer.serde())?;
@@ -349,4 +406,44 @@ mod tests {
         assert_eq!(set, restored);
         Ok(())
     }
+
+    #[test]
+    fn test_indexmap_roundtrip() -> crate::Result<()> {
+        use indexmap::IndexMap;
+
+        let mut map: IndexMap<String, i32> = IndexMap::new();
+        map.insert("one".to_owned(), 1);
+        map.insert("two".to_owned(), 2);
+        map.insert("three".to_owned(), 3);
+
+        let mut serializer = TestingSerializer::new();
+        map.pagable_serialize(&mut serializer)?;
+        let bytes = serializer.finish();
+
+        let mut deserializer = TestingDeserializer::new(&bytes);
+        let restored: IndexMap<String, i32> = IndexMap::pagable_deserialize(&mut deserializer)?;
+
+        assert_eq!(map, restored);
+        Ok(())
+    }
+
+    #[test]
+    fn test_indexset_roundtrip() -> crate::Result<()> {
+        use indexmap::IndexSet;
+
+        let mut set: IndexSet<String> = IndexSet::new();
+        set.insert("one".to_owned());
+        set.insert("two".to_owned());
+        set.insert("three".to_owned());
+
+        let mut serializer = TestingSerializer::new();
+        set.pagable_serialize(&mut serializer)?;
+        let bytes = serializer.finish();
+
+        let mut deserializer = TestingDeserializer::new(&bytes);
+        let restored: IndexSet<String> = IndexSet::pagable_deserialize(&mut deserializer)?;
+
+        assert_eq!(set, restored);
+        Ok(())
+    }
 }