Add StateClass and StateObject, fix construct. (#119)

jmjoy · web-flow · commit 3405afda54b9 · 2023-04-27T22:53:43.000+08:00
diff --git a/examples/http-server/src/request.rs b/examples/http-server/src/request.rs
@@ -10,17 +10,22 @@
 
 use phper::{
     arrays::ZArray,
-    classes::{ClassEntity, ClassEntry, Visibility},
-    objects::ZObject,
+    classes::{ClassEntity, StateClass, Visibility},
+    objects::StateObject,
 };
 use std::convert::Infallible;
 
 pub const HTTP_REQUEST_CLASS_NAME: &str = "HttpServer\\HttpRequest";
 
+pub static HTTP_REQUEST_CLASS: StateClass<()> = StateClass::new();
+
 /// Register the class `HttpServer\HttpRequest` by `ClassEntity`.
 pub fn make_request_class() -> ClassEntity<()> {
     let mut class = ClassEntity::new(HTTP_REQUEST_CLASS_NAME);
 
+    // The state class will be initialized after class registered.
+    class.bind(&HTTP_REQUEST_CLASS);
+
     // Register the http headers field with public visibility.
     class.add_property("headers", Visibility::Public, ());
 
@@ -38,6 +43,6 @@ pub fn make_request_class() -> ClassEntity<()> {
 }
 
 /// New the object with class `HttpServer\HttpRequest`.
-pub fn new_request_object() -> phper::Result<ZObject> {
-    ClassEntry::from_globals(HTTP_REQUEST_CLASS_NAME)?.new_object([])
+pub fn new_request_object() -> phper::Result<StateObject<()>> {
+    HTTP_REQUEST_CLASS.new_object([])
 }
diff --git a/examples/http-server/src/response.rs b/examples/http-server/src/response.rs
@@ -14,18 +14,23 @@ use axum::{
     http::{HeaderName, HeaderValue, Response},
 };
 use phper::{
-    classes::{ClassEntity, ClassEntry, Visibility},
+    classes::{ClassEntity, StateClass, Visibility},
     functions::Argument,
-    objects::ZObject,
+    objects::StateObject,
 };
 
 pub const HTTP_RESPONSE_CLASS_NAME: &str = "HttpServer\\HttpResponse";
 
+pub static HTTP_RESPONSE_CLASS: StateClass<Response<Body>> = StateClass::new();
+
 /// Register the class `HttpServer\HttpResponse` by `ClassEntity`, with the
 /// inner state `Response<Body>`.
 pub fn make_response_class() -> ClassEntity<Response<Body>> {
     let mut class = ClassEntity::new_with_default_state_constructor(HTTP_RESPONSE_CLASS_NAME);
 
+    // The state class will be initialized after class registered.
+    class.bind(&HTTP_RESPONSE_CLASS);
+
     // Register the header method with public visibility, accept `name` and `value`
     // parameters.
     class
@@ -59,6 +64,6 @@ pub fn make_response_class() -> ClassEntity<Response<Body>> {
 }
 
 /// New the object with class `HttpServer\HttpResponse`.
-pub fn new_response_object() -> phper::Result<ZObject> {
-    ClassEntry::from_globals(HTTP_RESPONSE_CLASS_NAME)?.new_object([])
+pub fn new_response_object() -> phper::Result<StateObject<Response<Body>>> {
+    HTTP_RESPONSE_CLASS.new_object([])
 }
diff --git a/phper-sys/php_wrapper.c b/phper-sys/php_wrapper.c
@@ -83,6 +83,10 @@ uint32_t phper_z_addref_p(zval *zv) {
     return Z_ADDREF_P(zv);
 }
 
+zend_function *phper_z_func_p(const zval *zv) {
+    return Z_FUNC_P(zv);
+}
+
 void *phper_z_ptr_p(const zval *zv) {
     return Z_PTR_P(zv);
 }
diff --git a/phper/src/classes.rs b/phper/src/classes.rs
@@ -14,7 +14,7 @@ use crate::{
     arrays::ZArr,
     errors::{ClassNotFoundError, InitializeObjectError, Throwable},
     functions::{Function, FunctionEntry, Method, MethodEntity},
-    objects::{StateObj, StateObject, ZObj, ZObject},
+    objects::{CStateObject, StateObj, StateObject, ZObj, ZObject},
     strings::ZStr,
     sys::*,
     types::Scalar,
@@ -34,6 +34,7 @@ use std::{
     os::raw::c_int,
     ptr::null_mut,
     rc::Rc,
+    sync::atomic::{AtomicPtr, Ordering},
 };
 
 /// Predefined interface `Iterator`.
@@ -136,6 +137,9 @@ impl ClassEntry {
     }
 
     /// Create the object from class and call `__construct` with arguments.
+    ///
+    /// If the `__construct` is private, or protected and the called scope isn't
+    /// parent class, it will throw PHP Error.
     pub fn new_object(&self, arguments: impl AsMut<[ZVal]>) -> crate::Result<ZObject> {
         let mut object = self.init_object()?;
         object.call_construct(arguments)?;
@@ -199,6 +203,77 @@ fn find_global_class_entry_ptr(name: impl AsRef<str>) -> *mut zend_class_entry {
     }
 }
 
+/// The [StateClass] holds [zend_class_entry](crate::sys::zend_class_entry) and
+/// inner state, always as the static variable, and then be bind to
+/// [ClassEntity].
+///
+/// When the class registered (module initialized), the [StateClass] will be
+/// initialized, so you can use the [StateClass] to new stateful object, etc.
+///
+/// So, You shouldn't use [StateClass] in `module_init` stage, because it hasn't
+/// initialized.
+///
+/// # Examples
+///
+/// ```rust
+/// use phper::classes::{ClassEntity, StateClass};
+///
+/// pub static FOO_CLASS: StateClass<FooState> = StateClass::new();
+///
+/// #[derive(Default)]
+/// pub struct FooState;
+///
+/// fn make_foo_class() -> ClassEntity<FooState> {
+///     let mut class = ClassEntity::new_with_default_state_constructor("Foo");
+///     class.bind(&FOO_CLASS);
+///     class
+/// }
+/// ```
+#[repr(transparent)]
+pub struct StateClass<T> {
+    inner: AtomicPtr<zend_class_entry>,
+    _p: PhantomData<T>,
+}
+
+impl<T> StateClass<T> {
+    /// Create empty [StateClass], with null
+    /// [zend_class_entry](crate::sys::zend_class_entry).
+    pub const fn new() -> Self {
+        Self {
+            inner: AtomicPtr::new(null_mut()),
+            _p: PhantomData,
+        }
+    }
+
+    fn bind(&'static self, ptr: *mut zend_class_entry) {
+        self.inner.store(ptr, Ordering::Relaxed);
+    }
+
+    /// Converts to class entry.
+    pub fn as_class_entry(&'static self) -> &'static ClassEntry {
+        unsafe { ClassEntry::from_mut_ptr(self.inner.load(Ordering::Relaxed)) }
+    }
+
+    /// Create the object from class and call `__construct` with arguments.
+    ///
+    /// If the `__construct` is private, or protected and the called scope isn't
+    /// parent class, it will throw PHP Error.
+    pub fn new_object(
+        &'static self, arguments: impl AsMut<[ZVal]>,
+    ) -> crate::Result<StateObject<T>> {
+        self.as_class_entry()
+            .new_object(arguments)
+            .map(StateObject::new)
+    }
+
+    /// Create the object from class, without calling `__construct`.
+    ///
+    /// **Be careful when `__construct` is necessary.**
+    pub fn init_object(&'static self) -> crate::Result<StateObject<T>> {
+        self.as_class_entry().init_object().map(StateObject::new)
+    }
+}
+
 pub(crate) type StateConstructor = dyn Fn() -> Box<dyn Any>;
 
 /// Builder for registering class.
@@ -207,13 +282,14 @@ pub(crate) type StateConstructor = dyn Fn() -> Box<dyn Any>;
 ///
 /// *It is a common practice for PHP extensions to use PHP objects to package
 /// third-party resources.*
-pub struct ClassEntity<T> {
+pub struct ClassEntity<T: 'static> {
     class_name: CString,
     state_constructor: Rc<StateConstructor>,
     method_entities: Vec<MethodEntity>,
     property_entities: Vec<PropertyEntity>,
     parent: Option<Box<dyn Fn() -> &'static ClassEntry>>,
     interfaces: Vec<Box<dyn Fn() -> &'static ClassEntry>>,
+    bind_class: Option<&'static StateClass<T>>,
     _p: PhantomData<(*mut (), T)>,
 }
 
@@ -245,6 +321,7 @@ impl<T: 'static> ClassEntity<T> {
             property_entities: Vec::new(),
             parent: None,
             interfaces: Vec::new(),
+            bind_class: None,
             _p: PhantomData,
         }
     }
@@ -331,6 +408,14 @@ impl<T: 'static> ClassEntity<T> {
         self.interfaces.push(Box::new(interface));
     }
 
+    /// Bind to static [StateClass].
+    ///
+    /// When the class registered, the [StateClass] will be initialized, so you
+    /// can use the [StateClass] to new stateful object, etc.
+    pub fn bind(&mut self, cls: &'static StateClass<T>) {
+        self.bind_class = Some(cls);
+    }
+
     #[allow(clippy::useless_conversion)]
     pub(crate) unsafe fn init(&self) -> *mut zend_class_entry {
         let parent: *mut zend_class_entry = self
@@ -348,6 +433,10 @@ impl<T: 'static> ClassEntity<T> {
             parent.cast(),
         );
 
+        if let Some(bind_class) = self.bind_class {
+            bind_class.bind(class_ce);
+        }
+
         for interface in &self.interfaces {
             let interface_ce = interface().as_ptr();
             zend_class_implements(class_ce, 1, interface_ce);
@@ -482,7 +571,7 @@ fn get_object_handlers() -> &'static zend_object_handlers {
     static HANDLERS: OnceCell<zend_object_handlers> = OnceCell::new();
     HANDLERS.get_or_init(|| unsafe {
         let mut handlers = std_object_handlers;
-        handlers.offset = StateObject::offset() as c_int;
+        handlers.offset = CStateObject::offset() as c_int;
         handlers.free_obj = Some(free_object);
         handlers
     })
@@ -491,11 +580,11 @@ fn get_object_handlers() -> &'static zend_object_handlers {
 #[allow(clippy::useless_conversion)]
 unsafe extern "C" fn create_object(ce: *mut zend_class_entry) -> *mut zend_object {
     // Alloc more memory size to store state data.
-    let state_object: *mut StateObject =
-        phper_zend_object_alloc(size_of::<StateObject>().try_into().unwrap(), ce).cast();
+    let state_object: *mut CStateObject =
+        phper_zend_object_alloc(size_of::<CStateObject>().try_into().unwrap(), ce).cast();
 
     // Common initialize process.
-    let object = StateObject::as_mut_object(state_object);
+    let object = CStateObject::as_mut_object(state_object);
     zend_object_std_init(object, ce);
     object_properties_init(object, ce);
     rebuild_object_properties(object);
@@ -512,15 +601,15 @@ unsafe extern "C" fn create_object(ce: *mut zend_class_entry) -> *mut zend_objec
 
     // Call the state constructor.
     let data: Box<dyn Any> = (state_constructor.as_ref().unwrap())();
-    *StateObject::as_mut_state(state_object) = Box::into_raw(data);
+    *CStateObject::as_mut_state(state_object) = Box::into_raw(data);
 
     object
 }
 
 unsafe extern "C" fn free_object(object: *mut zend_object) {
     // Drop the state.
-    let state_object = StateObject::fetch_ptr(object);
-    StateObject::drop_state(state_object);
+    let state_object = CStateObject::fetch_ptr(object);
+    CStateObject::drop_state(state_object);
 
     // Original destroy call.
     zend_object_std_dtor(object);
diff --git a/phper/src/functions.rs b/phper/src/functions.rs
@@ -291,11 +291,11 @@ impl Argument {
 
 /// Wrapper of [`zend_function`].
 #[repr(transparent)]
-pub struct ZendFunc {
+pub struct ZFunc {
     inner: zend_function,
 }
 
-impl ZendFunc {
+impl ZFunc {
     /// Wraps a raw pointer.
     ///
     /// # Safety
@@ -305,7 +305,7 @@ impl ZendFunc {
     /// # Panics
     ///
     /// Panics if pointer is null.
-    pub(crate) unsafe fn from_mut_ptr<'a>(ptr: *mut zend_function) -> &'a mut ZendFunc {
+    pub(crate) unsafe fn from_mut_ptr<'a>(ptr: *mut zend_function) -> &'a mut ZFunc {
         let ptr = ptr as *mut Self;
         ptr.as_mut().expect("ptr shouldn't be null")
     }
diff --git a/phper/src/objects.rs b/phper/src/objects.rs
diff --git a/phper/src/values.rs b/phper/src/values.rs

Original file line number	Diff line number	Diff line change
`@@ -83,6 +83,10 @@ uint32_t phper_z_addref_p(zval *zv) {`
`83`	`83`	`return Z_ADDREF_P(zv);`
`84`	`84`	`}`
`85`	`85`
	`86`	`+zend_function phper_z_func_p(const zval zv) {`
	`87`	`+ return Z_FUNC_P(zv);`
	`88`	`+}`
	`89`	`+`
`86`	`90`	`void phper_z_ptr_p(const zval zv) {`
`87`	`91`	`return Z_PTR_P(zv);`
`88`	`92`	`}`