feat(array): FromZval/IntoZval impls for BTreeMap

Author: kakserpom

src/builders/ini.rs

@@ -218,7 +218,8 @@ impl AsRef<str> for IniBuilder {
     }
 }
 
-// Ensure the C buffer is properly deinitialized when the builder goes out of scope.
+// Ensure the C buffer is properly deinitialized when the builder goes out of
+// scope.
 impl Drop for IniBuilder {
     fn drop(&mut self) {
         if !self.value.is_null() {

src/builders/sapi.rs

@@ -166,7 +166,8 @@ impl SapiBuilder {
     ///
     /// # Parameters
     ///
-    /// * `func` - The function to be called when PHP gets an environment variable.
+    /// * `func` - The function to be called when PHP gets an environment
+    ///   variable.
     pub fn getenv_function(mut self, func: SapiGetEnvFunc) -> Self {
         self.module.getenv = Some(func);
         self
@@ -216,7 +217,8 @@ impl SapiBuilder {
     ///
     /// # Parameters
     ///
-    /// * `func` - The function to be called when PHP registers server variables.
+    /// * `func` - The function to be called when PHP registers server
+    ///   variables.
     pub fn register_server_variables_function(
         mut self,
         func: SapiRegisterServerVariablesFunc,
@@ -450,8 +452,9 @@ mod test {
     extern "C" fn test_getenv(_name: *const c_char, _name_length: usize) -> *mut c_char {
         ptr::null_mut()
     }
-    // Note: C-variadic functions are unstable in Rust, so we can't test this properly
-    // extern "C" fn test_sapi_error(_type: c_int, _error_msg: *const c_char, _args: ...) {}
+    // Note: C-variadic functions are unstable in Rust, so we can't test this
+    // properly extern "C" fn test_sapi_error(_type: c_int, _error_msg: *const
+    // c_char, _args: ...) {}
     extern "C" fn test_send_header(_header: *mut sapi_header_struct, _server_context: *mut c_void) {
     }
     extern "C" fn test_read_post(_buffer: *mut c_char, _length: usize) -> usize {
@@ -591,9 +594,10 @@ mod test {
         );
     }
 
-    // Note: Cannot test sapi_error_function because C-variadic functions are unstable in Rust
-    // The sapi_error field accepts a function with variadic arguments which cannot be
-    // created in stable Rust. However, the builder method itself works correctly.
+    // Note: Cannot test sapi_error_function because C-variadic functions are
+    // unstable in Rust The sapi_error field accepts a function with variadic
+    // arguments which cannot be created in stable Rust. However, the builder
+    // method itself works correctly.
 
     #[test]
     fn test_send_header_function() {

src/embed/mod.rs

@@ -287,8 +287,9 @@ mod tests {
     #[test]
     fn test_eval_bailout() {
         Embed::run(|| {
-            // TODO: For PHP 8.5, this needs to be replaced, as `E_USER_ERROR` is deprecated.
-            //       Currently, this seems to still be the best way to trigger a bailout.
+            // TODO: For PHP 8.5, this needs to be replaced, as `E_USER_ERROR` is
+            // deprecated.       Currently, this seems to still be the best way
+            // to trigger a bailout.
             let result = Embed::eval("trigger_error(\"Fatal error\", E_USER_ERROR);");
 
             assert!(result.is_err());

src/types/array.rs

@@ -1,16 +1,6 @@
 //! Represents an array in PHP. As all arrays in PHP are associative arrays,
 //! they are represented by hash tables.
 
-use std::{
-    collections::HashMap,
-    convert::{TryFrom, TryInto},
-    ffi::CString,
-    fmt::{Debug, Display},
-    iter::FromIterator,
-    ptr,
-    str::FromStr,
-};
-
 use crate::{
     boxed::{ZBox, ZBoxable},
     convert::{FromZval, IntoZval},
@@ -27,6 +17,15 @@ use crate::{
     flags::DataType,
     types::Zval,
 };
+use std::{
+    collections::{BTreeMap, HashMap},
+    convert::{TryFrom, TryInto},
+    ffi::CString,
+    fmt::{Debug, Display},
+    iter::FromIterator,
+    ptr,
+    str::FromStr,
+};
 
 /// A PHP hashtable.
 ///
@@ -1165,6 +1164,76 @@ where
     }
 }
 
+///////////////////////////////////////////
+// BTreeMap
+///////////////////////////////////////////
+
+impl<'a, V> TryFrom<&'a ZendHashTable> for BTreeMap<String, V>
+where
+    V: FromZval<'a>,
+{
+    type Error = Error;
+
+    fn try_from(value: &'a ZendHashTable) -> Result<Self> {
+        let mut hm = BTreeMap::new();
+
+        for (key, val) in value {
+            hm.insert(
+                key.to_string(),
+                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())
+    }
+}
+
 ///////////////////////////////////////////
 // Vec
 ///////////////////////////////////////////