use crate::DeserializeRevisioned;

use crate::Error;

use crate::Revisioned;

use crate::SerializeRevisioned;

use std::collections::BTreeMap;

use std::collections::BTreeSet;

use std::collections::BinaryHeap;

use std::collections::HashMap;

use std::collections::HashSet;

use std::hash::BuildHasher;

use std::hash::Hash;

impl<K: SerializeRevisioned + Eq + Hash, V: SerializeRevisioned, S: BuildHasher + Default>

  SerializeRevisioned for HashMap<K, V, S>

{

  #[inline]

  fn serialize_revisioned<W: std::io::Write>(&self, writer: &mut W) -> Result<(), Error> {

    self.len().serialize_revisioned(writer)?;

    for (k, v) in self.iter() {

      k.serialize_revisioned(writer)?;

      v.serialize_revisioned(writer)?;

    }

    Ok(())

  }

}

impl<K: DeserializeRevisioned + Eq + Hash, V: DeserializeRevisioned, S: BuildHasher + Default>

  DeserializeRevisioned for HashMap<K, V, S>

{

  #[inline]

  fn deserialize_revisioned<R: std::io::Read>(reader: &mut R) -> Result<Self, Error> {

    let len = usize::deserialize_revisioned(reader)?;

    let mut map = Self::with_capacity_and_hasher(len, S::default());

    for _ in 0..len {

      let k = K::deserialize_revisioned(reader)?;

      let v = V::deserialize_revisioned(reader)?;

      map.insert(k, v);

    }

    Ok(map)

  }

}

impl<K: Revisioned + Eq + Hash, V: Revisioned, S: BuildHasher + Default> Revisioned

  for HashMap<K, V, S>

{

  #[inline]

  fn revision() -> u16 {

    1

  }

}

impl<K: SerializeRevisioned + Ord, V: SerializeRevisioned> SerializeRevisioned for BTreeMap<K, V> {

  #[inline]

  fn serialize_revisioned<W: std::io::Write>(&self, writer: &mut W) -> Result<(), Error> {

    self.len().serialize_revisioned(writer)?;

    for (k, v) in self.iter() {

      k.serialize_revisioned(writer)?;

      v.serialize_revisioned(writer)?;

    }

    Ok(())

  }

<alloc::collections::btree::map::BTreeMap<alloc::string::String, surrealdb_core::val::Value> as revision::SerializeRevisioned>::serialize_revisioned::<alloc::vec::Vec<u8>>

Line

Count

Source

55

31.4k

  fn serialize_revisioned<W: std::io::Write>(&self, writer: &mut W) -> Result<(), Error> {

56

31.4k

    self.len().serialize_revisioned(writer)?;

57

31.4k

    for (k, v) in self.iter() {

58

5.39k

      k.serialize_revisioned(writer)?;

59

5.39k

      v.serialize_revisioned(writer)?;

60

    }

61

31.4k

    Ok(())

62

31.4k

  }

Unexecuted instantiation: <alloc::collections::btree::map::BTreeMap<alloc::string::String, surrealdb_core::expr::kind::Kind> as revision::SerializeRevisioned>::serialize_revisioned::<alloc::vec::Vec<u8>>

Unexecuted instantiation: <alloc::collections::btree::map::BTreeMap<_, _> as revision::SerializeRevisioned>::serialize_revisioned::<_>

}

impl<K: DeserializeRevisioned + Ord, V: DeserializeRevisioned> DeserializeRevisioned

  for BTreeMap<K, V>

{

  #[inline]

  fn deserialize_revisioned<R: std::io::Read>(reader: &mut R) -> Result<Self, Error> {

    let len = usize::deserialize_revisioned(reader)?;

    let mut map = Self::new();

    for _ in 0..len {

      let k = K::deserialize_revisioned(reader)?;

      let v = V::deserialize_revisioned(reader)?;

      map.insert(k, v);

    }

    Ok(map)

  }

<alloc::collections::btree::map::BTreeMap<alloc::string::String, surrealdb_core::val::Value> as revision::DeserializeRevisioned>::deserialize_revisioned::<&[u8]>

Line

Count

Source

69

727

  fn deserialize_revisioned<R: std::io::Read>(reader: &mut R) -> Result<Self, Error> {

70

727

    let len = usize::deserialize_revisioned(reader)?;

71

727

    let mut map = Self::new();

72

727

    for _ in 0..len {

73

1.25k

      let k = K::deserialize_revisioned(reader)?;

74

1.25k

      let v = V::deserialize_revisioned(reader)?;

75

1.25k

      map.insert(k, v);

76

    }

77

727

    Ok(map)

78

727

  }

Unexecuted instantiation: <alloc::collections::btree::map::BTreeMap<alloc::string::String, surrealdb_core::expr::kind::Kind> as revision::DeserializeRevisioned>::deserialize_revisioned::<&[u8]>

Unexecuted instantiation: <alloc::collections::btree::map::BTreeMap<_, _> as revision::DeserializeRevisioned>::deserialize_revisioned::<_>

}

