Store T of Object, but the code will be removed next.

jmjoy · jmjoy · commit 43410c816be4 · 2021-05-11T12:16:42.000+08:00
diff --git a/examples/hello/src/lib.rs b/examples/hello/src/lib.rs
@@ -62,7 +62,7 @@ pub fn get_module() -> Module {
     );
 
     // register classes
-    let mut foo_class = DynamicClass::new();
+    let mut foo_class = DynamicClass::new("FooClass");
     foo_class.add_property("foo", "100".to_string());
     foo_class.add_method(
         "getFoo",
@@ -80,7 +80,7 @@ pub fn get_module() -> Module {
         },
         vec![Argument::by_val("foo")],
     );
-    module.add_class("FooClass", foo_class);
+    module.add_class(foo_class);
 
     module
 }
diff --git a/examples/http-client/Cargo.toml b/examples/http-client/Cargo.toml
@@ -12,8 +12,10 @@ license = "Unlicense"
 crate-type = ["cdylib"]
 
 [dependencies]
+anyhow = "1.0.40"
 phper = { version = "0.2.0-alpha.2", path = "../../phper" }
 reqwest = { version = "0.11.3", features = ["blocking"] }
+thiserror = "1.0.24"
 
 [dev-dependencies]
 phper-test = { version = "0.2.0-alpha.2", path = "../../phper-test" }
