Add state for Class and Object.

Author: jmjoy

examples/http-client/src/client.rs

@@ -1,9 +1,8 @@
+use crate::errors::HttpClientError;
+use anyhow::Context;
+use phper::{classes::DynamicClass, functions::Argument};
 use reqwest::blocking::{Client, ClientBuilder};
 use std::time::Duration;
-use phper::classes::DynamicClass;
-use anyhow::Context;
-use crate::errors::HttpClientError;
-use phper::functions::Argument;
 
 const HTTP_CLIENT_CLASS_NAME: &'static str = "HttpClient\\HttpClient";
 
@@ -15,8 +14,17 @@ pub fn make_client_class() -> DynamicClass<Client> {
         Ok::<_, HttpClientError>(client)
     });
 
-    http_client_class.add_method("get", |this, arguments| {
-    }, vec![Argument::by_val("url")]);
+    http_client_class.add_method(
+        "get",
+        |this, arguments| {
+            let url = arguments[0].as_string()?;
+            let client = this.as_state();
+            let response = client.get(url).send().unwrap();
+            let body = response.text().unwrap();
+            Ok::<_, phper::Error>(body)
+        },
+        vec![Argument::by_val("url")],
+    );
 
     http_client_class
 }

examples/http-client/src/errors.rs

@@ -1,6 +1,7 @@
-use phper::errors::Throwable;
-use phper::classes::{ClassEntry, DynamicClass};
-use phper::errors::Error::ClassNotFound;
+use phper::{
+    classes::{ClassEntry, DynamicClass},
+    errors::{Error::ClassNotFound, Throwable},
+};
 
 const EXCEPTION_CLASS_NAME: &'static str = "HttpClient\\HttpClientException";
 
@@ -19,4 +20,4 @@ impl Throwable for HttpClientError {
 pub fn make_exception_class() -> DynamicClass<()> {
     let exception_class = DynamicClass::new(EXCEPTION_CLASS_NAME);
     exception_class
-}
+}

examples/http-client/src/lib.rs

@@ -1,6 +1,6 @@
+use crate::client::make_client_class;
 use anyhow::Context;
 use phper::{classes::DynamicClass, modules::Module, php_get_module};
-use crate::client::make_client_class;
 
 pub mod client;
 pub mod errors;

examples/http-client/src/request.rs

@@ -0,0 +1 @@
+

examples/http-client/src/response.rs

@@ -0,0 +1 @@
+

examples/http-client/tests/php/test.php

@@ -7,4 +7,5 @@
 error_reporting(E_ALL);
 
 $client = new HttpClient();
-var_dump($client);
+$ip = $client->get("http://httpbin.org/ip");
+var_dump($ip);

phper/src/classes.rs

@@ -1,17 +1,18 @@
 //! Apis relate to [crate::sys::zend_class_entry].
 
 use std::{
+    any::Any,
+    collections::HashMap,
     convert::Infallible,
     marker::PhantomData,
-    mem::zeroed,
+    mem::{size_of, zeroed, ManuallyDrop},
     os::raw::c_int,
     ptr::null_mut,
-    sync::atomic::{AtomicPtr, Ordering},
+    sync::{
+        atomic::{AtomicPtr, Ordering},
+        Arc,
+    },
 };
-use std::any::Any;
-use std::collections::HashMap;
-use std::mem::{ManuallyDrop, size_of};
-use std::sync::Arc;
 
 use dashmap::DashMap;
 use once_cell::sync::OnceCell;
@@ -21,12 +22,12 @@ use phper_alloc::EBox;
 use crate::{
     errors::{ClassNotFoundError, Throwable},
     functions::{Argument, FunctionEntity, FunctionEntry, Method},
-    objects::Object,
+    objects::{ExtendObject, Object},
     sys::*,
     utils::ensure_end_with_zero,
     values::{SetVal, Val},
 };
