Add into state method for StateObject, and refactor StateObj. (#120)

jmjoy · web-flow · commit 4dd852f73045 · 2023-04-29T19:02:54.000+08:00
diff --git a/examples/http-client/src/client.rs b/examples/http-client/src/client.rs
@@ -52,9 +52,10 @@ pub fn make_client_builder_class() -> ClassEntity<ClientBuilder> {
     class.add_method("build", Visibility::Public, |this, _arguments| {
         let state = take(this.as_mut_state());
         let client = ClientBuilder::build(state).map_err(HttpClientError::Reqwest)?;
-        let mut object = ClassEntry::from_globals(HTTP_CLIENT_CLASS_NAME)?.init_object()?;
+        let class = ClassEntry::from_globals(HTTP_CLIENT_CLASS_NAME)?;
+        let mut object = class.init_object()?;
         unsafe {
-            *object.as_mut_state() = Some(client);
+            *object.as_mut_state_obj().as_mut_state() = Some(client);
         }
         Ok::<_, phper::Error>(object)
     });
@@ -77,7 +78,7 @@ pub fn make_client_class() -> ClassEntity<Option<Client>> {
             let request_builder = client.get(url);
             let mut object = ClassEntry::from_globals(REQUEST_BUILDER_CLASS_NAME)?.init_object()?;
             unsafe {
-                *object.as_mut_state() = Some(request_builder);
+                *object.as_mut_state_obj().as_mut_state() = Some(request_builder);
             }
             Ok::<_, phper::Error>(object)
         })
@@ -90,7 +91,7 @@ pub fn make_client_class() -> ClassEntity<Option<Client>> {
             let request_builder = client.post(url);
             let mut object = ClassEntry::from_globals(REQUEST_BUILDER_CLASS_NAME)?.init_object()?;
             unsafe {
-                *object.as_mut_state() = Some(request_builder);
+                *object.as_mut_state_obj().as_mut_state() = Some(request_builder);
             }
             Ok::<_, phper::Error>(object)
         })
diff --git a/examples/http-client/src/request.rs b/examples/http-client/src/request.rs
@@ -34,7 +34,7 @@ pub fn make_request_builder_class() -> ClassEntity<Option<RequestBuilder>> {
             .map_err(ThrowObject::from_throwable)?
             .new_object([])?;
         unsafe {
-            *object.as_mut_state() = Some(response);
+            *object.as_mut_state_obj().as_mut_state() = Some(response);
         }
         Ok::<_, phper::Error>(object)
     });
diff --git a/examples/http-server/src/request.rs b/examples/http-server/src/request.rs
@@ -17,7 +17,7 @@ use std::convert::Infallible;
 
 pub const HTTP_REQUEST_CLASS_NAME: &str = "HttpServer\\HttpRequest";
 
-pub static HTTP_REQUEST_CLASS: StateClass<()> = StateClass::new();
+pub static HTTP_REQUEST_CLASS: StateClass<()> = StateClass::null();
 
 /// Register the class `HttpServer\HttpRequest` by `ClassEntity`.
 pub fn make_request_class() -> ClassEntity<()> {
diff --git a/examples/http-server/src/response.rs b/examples/http-server/src/response.rs
@@ -21,7 +21,7 @@ use phper::{
 
 pub const HTTP_RESPONSE_CLASS_NAME: &str = "HttpServer\\HttpResponse";
 
-pub static HTTP_RESPONSE_CLASS: StateClass<Response<Body>> = StateClass::new();
+pub static HTTP_RESPONSE_CLASS: StateClass<Response<Body>> = StateClass::null();
 
 /// Register the class `HttpServer\HttpResponse` by `ClassEntity`, with the
 /// inner state `Response<Body>`.
diff --git a/examples/http-server/src/server.rs b/examples/http-server/src/server.rs
@@ -22,7 +22,7 @@ use phper::{
     functions::Argument,
     values::ZVal,
 };
-use std::{cell::RefCell, collections::HashMap, mem::take, net::SocketAddr};
+use std::{cell::RefCell, collections::HashMap, net::SocketAddr};
 use tokio::runtime::{self};
 
 const HTTP_SERVER_CLASS_NAME: &str = "HttpServer\\HttpServer";
@@ -128,8 +128,7 @@ pub fn make_server_class() -> ClassEntity<()> {
                             handler.call([request_val, response_val])?;
 
                             // Get the inner state.
-                            let response =
-                                take(unsafe { response.as_mut_state::<Response<Body>>() });
+                            let response = response.into_state().unwrap();
 
                             Ok::<Response<Body>, phper::Error>(response)
                         })
diff --git a/phper-doc/doc/_02_quick_start/_02_write_a_simple_http_client/index.md b/phper-doc/doc/_02_quick_start/_02_write_a_simple_http_client/index.md
@@ -236,7 +236,7 @@ Now let's begin to finish the logic.
            let client = ClientBuilder::build(state).map_err(HttpClientError::Reqwest)?;
            let mut object = ClassEntry::from_globals(HTTP_CLIENT_CLASS_NAME)?.init_object()?;
            unsafe {
-               *object.as_mut_state() = Some(client);
+               *object.as_mut_state_obj().as_mut_state() = Some(client);
            }
            Ok::<_, phper::Error>(object)
        });