diff --git a/examples/http-client/src/client.rs b/examples/http-client/src/client.rs
@@ -0,0 +1,22 @@
+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";
+
+pub fn make_client_class() -> DynamicClass<Client> {
+    let mut http_client_class = DynamicClass::new_with_constructor(HTTP_CLIENT_CLASS_NAME, |_| {
+        let client = ClientBuilder::new()
+            .timeout(Duration::from_secs(15))
+            .build()?;
+        Ok::<_, HttpClientError>(client)
+    });
+
+    http_client_class.add_method("get", |this, arguments| {
+    }, vec![Argument::by_val("url")]);
+
+    http_client_class
+}
diff --git a/examples/http-client/src/errors.rs b/examples/http-client/src/errors.rs
@@ -0,0 +1,22 @@
+use phper::errors::Throwable;
+use phper::classes::{ClassEntry, DynamicClass};
+use phper::errors::Error::ClassNotFound;
+
+const EXCEPTION_CLASS_NAME: &'static str = "HttpClient\\HttpClientException";
+
+#[derive(thiserror::Error, Debug)]
+pub enum HttpClientError {
+    #[error(transparent)]
+    Reqwest(#[from] reqwest::Error),
+}
+
+impl Throwable for HttpClientError {
+    fn class_entry(&self) -> &ClassEntry {
+        ClassEntry::from_globals(EXCEPTION_CLASS_NAME).unwrap()
+    }
+}
+
+pub fn make_exception_class() -> DynamicClass<()> {
+    let exception_class = DynamicClass::new(EXCEPTION_CLASS_NAME);
+    exception_class
+}
diff --git a/examples/http-client/src/http_client.rs b/examples/http-client/src/http_client.rs
diff --git a/examples/http-client/src/lib.rs b/examples/http-client/src/lib.rs
@@ -1,6 +1,11 @@
+use anyhow::Context;
 use phper::{classes::DynamicClass, modules::Module, php_get_module};
+use crate::client::make_client_class;
 
-pub mod http_client;
+pub mod client;
+pub mod errors;
+pub mod request;
+pub mod response;
 
 #[php_get_module]
 pub fn get_module() -> Module {
@@ -10,9 +15,7 @@ pub fn get_module() -> Module {
         env!("CARGO_PKG_AUTHORS"),
     );
 
-    // let client = HttpClient::new();
-    let client_class: DynamicClass<()> = DynamicClass::new();
-    module.add_class("HttpClient", client_class);
+    module.add_class(make_client_class());
 
     module
 }
diff --git a/examples/http-client/src/request.rs b/examples/http-client/src/request.rs
diff --git a/examples/http-client/src/response.rs b/examples/http-client/src/response.rs
diff --git a/phper-sys/php_wrapper.c b/phper-sys/php_wrapper.c
@@ -128,4 +128,8 @@ zend_string *phper_get_function_or_method_name(const zend_function *func) {
 
 void phper_zval_ptr_dtor(zval *pDest) {
     ZVAL_PTR_DTOR(pDest);
+}
+
+size_t phper_zend_object_properties_size(zend_class_entry *ce) {
+    return zend_object_properties_size(ce);
 }
diff --git a/phper-sys/php_wrapper.h b/phper-sys/php_wrapper.h
@@ -44,4 +44,6 @@ zend_string *phper_get_function_or_method_name(const zend_function *func);
 
 void phper_zval_ptr_dtor(zval *pDest);
 
+size_t phper_zend_object_properties_size(zend_class_entry *ce);
+
 #endif //PHPER_PHP_WRAPPER_H
diff --git a/phper/src/classes.rs b/phper/src/classes.rs
@@ -1,7 +1,7 @@
 //! Apis relate to [crate::sys::zend_class_entry].
 
 use crate::{
-    errors::ClassNotFoundError,
+    errors::{ClassNotFoundError, Throwable},
     functions::{Argument, FunctionEntity, FunctionEntry, Method},
     objects::Object,
     sys::*,
@@ -10,6 +10,7 @@ use crate::{
 };
 use once_cell::sync::OnceCell;
 use std::{
+    convert::Infallible,
     marker::PhantomData,
     mem::zeroed,
     os::raw::c_int,
@@ -18,21 +19,42 @@ use std::{
 };
 
 pub trait Classifiable {
+    fn class_name(&self) -> &str;
     fn methods(&mut self) -> &mut [FunctionEntity];
     fn properties(&mut self) -> &mut [PropertyEntity];
     fn parent(&self) -> Option<&str>;
 }
 
 pub struct DynamicClass<T: Send + Sync + 'static> {
+    class_name: String,
+    data_constructor: Box<dyn FnOnce(&mut Object<T>) -> Result<T, Box<dyn Throwable>>>,
     pub(crate) method_entities: Vec<FunctionEntity>,
     pub(crate) property_entities: Vec<PropertyEntity>,
     pub(crate) parent: Option<String>,
     _p: PhantomData<T>,
 }
 
+impl DynamicClass<()> {
+    pub fn new(class_name: impl ToString) -> Self {
+        Self::new_with_constructor(class_name, |_| Ok::<_, Infallible>(()))
+    }
+}
+
+impl<T: Default + Send + Sync + 'static> DynamicClass<T> {
+    pub fn new_with_default(class_name: impl ToString) -> Self {
+        Self::new_with_constructor(class_name, |_| Ok::<_, Infallible>(Default::default()))
+    }
+}
+
 impl<T: Send + Sync + 'static> DynamicClass<T> {
-    pub fn new() -> Self {
+    pub fn new_with_constructor<F, E>(class_name: impl ToString, data_constructor: F) -> Self
+    where
+        F: FnOnce(&mut Object<T>) -> Result<T, E> + 'static,
+        E: Throwable + 'static,
+    {
         Self {
+            class_name: class_name.to_string(),
+            data_constructor: Box::new(|o| data_constructor(o).map_err(|e| Box::new(e) as _)),
             method_entities: Vec::new(),
             property_entities: Vec::new(),
             parent: None,
@@ -64,6 +86,10 @@ impl<T: Send + Sync + 'static> DynamicClass<T> {
 }
 
 impl<T: Send + Sync> Classifiable for DynamicClass<T> {
+    fn class_name(&self) -> &str {
+        &self.class_name
+    }
+
     fn methods(&mut self) -> &mut [FunctionEntity] {
         &mut self.method_entities
     }
@@ -126,9 +152,9 @@ pub struct ClassEntity {
 }
 
 impl ClassEntity {
-    pub(crate) unsafe fn new(name: impl ToString, class: impl Classifiable + 'static) -> Self {
+    pub(crate) unsafe fn new(class: impl Classifiable + 'static) -> Self {
         Self {
-            name: name.to_string(),
+            name: class.class_name().to_string(),
             entry: AtomicPtr::new(null_mut()),
             class: Box::new(class),
             function_entries: Default::default(),
diff --git a/phper/src/errors.rs b/phper/src/errors.rs
@@ -2,7 +2,7 @@
 
 use crate::{classes::ClassEntry, sys::*, Error::Other};
 use anyhow::anyhow;
-use std::{error, ffi::FromBytesWithNulError, io, str::Utf8Error};
+use std::{convert::Infallible, error, ffi::FromBytesWithNulError, io, str::Utf8Error};
 
 /// PHP Throwable, can cause throwing an exception when setting to [crate::values::Val].
 pub trait Throwable: error::Error {
@@ -17,6 +17,12 @@ pub trait Throwable: error::Error {
     }
 }
 
+impl Throwable for Infallible {
+    fn class_entry(&self) -> &ClassEntry {
+        unreachable!()
+    }
+}
+
 /// Type of [std::result::Result]<T, [crate::Error]>.
 pub type Result<T> = std::result::Result<T, self::Error>;
 
diff --git a/phper/src/modules.rs b/phper/src/modules.rs
@@ -35,7 +35,7 @@ unsafe extern "C" fn module_startup(r#type: c_int, module_number: c_int) -> c_in
     let args = ModuleArgs::new(r#type, module_number);
     write_global_module(|module| {
         args.register_ini_entries(module.ini_entries());
-        for (_, class_entity) in &mut module.class_entities {
+        for class_entity in &mut module.class_entities {
             class_entity.init();
             class_entity.declare_properties();
         }
@@ -92,7 +92,7 @@ pub struct Module {
     request_init: Option<Box<dyn Fn(ModuleArgs) -> bool + Send + Sync>>,
     request_shutdown: Option<Box<dyn Fn(ModuleArgs) -> bool + Send + Sync>>,
     function_entities: Vec<FunctionEntity>,
-    pub(crate) class_entities: HashMap<String, ClassEntity>,
+    class_entities: Vec<ClassEntity>,
 }
 
 impl Module {
@@ -216,9 +216,8 @@ impl Module {
         ));
     }
 
-    pub fn add_class(&mut self, name: impl ToString, class: impl Classifiable + 'static) {
-        self.class_entities
-            .insert(name.to_string(), unsafe { ClassEntity::new(name, class) });
+    pub fn add_class(&mut self, class: impl Classifiable + 'static) {
+        self.class_entities.push(unsafe { ClassEntity::new(class) });
     }
 
     pub unsafe fn module_entry(self) -> *const zend_module_entry {
diff --git a/phper/src/objects.rs b/phper/src/objects.rs
@@ -8,6 +8,11 @@ use crate::{
     values::Val,
 };
 use std::{marker::PhantomData, ptr::null_mut};
+use std::mem::size_of;
+use std::slice::{from_raw_parts_mut, from_raw_parts};
+use std::hash::Hasher;
+use std::io::Write;
+use std::ffi::c_void;
 
 /// Wrapper of [crate::sys::zend_object].
 #[repr(transparent)]
@@ -17,18 +22,33 @@ pub struct Object<T> {
 }
 
 impl<T> Object<T> {
-    pub fn new(class_entry: &ClassEntry) -> EBox<Self> {
+    pub fn new(class_entry: &ClassEntry, constructor: impl FnOnce() -> T) -> EBox<Self> {
+        // Like `zend_objects_new`, but `emalloc` more size to store `T`.
         unsafe {
-            let ptr = zend_objects_new(class_entry.as_ptr() as *mut _);
-            EBox::from_raw(ptr.cast())
+            let ce = class_entry.as_ptr() as *mut _;
+            let ori_len = size_of::<zend_object>() + phper_zend_object_properties_size(ce);
+            let total_len = ori_len + size_of::<*mut T>();
+            let object = _emalloc(total_len).cast();
+            zend_object_std_init(object, ce);
+            (*object).handlers = &std_object_handlers;
+
+            let t = Box::new(constructor());
+            let ptr = Box::into_raw(t) as usize;
+
+            let data = from_raw_parts_mut(object as *mut u8, total_len);
+            let mut data = &mut data[ori_len..];
+            data.write_all(&ptr.to_le_bytes());
+
+            EBox::from_raw(object.cast())
         }
     }
 
     pub fn new_by_class_name(
         class_name: impl AsRef<str>,
+        constructor: impl FnOnce() -> T,
     ) -> Result<EBox<Self>, ClassNotFoundError> {
         let class_entry = ClassEntry::from_globals(class_name)?;
-        Ok(Self::new(class_entry))
+        Ok(Self::new(class_entry, constructor))
     }
 
     pub unsafe fn from_mut_ptr<'a>(ptr: *mut zend_object) -> &'a mut Self {
@@ -127,14 +147,14 @@ impl<T> Object<T> {
 
 impl Object<()> {
     pub fn new_by_std_class() -> EBox<Self> {
-        Self::new_by_class_name("stdclass").unwrap()
+        Self::new_by_class_name("stdclass", || ()).unwrap()
     }
 }
 
 impl<T> EAllocatable for Object<T> {
     fn free(ptr: *mut Self) {
         unsafe {
-            zend_objects_destroy_object(ptr.cast());
+            hack_zend_objects_destroy_object(ptr.cast());
         }
     }
 }
@@ -144,3 +164,20 @@ impl<T> Drop for Object<T> {
         unreachable!("Allocation on the stack is not allowed")
     }
 }
+
+unsafe extern "C" fn hack_zend_objects_destroy_object(object: *mut zend_object) {
+    let ce = (*object).ce;
+    let ori_len = size_of::<zend_object>() + phper_zend_object_properties_size(ce);
+    let total_len = ori_len + size_of::<*mut c_void>();
+
+    let data = from_raw_parts(object as *mut u8, total_len);
+    let data = &data[ori_len..];
+
+    let mut buf = [0u8; 8];
+    (&mut buf[..]).write_all(data);
+    let ptr = usize::from_le_bytes(buf) as *mut c_void;
+
+    // TODO why to find the type of `T` ???
+
+    zend_objects_destroy_object(object);
+}

Original file line number	Diff line number	Diff line change
`@@ -128,4 +128,8 @@ zend_string phper_get_function_or_method_name(const zend_function func) {`
`128`	`128`
`129`	`129`	`void phper_zval_ptr_dtor(zval *pDest) {`
`130`	`130`	`ZVAL_PTR_DTOR(pDest);`
	`131`	`+}`
	`132`	`+`
	`133`	`+size_t phper_zend_object_properties_size(zend_class_entry *ce) {`
	`134`	`+ return zend_object_properties_size(ce);`
`131`	`135`	`}`