-use crate::objects::ExtendObject;
+use std::rc::Rc;
 
 pub trait Classifiable {
     fn state_constructor(&self) -> Box<StateConstructor<Box<dyn Any>>>;
@@ -36,15 +37,11 @@ pub trait Classifiable {
     fn parent(&self) -> Option<&str>;
 }
 
-// TODO Let pointer address as a field of Object isn't safe, will choose another plan later.
-pub(crate) const DATA_CONSTRUCTOR_PROPERTY_NAME: &'static str = "__very_important_do_not_modify_data_constructor__";
-pub(crate) const DATA_PROPERTY_NAME: &'static str = "__very_important_do_not_modify_data__";
-
 pub type StateConstructor<T> = dyn Fn() -> Result<T, Box<dyn Throwable>> + Send + Sync;
 
 pub struct DynamicClass<T: Send + Sync + 'static> {
     class_name: String,
-    // data_constructor: Box<DataConstructor<T>>,
+    state_constructor: Arc<StateConstructor<T>>,
     pub(crate) method_entities: Vec<FunctionEntity>,
     pub(crate) property_entities: Vec<PropertyEntity>,
     pub(crate) parent: Option<String>,
@@ -64,14 +61,14 @@ impl<T: Default + Send + Sync + 'static> DynamicClass<T> {
 }
 
 impl<T: Send + Sync + 'static> DynamicClass<T> {
