Implement SetVal for Vec and HashMap.

Author: jmjoy

phper/src/values.rs

@@ -8,7 +8,7 @@ use crate::{
     TypeError,
 };
 use std::{
-    mem::zeroed, os::raw::c_char, slice::from_raw_parts, str, str::Utf8Error,
+    collections::HashMap, mem::zeroed, os::raw::c_char, slice::from_raw_parts, str, str::Utf8Error,
     sync::atomic::Ordering,
 };
 
@@ -289,6 +289,38 @@ impl SetVal for String {
     }
 }
 
+impl<T: SetVal> SetVal for Vec<T> {
+    fn set_val(self, val: &mut Val) {
+        unsafe {
+            phper_array_init(val.as_mut_ptr());
+            for (k, v) in self.into_iter().enumerate() {
+                zend_hash_index_update(
+                    (*val.as_mut_ptr()).value.arr,
+                    k as u64,
+                    Val::new(v).as_mut_ptr(),
+                );
+            }
+        }
+    }
+}
+
+impl<K: AsRef<str>, V: SetVal> SetVal for HashMap<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 {

tests/integration/src/values.rs

@@ -1,4 +1,5 @@
 use phper::{arrays::Array, modules::Module, values::Val};
+use std::collections::HashMap;
 
 pub fn integrate(module: &mut Module) {
     integrate_returns(module);
@@ -50,6 +51,26 @@ fn integrate_returns(module: &mut Module) {
         integration_values_return_string,
         vec![],
     );
+    module.add_function(
+        "integration_values_return_i64_vec",
+        integration_values_return_i64_vec,
+        vec![],
+    );
+    module.add_function(
+        "integration_values_return_string_vec",
+        integration_values_return_string_vec,
+        vec![],
+    );
+    module.add_function(
+        "integration_values_return_i64_map",
+        integration_values_return_i64_map,
+        vec![],
+    );
+    module.add_function(
+        "integration_values_return_string_map",
+        integration_values_return_string_map,
+        vec![],
+    );
     module.add_function(
         "integration_values_return_array",
         integration_values_return_array,
@@ -91,6 +112,30 @@ fn integration_values_return_string(_: &mut [Val]) -> String {
     "foo".to_string()
 }
 
+fn integration_values_return_i64_vec(_: &mut [Val]) -> Vec<i64> {
+    vec![0, 1, 2]
+}
+
+fn integration_values_return_string_vec(_: &mut [Val]) -> Vec<String> {
+    vec!["a".to_string(), "b".to_string(), "c".to_string()]
+}
+
+fn integration_values_return_i64_map(_: &mut [Val]) -> HashMap<&'static str, i64> {
+    let mut map = HashMap::new();
+    map.insert("a", 0);
+    map.insert("b", 1);
+    map.insert("c", 2);
+    map
+}
+
+fn integration_values_return_string_map(_: &mut [Val]) -> HashMap<String, String> {
+    let mut map = HashMap::new();
+    map.insert("a".to_string(), "x".to_string());
+    map.insert("b".to_string(), "y".to_string());
+    map.insert("c".to_string(), "z".to_string());
+    map
+}
+
 fn integration_values_return_array(_: &mut [Val]) -> Array {
     let mut arr = Array::new();
     arr.insert("a", Val::new(1));

tests/integration/tests/php/values.php

@@ -11,4 +11,8 @@
 assert_eq(integration_values_return_f64(), 64.0);
 assert_eq(integration_values_return_str(), "foo");
 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(integration_values_return_array(), ["a" => 1, "b" => "foo"]);