Implement SetVal for Indexmap.

Author: jmjoy

phper/Cargo.toml

@@ -15,6 +15,7 @@ keywords = ["php", "binding", "extension"]
 [dependencies]
 anyhow = "1.0.40"
 clap = "3.0.0-beta.2"
+indexmap = "1.6.2"
 num-derive = "0.3"
 num-traits = "0.2"
 once_cell = "1.7.2"

phper/src/values.rs

@@ -7,6 +7,7 @@ use crate::{
     utils::ensure_end_with_zero,
     TypeError,
 };
+use indexmap::map::IndexMap;
 use std::{
     collections::HashMap, mem::zeroed, os::raw::c_char, slice::from_raw_parts, str, str::Utf8Error,
     sync::atomic::Ordering,
@@ -227,6 +228,10 @@ impl Val {
     }
 }
 
+/// The trait for setting the value of [Val], mainly as the return value of
+/// [crate::functions::Function] and [crate::functions::Method], and initializer of [Val].
+///
+/// TODO Fix the possibility of leak memory.
 pub trait SetVal {
     fn set_val(self, val: &mut Val);
 }
@@ -304,6 +309,8 @@ impl<T: SetVal> SetVal for Vec<T> {
     }
 }
 
+/// Setting the val to an array, Because of the feature of [std::collections::HashMap], the item
+/// order of array is not guarantee.
 impl<K: AsRef<str>, V: SetVal> SetVal for HashMap<K, V> {
     fn set_val(self, val: &mut Val) {
         unsafe {
@@ -321,6 +328,24 @@ impl<K: AsRef<str>, V: SetVal> SetVal for HashMap<K, V> {
     }
 }
 
+/// Setting the val to an array, which preserves item order.
+impl<K: AsRef<str>, V: SetVal> SetVal for IndexMap<K, V> {
+    fn set_val(self, val: &mut Val) {
+        unsafe {
+            phper_array_init(val.as_mut_ptr());
+            for (k, v) in self {
+                let k = k.as_ref();
+                zend_hash_str_update(
+                    (*val.as_mut_ptr()).value.arr,
+                    k.as_ptr().cast(),
+                    k.len(),
+                    Val::new(v).as_mut_ptr(),
+                );
+            }
+        }
+    }
+}
+
 impl SetVal for Array {
     fn set_val(mut self, val: &mut Val) {
         unsafe {
@@ -330,12 +355,6 @@ impl SetVal for Array {
     }
 }
 
-extern "C" fn array_copy_ctor(zv: *mut zval) {
-    let val = unsafe { Val::from_mut(zv) };
-    let other = unsafe { Val::from_mut(zv) };
-    val.deep_copy(other).expect("deep copy failed");
-}
-
 impl<T: SetVal> SetVal for Option<T> {
     fn set_val(self, val: &mut Val) {
         match self {

tests/integration/Cargo.toml

@@ -12,6 +12,7 @@ license = "Unlicense"
 crate-type = ["cdylib"]
 
 [dependencies]
+indexmap = "1.6.2"
 phper = { version = "0.2.0-alpha.2", path = "../../phper" }
 
 [dev-dependencies]

tests/integration/src/values.rs

@@ -1,3 +1,4 @@
+use indexmap::map::IndexMap;
 use phper::{arrays::Array, modules::Module, values::Val};
 use std::collections::HashMap;
 
@@ -71,11 +72,26 @@ fn integrate_returns(module: &mut Module) {
         integration_values_return_string_map,
         vec![],
     );
+    module.add_function(
+        "integration_values_return_i64_index_map",
+        integration_values_return_i64_index_map,
+        vec![],
+    );
     module.add_function(
         "integration_values_return_array",
         integration_values_return_array,
         vec![],
     );
+    module.add_function(
+        "integration_values_return_option_i64_some",
+        integration_values_return_option_i64_some,
+        vec![],
+    );
+    module.add_function(
+        "integration_values_return_option_i64_none",
+        integration_values_return_option_i64_none,
+        vec![],
+    );
 }
 
 fn integration_values_return_null(_: &mut [Val]) {}
@@ -136,9 +152,25 @@ fn integration_values_return_string_map(_: &mut [Val]) -> HashMap<String, String
     map
 }
 
+fn integration_values_return_i64_index_map(_: &mut [Val]) -> IndexMap<&'static str, i64> {
+    let mut map = IndexMap::new();
+    map.insert("a", 0);
+    map.insert("b", 1);
+    map.insert("c", 2);
+    map
+}
+
 fn integration_values_return_array(_: &mut [Val]) -> Array {
     let mut arr = Array::new();
     arr.insert("a", Val::new(1));
     arr.insert("b", Val::new("foo"));
     arr
 }
+
+fn integration_values_return_option_i64_some(_: &mut [Val]) -> Option<i64> {
+    Some(64)
+}
+
+fn integration_values_return_option_i64_none(_: &mut [Val]) -> Option<i64> {
+    None
+}

tests/integration/tests/php/_common.php

@@ -9,3 +9,8 @@ function assert_eq($left, $right) {
         throw new Exception(sprintf("left != right,\n left: %s,\n right: %s", var_export($left, true), var_export($right, true)));
     }
 }
+
+function array_ksort($array) {
+    ksort($array);
+    return $array;
+}

tests/integration/tests/php/values.php

@@ -13,6 +13,9 @@
 assert_eq(integration_values_return_string(), "foo");
 assert_eq(integration_values_return_i64_vec(), [0, 1, 2]);
 assert_eq(integration_values_return_string_vec(), ["a", "b", "c"]);
-assert_eq(integration_values_return_i64_map(), ["a" => 0, "b" => 1, "c" => 2]);
-assert_eq(integration_values_return_string_map(), ["a" => "x", "b" => "y", "c" => "z"]);
+assert_eq(array_ksort(integration_values_return_i64_map()), ["a" => 0, "b" => 1, "c" => 2]);
+assert_eq(array_ksort(integration_values_return_string_map()), ["a" => "x", "b" => "y", "c" => "z"]);
+assert_eq(integration_values_return_i64_index_map(), ["a" => 0, "b" => 1, "c" => 2]);
 assert_eq(integration_values_return_array(), ["a" => 1, "b" => "foo"]);
+assert_eq(integration_values_return_option_i64_some(), 64);
+assert_eq(integration_values_return_option_i64_none(), null);