-    pub fn new_with_constructor<F, E>(class_name: impl ToString, data_constructor: F) -> Self
+    pub fn new_with_constructor<F, E>(class_name: impl ToString, state_constructor: F) -> Self
     where
         F: Fn() -> Result<T, E> + Send + Sync + 'static,
         E: Throwable + 'static,
     {
         let mut dyn_class = Self {
             class_name: class_name.to_string(),
-            // data_constructor: Box::new(|| data_constructor().map_err(|e| Box::new(e) as _)),
+            state_constructor: Arc::new(move || state_constructor().map_err(|e| Box::new(e) as _)),
             method_entities: Vec::new(),
             property_entities: Vec::new(),
             parent: None,
@@ -109,7 +106,8 @@ impl<T: Send + Sync + 'static> DynamicClass<T> {
 
 impl<T: Send + Sync> Classifiable for DynamicClass<T> {
     fn state_constructor(&self) -> Box<StateConstructor<Box<dyn Any>>> {
-        Box::new(|| Ok(Box::new(())))
+        let sc = self.state_constructor.clone();
+        Box::new(move || sc().map(|x| Box::new(x) as _))
     }
 
     fn class_name(&self) -> &str {
@@ -294,17 +292,18 @@ fn get_object_handlers() -> &'static zend_object_handlers {
     OBJECT_HANDLERS.get_or_init(|| unsafe {
         let mut handlers = std_object_handlers;
         handlers.offset = ExtendObject::offset() as c_int;
-        handlers.free_obj = Some(destroy_object);
+        handlers.free_obj = Some(free_object);
         handlers
     })
 }
 
 unsafe extern "C" fn create_object(ce: *mut zend_class_entry) -> *mut zend_object {
     // Alloc more memory size to store state data.
-    let extend_object: *mut ExtendObject = phper_zend_object_alloc(size_of::<ExtendObject>(), ce).cast();
+    let extend_object: *mut ExtendObject =
+        phper_zend_object_alloc(size_of::<ExtendObject>(), ce).cast();
 
     // Common initialize process.
-    let object = &mut (*extend_object).object;
+    let object = ExtendObject::as_mut_object(extend_object);
     zend_object_std_init(object, ce);
     object_properties_init(object, ce);
     rebuild_object_properties(object);
@@ -322,12 +321,16 @@ unsafe extern "C" fn create_object(ce: *mut zend_class_entry) -> *mut zend_objec
     // Call the state constructor.
     // TODO Throw an exception rather than unwrap.
     let data: Box<dyn Any> = state_constructor().unwrap();
-    (*extend_object).state = ManuallyDrop::new(data);
+    *ExtendObject::as_mut_state(extend_object) = ManuallyDrop::new(data);
 
     object
 }
 
-unsafe extern "C" fn destroy_object(object: *mut zend_object) {
+unsafe extern "C" fn free_object(object: *mut zend_object) {
+    // Drop the state.
+    let extend_object = ExtendObject::fetch_ptr(object);
+    ExtendObject::drop_state(extend_object);
+
     // Original destroy call.
     zend_object_std_dtor(object);
 }

phper/src/functions.rs

@@ -56,7 +56,7 @@ where
     }
 }
 
-impl<F, R, T> Callable for Method<F, R, T>
+impl<F, R, T: 'static> Callable for Method<F, R, T>
 where
     F: Fn(&mut Object<T>, &mut [Val]) -> R + Send + Sync,
     R: SetVal,
@@ -229,6 +229,7 @@ unsafe extern "C" fn invoke(execute_data: *mut zend_execute_data, return_value:
     let handler = handler.as_ref().expect("handler is null");
 
     // Check arguments count.
+    // TODO Use `zend_argument_count_error` rather than just throw an exception.
     let num_args = execute_data.num_args() as usize;
     let required_num_args = execute_data.common_required_num_args() as usize;
     if num_args < required_num_args {

phper/src/objects.rs

@@ -1,12 +1,15 @@
 //! Apis relate to [crate::sys::zend_object].
 
-use std::{marker::PhantomData, ptr::null_mut};
-use std::any::Any;
-use std::ffi::c_void;
-use std::hash::Hasher;
-use std::io::Write;
-use std::mem::{size_of, ManuallyDrop};
-use std::slice::{from_raw_parts, from_raw_parts_mut};
+use std::{
+    any::Any,
+    ffi::c_void,
+    hash::Hasher,
+    io::Write,
+    marker::PhantomData,
+    mem::{size_of, ManuallyDrop},
+    ptr::null_mut,
+    slice::{from_raw_parts, from_raw_parts_mut},
+};
 
 use crate::{
     alloc::{EAllocatable, EBox},
@@ -15,15 +18,16 @@ use crate::{
     sys::*,
     values::Val,
 };
+use std::ops::Deref;
 
 /// Wrapper of [crate::sys::zend_object].
 #[repr(transparent)]
-pub struct Object<T> {
+pub struct Object<T: 'static> {
     inner: zend_object,
     _p: PhantomData<T>,
 }
 
-impl<T> Object<T> {
+impl<T: 'static> Object<T> {
     pub fn new(class_entry: &ClassEntry) -> EBox<Self> {
         unsafe {
             let ptr = zend_objects_new(class_entry.as_ptr() as *mut _);
@@ -50,6 +54,16 @@ impl<T> Object<T> {
         &mut self.inner
     }
 
+    pub fn as_state(&self) -> &T {
+        let eo = ExtendObject::fetch(&self.inner);
+        eo.state.downcast_ref().unwrap()
+    }
+
+    pub fn as_mut_state(&mut self) -> &mut T {
+        let eo = ExtendObject::fetch_mut(&mut self.inner);
+        eo.state.downcast_mut().unwrap()
+    }
+
     pub fn get_property(&self, name: impl AsRef<str>) -> &Val {
         let name = name.as_ref();
 
@@ -152,16 +166,50 @@ impl<T> Drop for Object<T> {
     }
 }
 
+pub(crate) type ManuallyDropState = ManuallyDrop<Box<dyn Any>>;
+
 /// The Object contains `zend_object` and the user defined state data.
 #[repr(C)]
-pub struct ExtendObject {
-    pub(crate) state: ManuallyDrop<Box<dyn Any>>,
-    pub(crate) object: zend_object,
+pub(crate) struct ExtendObject {
+    state: ManuallyDropState,
+    object: zend_object,
 }
 
 impl ExtendObject {
     pub(crate) const fn offset() -> usize {
-       size_of::<ManuallyDrop<Box<dyn Any>>>()
+        size_of::<ManuallyDropState>()
+    }
+
+    pub(crate) fn fetch(object: &zend_object) -> &Self {
+        unsafe {
+            (((object as *const _ as usize) - ExtendObject::offset()) as *const Self)
+                .as_ref()
+                .unwrap()
+        }
     }
-}
 
+    pub(crate) fn fetch_mut(object: &mut zend_object) -> &mut Self {
+        unsafe {
+            (((object as *mut _ as usize) - ExtendObject::offset()) as *mut Self)
+                .as_mut()
+                .unwrap()
+        }
+    }
+
+    pub(crate) fn fetch_ptr(object: *mut zend_object) -> *mut Self {
+        (object as usize - ExtendObject::offset()) as *mut Self
+    }
+
+    pub(crate) unsafe fn drop_state(this: *mut Self) {
+        let state = &mut (*this).state;
+        ManuallyDrop::drop(state);
+    }
+
+    pub(crate) unsafe fn as_mut_state<'a>(this: *mut Self) -> &'a mut ManuallyDropState {
+        &mut (*this).state
+    }
+
+    pub(crate) unsafe fn as_mut_object<'a>(this: *mut Self) -> &'a mut zend_object {
+        &mut (*this).object
+    }
+}

phper/src/values.rs

@@ -181,7 +181,7 @@ impl Val {
         }
     }
 
-    pub fn as_object<T>(&self) -> crate::Result<&Object<T>> {
+    pub fn as_object(&self) -> crate::Result<&Object<()>> {
         if self.get_type().is_object() {
             unsafe {
                 let ptr = self.inner.value.obj;