Refactor owned object to EBox alias

Author: jmjoy

.gitignore

@@ -3,3 +3,4 @@
 /.cargo
 /vendor
 core
+compile_commands.json

examples/complex/src/lib.rs

@@ -9,7 +9,8 @@
 // See the Mulan PSL v2 for more details.
 
 use phper::{
-    arrays::ZArray,
+    alloc::EBox,
+    arrays::ZArr,
     classes::{ClassEntity, Visibility},
     functions::Argument,
     ini::{Policy, ini_get},
@@ -61,7 +62,7 @@ pub fn get_module() -> Module {
         .argument(Argument::new("name"));
     module.add_function("complex_throw_exception", throw_exception);
     module.add_function("complex_get_all_ini", |_: &mut [ZVal]| {
-        let mut arr = ZArray::new();
+        let mut arr = EBox::<ZArr>::new();
 
         let complex_enable = ZVal::from(ini_get::<bool>("complex.enable"));
         arr.insert("complex.enable", complex_enable);

examples/http-client/src/response.rs

@@ -10,7 +10,8 @@
 
 use crate::errors::HttpClientError;
 use phper::{
-    arrays::{InsertKey, ZArray},
+    alloc::EBox,
+    arrays::{InsertKey, ZArr},
     classes::{ClassEntity, StateClass, Visibility},
     values::ZVal,
 };
@@ -50,16 +51,19 @@ pub fn make_response_class() -> ClassEntity<Option<Response>> {
                 .ok_or_else(|| HttpClientError::ResponseAfterRead {
                     method_name: "headers".to_owned(),
                 })?;
-        let headers_map = response
-            .headers()
-            .iter()
-            .fold(ZArray::new(), |mut acc, (key, value)| {
-                let arr = acc.entry(key.as_str()).or_insert(ZVal::from(ZArray::new()));
-                arr.as_mut_z_arr()
-                    .unwrap()
-                    .insert(InsertKey::NextIndex, ZVal::from(value.as_bytes()));
-                acc
-            });
+        let headers_map =
+            response
+                .headers()
+                .iter()
+                .fold(EBox::<ZArr>::new(), |mut acc, (key, value)| {
+                    let arr = acc
+                        .entry(key.as_str())
+                        .or_insert(ZVal::from(EBox::<ZArr>::new()));
+                    arr.as_mut_z_arr()
+                        .unwrap()
+                        .insert(InsertKey::NextIndex, ZVal::from(value.as_bytes()));
+                    acc
+                });
         Ok::<_, HttpClientError>(headers_map)
     });
 

examples/http-server/src/request.rs

@@ -9,7 +9,8 @@
 // See the Mulan PSL v2 for more details.
 
 use phper::{
-    arrays::ZArray,
+    alloc::EBox,
+    arrays::ZArr,
     classes::{ClassEntity, StateClass, Visibility},
 };
 use std::convert::Infallible;
@@ -31,7 +32,7 @@ pub fn make_request_class() -> ClassEntity<()> {
     // Register the constructor method with public visibility, initialize the
     // headers with empty array.
     class.add_method("__construct", Visibility::Public, |this, _arguments| {
-        this.set_property("headers", ZArray::new());
+        this.set_property("headers", EBox::<ZArr>::new());
         Ok::<_, Infallible>(())
     });
 

phper-alloc/src/lib.rs

@@ -12,85 +12,7 @@
 #![warn(clippy::dbg_macro, clippy::print_stdout)]
 #![doc = include_str!("../README.md")]
 
-#[macro_use]
-mod macros;
-
-use phper_sys::*;
-use std::{
-    borrow::Borrow,
-    mem::{ManuallyDrop, size_of},
-    ops::{Deref, DerefMut},
-};
-
-/// The Box which use php `emalloc` and `efree` to manage memory.
-///
-/// TODO Now feature `allocator_api` is still unstable, implement myself, use
-/// Box<T, Alloc> later.
-pub struct EBox<T> {
-    ptr: *mut T,
-}
-
-impl<T> EBox<T> {
-    /// Allocates heap memory using `emalloc` then places `x` into it.
-    ///
-    /// # Panic
-    ///
-    /// Panic if `size_of::<T>()` equals zero.
-    #[allow(clippy::useless_conversion)]
-    pub fn new(x: T) -> Self {
-        unsafe {
-            assert_ne!(size_of::<T>(), 0);
-            let ptr: *mut T = phper_emalloc(size_of::<T>().try_into().unwrap()).cast();
-            // TODO Deal with ptr is zero, when memory limit is reached.
-            ptr.write(x);
-            Self { ptr }
-        }
-    }
-
-    /// Constructs from a raw pointer.
-    ///
-    /// # Safety
-    ///
-    /// Make sure the pointer is from `into_raw`, or created from `emalloc`.
-    pub unsafe fn from_raw(raw: *mut T) -> Self {
-        Self { ptr: raw }
-    }
-
-    /// Consumes and returning a wrapped raw pointer.
-    ///
-    /// Will leak memory.
-    pub fn into_raw(b: EBox<T>) -> *mut T {
-        ManuallyDrop::new(b).ptr
-    }
-
-    /// Consumes the `EBox`, returning the wrapped value.
-    pub fn into_inner(self) -> T {
-        unsafe { self.ptr.read() }
-    }
-}
-
-impl<T> Deref for EBox<T> {
-    type Target = T;
-
-    fn deref(&self) -> &Self::Target {
-        unsafe { self.ptr.as_ref().unwrap() }
-    }
-}
-
-impl<T> DerefMut for EBox<T> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        unsafe { self.ptr.as_mut().unwrap() }
-    }
-}
-
-impl<T> Drop for EBox<T> {
-    fn drop(&mut self) {
-        unsafe {
-            self.ptr.drop_in_place();
-            phper_efree(self.ptr.cast());
-        }
-    }
-}
+use std::borrow::Borrow;
 
 /// Duplicate an object without deep copy, but to only add the refcount, for php
 /// refcount struct.

phper-alloc/src/macros.rs

@@ -0,0 +1,88 @@
+//! Memory allocation utilities and boxed types for PHP values.
+
+pub use phper_alloc::{RefClone, ToRefOwned};
+use std::{
+    borrow::{Borrow, BorrowMut},
+    fmt::{self},
+    mem::ManuallyDrop,
+    ops::{Deref, DerefMut},
+};
+
+/// A smart pointer for PHP values allocated in the Zend Engine memory.
+///
+/// `EBox<T>` provides owned access to values allocated in PHP's memory
+/// management system. It automatically handles deallocation when dropped,
+/// ensuring proper cleanup of PHP resources.
+pub struct EBox<T> {
+    ptr: *mut T,
+}
+
+impl<T> EBox<T> {
+    /// Constructs from a raw pointer.
+    ///
+    /// # Safety
+    ///
+    /// Make sure the pointer is from `into_raw`, or created from `emalloc`.
+    pub unsafe fn from_raw(raw: *mut T) -> Self {
+        Self { ptr: raw }
+    }
+
+    /// Consumes and returning a wrapped raw pointer.
+    ///
+    /// Will leak memory.
+    pub fn into_raw(b: EBox<T>) -> *mut T {
+        ManuallyDrop::new(b).ptr
+    }
+}
+
+impl<T: fmt::Debug> fmt::Debug for EBox<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(&**self, f)
+    }
+}
+
+impl<T> Deref for EBox<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        unsafe { self.ptr.as_ref().unwrap() }
+    }
+}
+
+impl<T> DerefMut for EBox<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        unsafe { self.ptr.as_mut().unwrap() }
+    }
+}
+
+impl<T> Drop for EBox<T> {
+    fn drop(&mut self) {
+        unsafe {
+            self.ptr.drop_in_place();
+        }
+    }
+}
+
+impl<T> Borrow<T> for EBox<T> {
+    fn borrow(&self) -> &T {
+        unsafe { self.ptr.as_ref().unwrap() }
+    }
+}
+
+impl<T> BorrowMut<T> for EBox<T> {
+    fn borrow_mut(&mut self) -> &mut T {
+        unsafe { self.ptr.as_mut().unwrap() }
+    }
+}
+
+impl<T> AsRef<T> for EBox<T> {
+    fn as_ref(&self) -> &T {
+        unsafe { self.ptr.as_ref().unwrap() }
+    }
+}
+
+impl<T> AsMut<T> for EBox<T> {
+    fn as_mut(&mut self) -> &mut T {
+        unsafe { self.ptr.as_mut().unwrap() }
+    }
+}