impl<K: Revisioned + Ord, V: Revisioned> Revisioned for BTreeMap<K, V> {

  #[inline]

  fn revision() -> u16 {

    1

  }

}

impl<T: SerializeRevisioned + Eq + Hash, S: BuildHasher + Default> SerializeRevisioned

  for HashSet<T, S>

{

  #[inline]

  fn serialize_revisioned<W: std::io::Write>(&self, writer: &mut W) -> Result<(), Error> {

    self.len().serialize_revisioned(writer)?;

    for v in self.iter() {

      v.serialize_revisioned(writer)?;

    }

    Ok(())

  }

}

impl<T: DeserializeRevisioned + Eq + Hash, S: BuildHasher + Default> DeserializeRevisioned

  for HashSet<T, S>

{

  #[inline]

  fn deserialize_revisioned<R: std::io::Read>(reader: &mut R) -> Result<Self, Error> {

    let len = usize::deserialize_revisioned(reader)?;

    let mut set = Self::with_capacity_and_hasher(len, S::default());

    for _ in 0..len {

      let v = T::deserialize_revisioned(reader)?;

      set.insert(v);

    }

    Ok(set)

  }

}

impl<T: Revisioned + Eq + Hash, S: BuildHasher + Default> Revisioned for HashSet<T, S> {

  #[inline]

  fn revision() -> u16 {

    1

  }

}

impl<T: SerializeRevisioned + Ord> SerializeRevisioned for BTreeSet<T> {

  #[inline]

  fn serialize_revisioned<W: std::io::Write>(&self, writer: &mut W) -> Result<(), Error> {

    self.len().serialize_revisioned(writer)?;

    for v in self.iter() {

      v.serialize_revisioned(writer)?;

    }

    Ok(())

  }

Unexecuted instantiation: <alloc::collections::btree::set::BTreeSet<surrealdb_core::val::Value> as revision::SerializeRevisioned>::serialize_revisioned::<alloc::vec::Vec<u8>>

Unexecuted instantiation: <alloc::collections::btree::set::BTreeSet<_> as revision::SerializeRevisioned>::serialize_revisioned::<_>

}

impl<T: DeserializeRevisioned + Ord> DeserializeRevisioned for BTreeSet<T> {

  #[inline]

  fn deserialize_revisioned<R: std::io::Read>(reader: &mut R) -> Result<Self, Error> {

    let len = usize::deserialize_revisioned(reader)?;

    let mut set = Self::new();

    for _ in 0..len {

      let v = T::deserialize_revisioned(reader)?;

      set.insert(v);

    }

    Ok(set)

  }

Unexecuted instantiation: <alloc::collections::btree::set::BTreeSet<surrealdb_core::val::Value> as revision::DeserializeRevisioned>::deserialize_revisioned::<&[u8]>

Unexecuted instantiation: <alloc::collections::btree::set::BTreeSet<_> as revision::DeserializeRevisioned>::deserialize_revisioned::<_>

}

impl<T: Revisioned + Eq + Ord> Revisioned for BTreeSet<T> {

  #[inline]

  fn revision() -> u16 {

    1

  }

}

impl<T: SerializeRevisioned + Ord> SerializeRevisioned for BinaryHeap<T> {

  #[inline]

  fn serialize_revisioned<W: std::io::Write>(&self, writer: &mut W) -> Result<(), Error> {

    self.len().serialize_revisioned(writer)?;

    for v in self.iter() {

      v.serialize_revisioned(writer)?;

    }

    Ok(())

  }

}

impl<T: DeserializeRevisioned + Ord> DeserializeRevisioned for BinaryHeap<T> {

  #[inline]

  fn deserialize_revisioned<R: std::io::Read>(reader: &mut R) -> Result<Self, Error> {

    let len = usize::deserialize_revisioned(reader)?;

    let mut heap = Self::with_capacity(len);

    for _ in 0..len {

      let v = T::deserialize_revisioned(reader)?;

      heap.push(v);

    }

    Ok(heap)

  }

}

impl<T: Revisioned + Ord> Revisioned for BinaryHeap<T> {

  #[inline]

  fn revision() -> u16 {

    1

  }

}

#[cfg(test)]

