feat(types): Argument coercion into HashSet/BTreeSet #493

Author: kakserpom

src/types/array/array_key.rs

@@ -92,12 +92,38 @@ impl<'a> From<&'a str> for ArrayKey<'a> {
     }
 }
 
+impl<'a> From<i32> for ArrayKey<'a> {
+    fn from(index: i32) -> ArrayKey<'a> {
+        ArrayKey::Long(i64::from(index))
+    }
+}
+
 impl<'a> From<i64> for ArrayKey<'a> {
     fn from(index: i64) -> ArrayKey<'a> {
         ArrayKey::Long(index)
     }
 }
 
+impl<'a> From<u64> for ArrayKey<'a> {
+    fn from(index: u64) -> ArrayKey<'a> {
+        if let Ok(index) = i64::try_from(index) {
+            ArrayKey::Long(index)
+        } else {
+            ArrayKey::String(index.to_string())
+        }
+    }
+}
+
+impl<'a> From<usize> for ArrayKey<'a> {
+    fn from(index: usize) -> ArrayKey<'a> {
+        if let Ok(index) = i64::try_from(index) {
+            ArrayKey::Long(index)
+        } else {
+            ArrayKey::String(index.to_string())
+        }
+    }
+}
+
 impl<'a> FromZval<'a> for ArrayKey<'_> {
     const TYPE: DataType = DataType::String;
 

src/types/array/conversions/btree_set.rs

@@ -0,0 +1,60 @@
+use super::super::ZendHashTable;
+use crate::{
+    boxed::ZBox,
+    convert::{FromZval, IntoZval},
+    error::{Error, Result},
+    flags::DataType,
+    types::Zval,
+};
+use std::collections::BTreeSet;
+use std::convert::TryFrom;
+
+impl<'a, V> TryFrom<&'a ZendHashTable> for BTreeSet<V>
+where
+    V: FromZval<'a> + Ord,
+{
+    type Error = Error;
+
+    fn try_from(value: &'a ZendHashTable) -> Result<Self> {
+        let mut set = Self::new();
+
+        for (_key, val) in value {
+            set.insert(V::from_zval(val).ok_or_else(|| Error::ZvalConversion(val.get_type()))?);
+        }
+
+        Ok(set)
+    }
+}
+
+impl<V> TryFrom<BTreeSet<V>> for ZBox<ZendHashTable>
+where
+    V: IntoZval,
+{
+    type Error = Error;
+
+    fn try_from(value: BTreeSet<V>) -> Result<Self> {
+        let mut set = ZendHashTable::with_capacity(
+            value.len().try_into().map_err(|_| Error::IntegerOverflow)?,
+        );
+
+        for (k, v) in value.into_iter().enumerate() {
+            set.insert(k, v)?;
+        }
+
+        Ok(set)
+    }
+}
+
+impl<V> IntoZval for BTreeSet<V>
+where
+    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(())
+    }
+}

src/types/array/conversions/hash_set.rs

@@ -0,0 +1,64 @@
+use super::super::ZendHashTable;
+use crate::{
+    boxed::ZBox,
+    convert::{FromZval, IntoZval},
+    error::{Error, Result},
+    flags::DataType,
+    types::Zval,
+};
+use std::collections::HashSet;
+use std::convert::TryFrom;
+use std::hash::{BuildHasher, Hash};
+
+impl<'a, V, H> TryFrom<&'a ZendHashTable> for HashSet<V, H>
+where
+    V: FromZval<'a> + Eq + Hash,
+    H: BuildHasher + Default,
+{
+    type Error = Error;
+
+    fn try_from(value: &'a ZendHashTable) -> Result<Self> {
+        let mut set = Self::with_capacity_and_hasher(value.len(), H::default());
+
+        for (_key, val) in value {
+            set.insert(V::from_zval(val).ok_or_else(|| Error::ZvalConversion(val.get_type()))?);
+        }
+
+        Ok(set)
+    }
+}
+
+impl<V, H> TryFrom<HashSet<V, H>> for ZBox<ZendHashTable>
+where
+    V: IntoZval,
+    H: BuildHasher,
+{
+    type Error = Error;
+
+    fn try_from(value: HashSet<V, H>) -> Result<Self> {
+        let mut ht = ZendHashTable::with_capacity(
+            value.len().try_into().map_err(|_| Error::IntegerOverflow)?,
+        );
+
+        for (k, v) in value.into_iter().enumerate() {
+            ht.insert(k, v)?;
+        }
+
+        Ok(ht)
+    }
+}
+
+impl<V, H> IntoZval for HashSet<V, H>
+where
+    V: IntoZval,
+    H: BuildHasher,
+{
+    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(())
+    }
+}

src/types/array/conversions/mod.rs

@@ -11,5 +11,7 @@
 //! - `Vec<T>` and `Vec<(K, V)>` ↔ `ZendHashTable` (via `vec` module)
 
 mod btree_map;
+mod btree_set;
 mod hash_map;
+mod hash_set;
 mod vec;