diff --git a/phper-doc/doc/_05_internal_types/index.md b/phper-doc/doc/_05_internal_types/index.md
@@ -18,6 +18,11 @@ PHPER follows this design, there are the following types:
 - [ZArr](phper::arrays::ZArr) / [ZArray](phper::arrays::ZArray)
 - [ZObj](phper::objects::ZObj) / [ZObject](phper::objects::ZObject)
 
+> It seems that there is no need to separate into two types, but `ZStr`,
+> `ZArr`, and `ZObj` are all transparent types, so the fields of the struct
+> cannot be changed. Separating an ownership struct `ZString`, `ZArray`,
+> and `ZObject`, and then we can change fields of the struct in the future.
+
 ## Mapping relationship
 
 Here is the mapping relationship of Rust type and base PHP type.
diff --git a/phper-sys/php_wrapper.c b/phper-sys/php_wrapper.c
@@ -348,6 +348,10 @@ void phper_zend_object_release(zend_object *obj) {
     zend_object_release(obj);
 }
 
+uint32_t phper_zend_object_gc_refcount(const zend_object *obj) {
+    return GC_REFCOUNT(obj);
+}
+
 // ==================================================
 // class apis:
 // ==================================================
diff --git a/phper/src/classes.rs b/phper/src/classes.rs
@@ -14,23 +14,22 @@ use crate::{
     arrays::ZArr,
     errors::{ClassNotFoundError, InitializeObjectError, Throwable},
     functions::{Function, FunctionEntry, Method, MethodEntity},
-    objects::{CStateObject, StateObj, StateObject, ZObj, ZObject},
+    objects::{StateObj, StateObject, ZObject},
     strings::ZStr,
     sys::*,
     types::Scalar,
     utils::ensure_end_with_zero,
     values::ZVal,
 };
 use once_cell::sync::OnceCell;
-use phper_alloc::ToRefOwned;
 use std::{
     any::Any,
     borrow::ToOwned,
     convert::TryInto,
     ffi::{c_void, CString},
     fmt::Debug,
     marker::PhantomData,
-    mem::{size_of, zeroed},
+    mem::{size_of, zeroed, ManuallyDrop},
     os::raw::c_int,
     ptr::null_mut,
     rc::Rc,
@@ -156,8 +155,11 @@ impl ClassEntry {
             if !phper_object_init_ex(val.as_mut_ptr(), ptr) {
                 Err(InitializeObjectError::new(self.get_name().to_str()?.to_owned()).into())
             } else {
+                // Can't drop val here! Otherwise the object will be dropped too (wasting me a
+                // day of debugging time here).
+                let mut val = ManuallyDrop::new(val);
                 let ptr = phper_z_obj_p(val.as_mut_ptr());
-                Ok(ZObj::from_mut_ptr(ptr).to_ref_owned())
+                Ok(ZObject::from_raw(ptr))
             }
         }
     }