mod tests {

  use super::*;

  #[test]

  fn test_hashmap() {

    let mut val: HashMap<String, Vec<f64>> = HashMap::new();

    val.insert("some".into(), vec![1.449, -5365.3849, 97194619.117391]);

    val.insert("test".into(), vec![-3917.195, 19461.3849, -365.195759]);

    let mut mem: Vec<u8> = vec![];

    val.serialize_revisioned(&mut mem).unwrap();

    assert_eq!(mem.len(), 61);

    let out = <HashMap<String, Vec<f64>> as DeserializeRevisioned>::deserialize_revisioned(

      &mut mem.as_slice(),

    )

    .unwrap();

    assert_eq!(val, out);

  }

  #[test]

  fn test_hashmap_nondefault_hasher() {

    #[derive(Default)]

    struct TestHasher(std::hash::RandomState);

    impl BuildHasher for TestHasher {

      type Hasher = <std::hash::RandomState as std::hash::BuildHasher>::Hasher;

      fn build_hasher(&self) -> Self::Hasher {

        self.0.build_hasher()

      }

    }

    let mut val: HashMap<String, Vec<f64>, TestHasher> =

      HashMap::with_hasher(Default::default());

    val.insert("some".into(), vec![1.449, -5365.3849, 97194619.117391]);

    val.insert("test".into(), vec![-3917.195, 19461.3849, -365.195759]);

    let mut mem: Vec<u8> = vec![];

    val.serialize_revisioned(&mut mem).unwrap();

    assert_eq!(mem.len(), 61);

    let out = <HashMap<String, Vec<f64>, TestHasher> as DeserializeRevisioned>::deserialize_revisioned(

      &mut mem.as_slice(),

    )

    .unwrap();

    assert_eq!(val, out);

  }

  #[test]

  fn test_btreemap() {

    let mut val: BTreeMap<String, Vec<f64>> = BTreeMap::new();

    val.insert("some".into(), vec![1.449, -5365.3849, 97194619.117391]);

    val.insert("test".into(), vec![-3917.195, 19461.3849, -365.195759]);

    let mut mem: Vec<u8> = vec![];

    val.serialize_revisioned(&mut mem).unwrap();

    assert_eq!(mem.len(), 61);

    let out = <BTreeMap<String, Vec<f64>> as DeserializeRevisioned>::deserialize_revisioned(

      &mut mem.as_slice(),

    )

    .unwrap();

    assert_eq!(val, out);

  }

  #[test]

  fn test_hashset() {

    let mut val: HashSet<String> = HashSet::new();

    val.insert("some".into());

    val.insert("test".into());

    let mut mem: Vec<u8> = vec![];

    val.serialize_revisioned(&mut mem).unwrap();

    assert_eq!(mem.len(), 11);

    let out =

      <HashSet<String> as DeserializeRevisioned>::deserialize_revisioned(&mut mem.as_slice())

        .unwrap();

    assert_eq!(val, out);

  }

  #[test]

  fn test_btreeset() {

    let mut val: BTreeSet<String> = BTreeSet::new();

    val.insert("some".into());

    val.insert("test".into());

    let mut mem: Vec<u8> = vec![];

    val.serialize_revisioned(&mut mem).unwrap();

    assert_eq!(mem.len(), 11);

    let out = <BTreeSet<String> as DeserializeRevisioned>::deserialize_revisioned(

      &mut mem.as_slice(),

    )

    .unwrap();

    assert_eq!(val, out);

  }

  #[test]

  fn test_binheap() {

    let mut val: BinaryHeap<String> = BinaryHeap::new();

    val.push("some".into());

    val.push("test".into());

    let mut mem: Vec<u8> = vec![];

    val.serialize_revisioned(&mut mem).unwrap();

    assert_eq!(mem.len(), 11);

    let out = <BinaryHeap<String> as DeserializeRevisioned>::deserialize_revisioned(

      &mut mem.as_slice(),

    )

    .unwrap();

    assert_eq!(val.into_sorted_vec(), out.into_sorted_vec());

  }

  #[test]

  fn test_hashset_string_empty() {

    let set: HashSet<String> = HashSet::new();

    let mut mem: Vec<u8> = vec![];

    set.serialize_revisioned(&mut mem).unwrap();

    let out: HashSet<String> = HashSet::deserialize_revisioned(&mut mem.as_slice()).unwrap();

    assert_eq!(set, out);

  }

  #[test]

  fn test_btreeset_string_empty() {

    let set: BTreeSet<String> = BTreeSet::new();

    let mut mem: Vec<u8> = vec![];

    set.serialize_revisioned(&mut mem).unwrap();

    let out: BTreeSet<String> = BTreeSet::deserialize_revisioned(&mut mem.as_slice()).unwrap();

    assert_eq!(set, out);

  }

