feat(array): BTreeMap/HashMap conversion

Author: kakserpom

src/types/array/array_key.rs

@@ -24,19 +24,19 @@ impl From<String> for ArrayKey<'_> {
 impl TryFrom<ArrayKey<'_>> for String {
     type Error = Error;
 
-    fn try_from(value: ArrayKey<'_>) -> std::result::Result<Self, Self::Error> {
+    fn try_from(value: ArrayKey<'_>) -> Result<Self, Self::Error> {
         match value {
             ArrayKey::String(s) => Ok(s),
             ArrayKey::Str(s) => Ok(s.to_string()),
-            ArrayKey::Long(_) => Err(Error::InvalidProperty),
+            ArrayKey::Long(l) => Ok(l.to_string()),
         }
     }
 }
 
 impl TryFrom<ArrayKey<'_>> for i64 {
     type Error = Error;
 
-    fn try_from(value: ArrayKey<'_>) -> std::result::Result<Self, Self::Error> {
+    fn try_from(value: ArrayKey<'_>) -> Result<Self, Self::Error> {
         match value {
             ArrayKey::Long(i) => Ok(i),
             ArrayKey::String(s) => s.parse::<i64>().map_err(|_| Error::InvalidProperty),

src/types/array/conversions/btree_map.rs

@@ -0,0 +1,78 @@
+use std::{collections::BTreeMap, convert::TryFrom};
+
+use super::super::ZendHashTable;
+use crate::types::ArrayKey;
+use crate::{
+    boxed::ZBox,
+    convert::{FromZval, IntoZval},
+    error::{Error, Result},
+    flags::DataType,
+    types::Zval,
+};
+
+impl<'a, K, V> TryFrom<&'a ZendHashTable> for BTreeMap<K, V>
+where
+    K: TryFrom<ArrayKey<'a>, Error = Error> + Ord,
+    V: FromZval<'a>,
+{
+    type Error = Error;
+
+    fn try_from(value: &'a ZendHashTable) -> Result<Self> {
+        let mut hm = Self::new();
+
+        for (key, val) in value {
+            hm.insert(
+                key.try_into()?,
+                V::from_zval(val).ok_or_else(|| Error::ZvalConversion(val.get_type()))?,
+            );
+        }
+
+        Ok(hm)
+    }
+}
+
+impl<K, V> TryFrom<BTreeMap<K, V>> for ZBox<ZendHashTable>
+where
+    K: AsRef<str>,
+    V: IntoZval,
+{
+    type Error = Error;
+
+    fn try_from(value: BTreeMap<K, V>) -> Result<Self> {
+        let mut ht = ZendHashTable::with_capacity(
+            value.len().try_into().map_err(|_| Error::IntegerOverflow)?,
+        );
+
+        for (k, v) in value {
+            ht.insert(k.as_ref(), v)?;
+        }
+
+        Ok(ht)
+    }
+}
+
+impl<K, V> IntoZval for BTreeMap<K, V>
+where
+    K: AsRef<str>,
+    V: IntoZval,
+{
+    const TYPE: DataType = DataType::Array;
+    const NULLABLE: bool = false;
+
+    fn set_zval(self, zv: &mut Zval, _: bool) -> Result<()> {
+        let arr = self.try_into()?;
+        zv.set_hashtable(arr);
+        Ok(())
+    }
+}
+
+impl<'a, T> FromZval<'a> for BTreeMap<String, T>
+where
+    T: FromZval<'a>,
+{
+    const TYPE: DataType = DataType::Array;
+
+    fn from_zval(zval: &'a Zval) -> Option<Self> {
+        zval.array().and_then(|arr| arr.try_into().ok())
+    }
+}

src/types/array/conversions/hash_map.rs

@@ -1,29 +1,29 @@
-use std::{collections::HashMap, convert::TryFrom};
-
+use super::super::ZendHashTable;
+use crate::types::ArrayKey;
 use crate::{
     boxed::ZBox,
     convert::{FromZval, IntoZval},
     error::{Error, Result},
     flags::DataType,
     types::Zval,
 };
+use std::hash::{BuildHasher, Hash};
+use std::{collections::HashMap, convert::TryFrom};
 
-use super::super::ZendHashTable;
-
-// TODO: Generalize hasher
-#[allow(clippy::implicit_hasher)]
-impl<'a, V> TryFrom<&'a ZendHashTable> for HashMap<String, V>
+impl<'a, K, V, H> TryFrom<&'a ZendHashTable> for HashMap<K, V, H>
 where
+    K: TryFrom<ArrayKey<'a>, Error = Error> + Eq + Hash,
     V: FromZval<'a>,
+    H: BuildHasher + Default,
 {
     type Error = Error;
 
     fn try_from(value: &'a ZendHashTable) -> Result<Self> {
-        let mut hm = HashMap::with_capacity(value.len());
+        let mut hm = Self::with_capacity_and_hasher(value.len(), H::default());
 
         for (key, val) in value {
             hm.insert(
-                key.to_string(),
+                key.try_into()?,
                 V::from_zval(val).ok_or_else(|| Error::ZvalConversion(val.get_type()))?,
             );
         }
@@ -32,14 +32,15 @@ where
     }
 }
 
-impl<K, V> TryFrom<HashMap<K, V>> for ZBox<ZendHashTable>
+impl<K, V, H> TryFrom<HashMap<K, V, H>> for ZBox<ZendHashTable>
 where
     K: AsRef<str>,
     V: IntoZval,
+    H: BuildHasher,
 {
     type Error = Error;
 
-    fn try_from(value: HashMap<K, V>) -> Result<Self> {
+    fn try_from(value: HashMap<K, V, H>) -> Result<Self> {
         let mut ht = ZendHashTable::with_capacity(
             value.len().try_into().map_err(|_| Error::IntegerOverflow)?,
         );
@@ -52,12 +53,11 @@ where
     }
 }
 
-// TODO: Generalize hasher
-#[allow(clippy::implicit_hasher)]
-impl<K, V> IntoZval for HashMap<K, V>
+impl<K, V, H> IntoZval for HashMap<K, V, H>
 where
     K: AsRef<str>,
     V: IntoZval,
+    H: BuildHasher,
 {
     const TYPE: DataType = DataType::Array;
     const NULLABLE: bool = false;
@@ -69,11 +69,10 @@ where
     }
 }
 
-// TODO: Generalize hasher
-#[allow(clippy::implicit_hasher)]
-impl<'a, T> FromZval<'a> for HashMap<String, T>
+impl<'a, V, H> FromZval<'a> for HashMap<String, V, H>
 where
-    T: FromZval<'a>,
+    V: FromZval<'a>,
+    H: BuildHasher + Default,
 {
     const TYPE: DataType = DataType::Array;
 

src/types/array/conversions/mod.rs

@@ -6,8 +6,10 @@
 //!
 //! ## Supported Collections
 //!
+//! - `BTreeMap<K, V>` ↔ `ZendHashTable` (via `btree_map` module)
 //! - `HashMap<K, V>` ↔ `ZendHashTable` (via `hash_map` module)
 //! - `Vec<T>` and `Vec<(K, V)>` ↔ `ZendHashTable` (via `vec` module)
 
+mod btree_map;
 mod hash_map;
 mod vec;