@@ -218,7 +220,7 @@ fn find_global_class_entry_ptr(name: impl AsRef<str>) -> *mut zend_class_entry {
 /// ```rust
 /// use phper::classes::{ClassEntity, StateClass};
 ///
-/// pub static FOO_CLASS: StateClass<FooState> = StateClass::new();
+/// pub static FOO_CLASS: StateClass<FooState> = StateClass::null();
 ///
 /// #[derive(Default)]
 /// pub struct FooState;
@@ -238,7 +240,7 @@ pub struct StateClass<T> {
 impl<T> StateClass<T> {
     /// Create empty [StateClass], with null
     /// [zend_class_entry](crate::sys::zend_class_entry).
-    pub const fn new() -> Self {
+    pub const fn null() -> Self {
         Self {
             inner: AtomicPtr::new(null_mut()),
             _p: PhantomData,
@@ -263,18 +265,22 @@ impl<T> StateClass<T> {
     ) -> crate::Result<StateObject<T>> {
         self.as_class_entry()
             .new_object(arguments)
-            .map(StateObject::new)
+            .map(ZObject::into_raw)
+            .map(StateObject::<T>::from_raw_object)
     }
 
     /// 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)
+        self.as_class_entry()
+            .init_object()
+            .map(ZObject::into_raw)
+            .map(StateObject::<T>::from_raw_object)
     }
 }
 
-pub(crate) type StateConstructor = dyn Fn() -> Box<dyn Any>;
+pub(crate) type StateConstructor = dyn Fn() -> *mut dyn Any;
 
 /// Builder for registering class.
 ///
@@ -316,7 +322,11 @@ impl<T: 'static> ClassEntity<T> {
     ) -> Self {
         Self {
             class_name: ensure_end_with_zero(class_name),
-            state_constructor: Rc::new(move || Box::new(state_constructor())),
+            state_constructor: Rc::new(move || {
+                let state = state_constructor();
+                let boxed = Box::new(state) as Box<dyn Any>;
+                Box::into_raw(boxed)
+            }),
             method_entities: Vec::new(),
             property_entities: Vec::new(),
             parent: None,
@@ -571,7 +581,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 = CStateObject::offset() as c_int;
+        handlers.offset = StateObj::<()>::offset() as c_int;
         handlers.free_obj = Some(free_object);
         handlers
     })
@@ -580,15 +590,15 @@ 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 CStateObject =
-        phper_zend_object_alloc(size_of::<CStateObject>().try_into().unwrap(), ce).cast();
+    let state_object = phper_zend_object_alloc(size_of::<StateObj<()>>().try_into().unwrap(), ce);
+    let state_object = StateObj::<()>::from_mut_ptr(state_object);
 
     // Common initialize process.
-    let object = CStateObject::as_mut_object(state_object);
+    let object = state_object.as_mut_object().as_mut_ptr();
     zend_object_std_init(object, ce);
     object_properties_init(object, ce);
     rebuild_object_properties(object);
-    object.handlers = get_object_handlers();
+    (*object).handlers = get_object_handlers();
 
     // Get state constructor.
     let mut func_ptr = (*ce).info.internal.builtin_functions;
@@ -599,17 +609,18 @@ unsafe extern "C" fn create_object(ce: *mut zend_class_entry) -> *mut zend_objec
     let state_constructor = func_ptr as *mut *const StateConstructor;
     let state_constructor = state_constructor.read();
 
-    // Call the state constructor.
-    let data: Box<dyn Any> = (state_constructor.as_ref().unwrap())();
-    *CStateObject::as_mut_state(state_object) = Box::into_raw(data);
+    // Call the state constructor and store the state.
+    let data = (state_constructor.as_ref().unwrap())();
+    *state_object.as_mut_any_state() = data;
 
     object
 }
 
 unsafe extern "C" fn free_object(object: *mut zend_object) {
+    let state_object = StateObj::<()>::from_mut_object_ptr(object);
+
     // Drop the state.
-    let state_object = CStateObject::fetch_ptr(object);
-    CStateObject::drop_state(state_object);
+    state_object.drop_state();
 
     // Original destroy call.
     zend_object_std_dtor(object);
diff --git a/phper/src/objects.rs b/phper/src/objects.rs

Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ pub fn make_request_builder_class() -> ClassEntity<Option<RequestBuilder>> {`
`34`	`34`	`.map_err(ThrowObject::from_throwable)?`
`35`	`35`	`.new_object([])?;`
`36`	`36`	`unsafe {`
`37`		`- *object.as_mut_state() = Some(response);`
	`37`	`+ *object.as_mut_state_obj().as_mut_state() = Some(response);`
`38`	`38`	`}`
`39`	`39`	`Ok::<_, phper::Error>(object)`
`40`	`40`	`});`
Original file line number	Diff line number	Diff line change
`@@ -236,7 +236,7 @@ Now let's begin to finish the logic.`
`236`	`236`	`let client = ClientBuilder::build(state).map_err(HttpClientError::Reqwest)?;`
`237`	`237`	`let mut object = ClassEntry::from_globals(HTTP_CLIENT_CLASS_NAME)?.init_object()?;`
`238`	`238`	`unsafe {`
`239`		`- *object.as_mut_state() = Some(client);`
	`239`	`+ *object.as_mut_state_obj().as_mut_state() = Some(client);`
`240`	`240`	`}`
`241`	`241`	`Ok::<_, phper::Error>(object)`
`242`	`242`	`});`