  #[test]

  fn test_hashmap_string_empty() {

    let map: HashMap<String, i32> = HashMap::new();

    let mut mem: Vec<u8> = vec![];

    map.serialize_revisioned(&mut mem).unwrap();

    let out: HashMap<String, i32> =

      HashMap::deserialize_revisioned(&mut mem.as_slice()).unwrap();

    assert_eq!(map, out);

  }

  #[test]

  fn test_btreemap_string_empty() {

    let map: BTreeMap<String, i32> = BTreeMap::new();

    let mut mem: Vec<u8> = vec![];

    map.serialize_revisioned(&mut mem).unwrap();

    let out: BTreeMap<String, i32> =

      BTreeMap::deserialize_revisioned(&mut mem.as_slice()).unwrap();

    assert_eq!(map, out);

  }

  #[test]

  fn test_hashset_string_specialization() {

    let mut set = HashSet::new();

    set.insert("item1".to_string());

    set.insert("item2".to_string());

    set.insert("".to_string());

    set.insert("longer_item_with_underscores".to_string());

    set.insert("unicode_🚀🔥✨".to_string());

    let mut mem: Vec<u8> = vec![];

    set.serialize_revisioned(&mut mem).unwrap();

    let out: HashSet<String> = HashSet::deserialize_revisioned(&mut mem.as_slice()).unwrap();

    assert_eq!(set, out);

  }

  #[test]

  fn test_btreeset_string_specialization() {

    let mut set = BTreeSet::new();

    set.insert("item1".to_string());

    set.insert("item2".to_string());

    set.insert("".to_string());

    set.insert("longer_item_with_underscores".to_string());

    set.insert("unicode_🚀🔥✨".to_string());

    let mut mem: Vec<u8> = vec![];

    set.serialize_revisioned(&mut mem).unwrap();

    let out: BTreeSet<String> = BTreeSet::deserialize_revisioned(&mut mem.as_slice()).unwrap();

    assert_eq!(set, out);

  }

  #[test]

  fn test_hashset_string_large() {

    // Test larger HashSet to verify bulk operations and deterministic serialization

    let mut set = HashSet::new();

    for i in 0..50 {

      set.insert(format!("item_{}", i));

    }

    let mut mem: Vec<u8> = vec![];

    set.serialize_revisioned(&mut mem).unwrap();

    let out: HashSet<String> = HashSet::deserialize_revisioned(&mut mem.as_slice()).unwrap();

    assert_eq!(set, out);

  }

  #[test]

  fn test_btreeset_string_large() {

    // Test larger BTreeSet to verify bulk operations and ordering

    let mut set = BTreeSet::new();

    for i in 0..50 {

      set.insert(format!("item_{:03}", i)); // Zero-padded for consistent ordering

    }

    let mut mem: Vec<u8> = vec![];

    set.serialize_revisioned(&mut mem).unwrap();

    let out: BTreeSet<String> = BTreeSet::deserialize_revisioned(&mut mem.as_slice()).unwrap();

    assert_eq!(set, out);

  }

  // Tests specifically for the String-keyed specializations

  #[test]

  fn test_hashmap_string_specialization() {

    let mut map = HashMap::new();

    map.insert("key1".to_string(), 42i32);

    map.insert("key2".to_string(), -100i32);

    map.insert("".to_string(), 0i32);

    map.insert("longer_key_with_underscores".to_string(), 999i32);

    map.insert("unicode_🚀🔥✨".to_string(), -42i32);

    let mut mem: Vec<u8> = vec![];

    map.serialize_revisioned(&mut mem).unwrap();

    let out: HashMap<String, i32> =

      HashMap::deserialize_revisioned(&mut mem.as_slice()).unwrap();

    assert_eq!(map, out);

  }

  #[test]

  fn test_btreemap_string_specialization() {

    let mut map = BTreeMap::new();

    map.insert("key1".to_string(), 42i32);

    map.insert("key2".to_string(), -100i32);

    map.insert("".to_string(), 0i32);

    map.insert("longer_key_with_underscores".to_string(), 999i32);

    map.insert("unicode_🚀🔥✨".to_string(), -42i32);

    let mut mem: Vec<u8> = vec![];

    map.serialize_revisioned(&mut mem).unwrap();

    let out: BTreeMap<String, i32> =

      BTreeMap::deserialize_revisioned(&mut mem.as_slice()).unwrap();

    assert_eq!(map, out);

  }

}