Add stateful obj.

Author: jmjoy

examples/hello/src/lib.rs

@@ -10,11 +10,11 @@
 
 use phper::{
     arrays::ZArray,
-    classes::{DynamicClass, Visibility},
+    classes::{StatefulClass, Visibility},
     functions::Argument,
     ini::{Ini, Policy},
     modules::{Module, ModuleContext},
-    objects::ZObj,
+    objects::StatefulObj,
     php_get_module,
     values::ZVal,
 };
@@ -70,12 +70,12 @@ pub fn get_module() -> Module {
     );
 
     // register classes
-    let mut foo_class = DynamicClass::new("FooClass");
+    let mut foo_class = StatefulClass::new("FooClass");
     foo_class.add_property("foo", Visibility::Private, 100);
     foo_class.add_method(
         "getFoo",
         Visibility::Public,
-        |this: &mut ZObj, _: &mut [ZVal]| {
+        |this: &mut StatefulObj<()>, _: &mut [ZVal]| {
             let prop = this.get_property("foo");
             Ok::<_, phper::Error>(prop.clone())
         },
@@ -84,7 +84,7 @@ pub fn get_module() -> Module {
     foo_class.add_method(
         "setFoo",
         Visibility::Public,
-        |this: &mut ZObj, arguments: &mut [ZVal]| -> phper::Result<()> {
+        |this: &mut StatefulObj<()>, arguments: &mut [ZVal]| -> phper::Result<()> {
             this.set_property("foo", arguments[0].clone());
             Ok(())
         },

examples/http-client/src/client.rs

@@ -15,25 +15,24 @@ use crate::{
 };
 use phper::{
     alloc::ToRefOwned,
-    classes::{ClassEntry, DynamicClass, Visibility},
+    classes::{ClassEntry, StatefulClass, Visibility},
     functions::Argument,
-    objects::ZObj,
 };
-use reqwest::blocking::{Client, ClientBuilder, RequestBuilder};
+use reqwest::blocking::{Client, ClientBuilder};
 use std::time::Duration;
 
 const HTTP_CLIENT_BUILDER_CLASS_NAME: &str = "HttpClient\\HttpClientBuilder";
 const HTTP_CLIENT_CLASS_NAME: &str = "HttpClient\\HttpClient";
 
-pub fn make_client_builder_class() -> DynamicClass<ClientBuilder> {
-    let mut class = DynamicClass::new_with_default(HTTP_CLIENT_BUILDER_CLASS_NAME);
+pub fn make_client_builder_class() -> StatefulClass<ClientBuilder> {
+    let mut class = StatefulClass::new_with_default_state(HTTP_CLIENT_BUILDER_CLASS_NAME);
 
     class.add_method(
         "timeout",
         Visibility::Public,
         |this, arguments| {
             let ms = arguments[0].as_long().unwrap();
-            let state: &mut ClientBuilder = unsafe { this.as_mut_state() };
+            let state: &mut ClientBuilder = this.as_mut_state();
             replace_and_set(state, |builder| {
                 builder.timeout(Duration::from_millis(ms as u64))
             });
@@ -47,7 +46,7 @@ pub fn make_client_builder_class() -> DynamicClass<ClientBuilder> {
         Visibility::Public,
         |this, arguments| {
             let enable = arguments[0].as_bool().unwrap();
-            let state: &mut ClientBuilder = unsafe { this.as_mut_state() };
+            let state: &mut ClientBuilder = this.as_mut_state();
             replace_and_set(state, |builder| builder.cookie_store(enable));
             Ok::<_, HttpClientError>(this.to_ref_owned())
         },
@@ -58,7 +57,7 @@ pub fn make_client_builder_class() -> DynamicClass<ClientBuilder> {
         "build",
         Visibility::Public,
         |this, _arguments| {
-            let state = unsafe { this.as_mut_state() };
+            let state = this.as_mut_state();
             let client = replace_and_get(state, ClientBuilder::build)?;
             let mut object = ClassEntry::from_globals(HTTP_CLIENT_CLASS_NAME)?.new_object([])?;
             unsafe {
@@ -72,22 +71,17 @@ pub fn make_client_builder_class() -> DynamicClass<ClientBuilder> {
     class
 }
 
-pub fn make_client_class() -> DynamicClass<Option<Client>> {
-    let mut class = DynamicClass::new_with_default(HTTP_CLIENT_CLASS_NAME);
+pub fn make_client_class() -> StatefulClass<Option<Client>> {
+    let mut class = StatefulClass::<Option<Client>>::new_with_default_state(HTTP_CLIENT_CLASS_NAME);
 
-    class.add_method(
-        "__construct",
-        Visibility::Private,
-        |_: &mut ZObj, _| {},
-        vec![],
-    );
+    class.add_method("__construct", Visibility::Private, |_, _| {}, vec![]);
 
     class.add_method(
         "get",
         Visibility::Public,
         |this, arguments| {
             let url = arguments[0].as_z_str().unwrap().to_str().unwrap();
-            let client = unsafe { this.as_state::<Option<Client>>().as_ref().unwrap() };
+            let client = this.as_state().as_ref().unwrap();
             let request_builder = client.get(url);
             let mut object = ClassEntry::from_globals(REQUEST_BUILDER_CLASS_NAME)?.new_object([])?;
             unsafe {
@@ -103,7 +97,7 @@ pub fn make_client_class() -> DynamicClass<Option<Client>> {
         Visibility::Public,
         |this, arguments| {
             let url = arguments[0].as_z_str().unwrap().to_str().unwrap();
-            let client = unsafe { this.as_state::<Option<Client>>().as_ref().unwrap() };
+            let client = this.as_state().as_ref().unwrap();
             let request_builder = client.post(url);
             let mut object = ClassEntry::from_globals(REQUEST_BUILDER_CLASS_NAME)?.new_object([])?;
             unsafe {

examples/http-client/src/errors.rs

@@ -8,7 +8,7 @@
 // NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
 // See the Mulan PSL v2 for more details.
 
-use phper::classes::{ClassEntry, DynamicClass};
+use phper::classes::{ClassEntry, StatefulClass};
 
 const EXCEPTION_CLASS_NAME: &str = "HttpClient\\HttpClientException";
 
@@ -29,8 +29,8 @@ pub enum HttpClientError {
     ResponseHadRead,
 }
 
-pub fn make_exception_class() -> DynamicClass<()> {
-    let mut exception_class = DynamicClass::new(EXCEPTION_CLASS_NAME);
+pub fn make_exception_class() -> StatefulClass<()> {
+    let mut exception_class = StatefulClass::new(EXCEPTION_CLASS_NAME);
     exception_class.extends("Exception");
     exception_class
 }

examples/http-client/src/request.rs

@@ -9,29 +9,22 @@
 // See the Mulan PSL v2 for more details.
 
 use crate::{errors::HttpClientError, response::RESPONSE_CLASS_NAME, utils::replace_and_get};
-use phper::{
-    classes::{ClassEntry, DynamicClass, Visibility},
-    objects::ZObj,
-};
-use reqwest::blocking::{RequestBuilder, Response};
+use phper::classes::{ClassEntry, StatefulClass, Visibility};
+use reqwest::blocking::RequestBuilder;
 
 pub const REQUEST_BUILDER_CLASS_NAME: &str = "HttpClient\\RequestBuilder";
 
-pub fn make_request_builder_class() -> DynamicClass<Option<RequestBuilder>> {
-    let mut class = DynamicClass::new_with_default(REQUEST_BUILDER_CLASS_NAME);
+pub fn make_request_builder_class() -> StatefulClass<Option<RequestBuilder>> {
+    let mut class =
+        StatefulClass::<Option<RequestBuilder>>::new_with_default_state(REQUEST_BUILDER_CLASS_NAME);
 
-    class.add_method(
-        "__construct",
-        Visibility::Private,
-        |_: &mut ZObj, _| {},
-        vec![],
-    );
+    class.add_method("__construct", Visibility::Private, |_, _| {}, vec![]);
 
     class.add_method(
         "send",
         Visibility::Public,
         |this, _arguments| {
-            let state = unsafe { this.as_mut_state::<Option<RequestBuilder>>() };
+            let state = this.as_mut_state();
             let response = replace_and_get(state, |builder| builder.unwrap().send())?;
             let mut object = ClassEntry::from_globals(RESPONSE_CLASS_NAME)?.new_object([])?;
             unsafe {

examples/http-client/src/response.rs

@@ -11,22 +11,21 @@
 use crate::{errors::HttpClientError, utils::replace_and_get};
 use phper::{
     arrays::{InsertKey, ZArray},
-    classes::{DynamicClass, Visibility},
-    objects::ZObj,
+    classes::{StatefulClass, Visibility},
     values::ZVal,
 };
 use reqwest::blocking::Response;
 
 pub const RESPONSE_CLASS_NAME: &str = "HttpClient\\Response";
 
-pub fn make_response_class() -> DynamicClass<Option<Response>> {
-    let mut class = DynamicClass::new_with_default(RESPONSE_CLASS_NAME);
+pub fn make_response_class() -> StatefulClass<Option<Response>> {
+    let mut class = StatefulClass::<Option<Response>>::new_with_default_state(RESPONSE_CLASS_NAME);
 
     class.add_method(
         "body",
         Visibility::Public,
-        |this: &mut ZObj, _arguments| {
-            let response = unsafe { this.as_mut_state::<Option<Response>>() };
+        |this, _arguments| {
+            let response = this.as_mut_state();
             let body = replace_and_get(response, |response| {
                 response
                     .ok_or(HttpClientError::ResponseHadRead)
@@ -41,11 +40,12 @@ pub fn make_response_class() -> DynamicClass<Option<Response>> {
         "status",
         Visibility::Public,
         |this, _arguments| {
-            let response = unsafe { this.as_state::<Option<Response>>() }
-                .as_ref()
-                .ok_or_else(|| HttpClientError::ResponseAfterRead {
-                    method_name: "status".to_owned(),
-                })?;
+            let response =
+                this.as_state()
+                    .as_ref()
+                    .ok_or_else(|| HttpClientError::ResponseAfterRead {
+                        method_name: "status".to_owned(),
+                    })?;
 
             Ok::<_, HttpClientError>(response.status().as_u16() as i64)
         },
@@ -56,13 +56,12 @@ pub fn make_response_class() -> DynamicClass<Option<Response>> {
         "headers",
         Visibility::Public,
         |this, _arguments| {
-            let response = unsafe {
-                this.as_state::<Option<Response>>()
+            let response =
+                this.as_state()
                     .as_ref()
                     .ok_or_else(|| HttpClientError::ResponseAfterRead {
                         method_name: "headers".to_owned(),
-                    })?
-            };
+                    })?;
             let headers_map =
                 response
                     .headers()

examples/http-server/src/errors.rs

@@ -9,7 +9,7 @@
 // See the Mulan PSL v2 for more details.
 
 use hyper::header::{InvalidHeaderName, InvalidHeaderValue};
-use phper::classes::{ClassEntry, DynamicClass};
+use phper::classes::{ClassEntry, StatefulClass};
 use std::{net::AddrParseError, str::Utf8Error};
 
 const EXCEPTION_CLASS_NAME: &str = "HttpServer\\HttpServerException";
@@ -40,8 +40,8 @@ pub enum HttpServerError {
     InvalidHeaderValue(#[from] InvalidHeaderValue),
 }
 
-pub fn make_exception_class() -> DynamicClass<()> {
-    let mut exception_class = DynamicClass::new(EXCEPTION_CLASS_NAME);
+pub fn make_exception_class() -> StatefulClass<()> {
+    let mut exception_class = StatefulClass::new(EXCEPTION_CLASS_NAME);
     exception_class.extends("Exception");
     exception_class
 }

examples/http-server/src/request.rs

@@ -8,12 +8,12 @@
 // NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
 // See the Mulan PSL v2 for more details.
 
-use phper::classes::{DynamicClass, Visibility};
+use phper::classes::{StatefulClass, Visibility};
 
 pub const HTTP_REQUEST_CLASS_NAME: &str = "HttpServer\\HttpRequest";
 
-pub fn make_request_class() -> DynamicClass<()> {
-    let mut class = DynamicClass::new(HTTP_REQUEST_CLASS_NAME);
+pub fn make_request_class() -> StatefulClass<()> {
+    let mut class = StatefulClass::new(HTTP_REQUEST_CLASS_NAME);
 
     class.add_property("header", Visibility::Public, ());
     class.add_property("server", Visibility::Public, ());

examples/http-server/src/response.rs

@@ -11,20 +11,20 @@
 use crate::errors::HttpServerError;
 use hyper::{header::HeaderName, http::HeaderValue, Body, Response};
 use phper::{
-    classes::{DynamicClass, Visibility},
+    classes::{StatefulClass, Visibility},
     functions::Argument,
 };
 
 pub const HTTP_RESPONSE_CLASS_NAME: &str = "HttpServer\\HttpResponse";
 
-pub fn make_response_class() -> DynamicClass<Response<Body>> {
-    let mut class = DynamicClass::new_with_default(HTTP_RESPONSE_CLASS_NAME);
+pub fn make_response_class() -> StatefulClass<Response<Body>> {
+    let mut class = StatefulClass::new_with_default_state(HTTP_RESPONSE_CLASS_NAME);
 
     class.add_method(
         "header",
         Visibility::Public,
         |this, arguments| {
-            let response: &mut Response<Body> = unsafe { this.as_mut_state() };
+            let response: &mut Response<Body> = this.as_mut_state();
             response.headers_mut().insert(
                 HeaderName::from_bytes(arguments[0].as_z_str().unwrap().to_bytes())?,
                 HeaderValue::from_bytes(arguments[1].as_z_str().unwrap().to_bytes())?,
@@ -38,7 +38,7 @@ pub fn make_response_class() -> DynamicClass<Response<Body>> {
         "end",
         Visibility::Public,
         |this, arguments| {
-            let response: &mut Response<Body> = unsafe { this.as_mut_state() };
+            let response: &mut Response<Body> = this.as_mut_state();
             *response.body_mut() = arguments[0].as_z_str().unwrap().to_bytes().to_vec().into();
             Ok::<_, phper::Error>(())
         },

examples/http-server/src/server.rs

@@ -19,7 +19,7 @@ use hyper::{
 };
 use phper::{
     alloc::{EBox, RefClone, ToRefOwned},
-    classes::{ClassEntry, DynamicClass, Visibility},
+    classes::{ClassEntry, StatefulClass, Visibility},
     errors::Error::Throw,
     functions::Argument,
     values::ZVal,
@@ -35,8 +35,10 @@ use tokio::runtime::Handle;
 
 const HTTP_SERVER_CLASS_NAME: &str = "HttpServer\\HttpServer";
 
-pub fn make_server_class() -> DynamicClass<Option<Builder<AddrIncoming>>> {
-    let mut class = DynamicClass::new_with_default(HTTP_SERVER_CLASS_NAME);
+pub fn make_server_class() -> StatefulClass<Option<Builder<AddrIncoming>>> {
+    let mut class = StatefulClass::<Option<Builder<AddrIncoming>>>::new_with_default_state(
+        HTTP_SERVER_CLASS_NAME,
+    );
 
     class.add_property("host", Visibility::Private, "127.0.0.1");
     class.add_property("port", Visibility::Private, 8080);
@@ -52,9 +54,7 @@ pub fn make_server_class() -> DynamicClass<Option<Builder<AddrIncoming>>> {
             this.set_property("port", port);
             let addr = format!("{}:{}", host.to_str()?, port).parse::<SocketAddr>()?;
             let builder = Server::bind(&addr);
-            unsafe {
-                *this.as_mut_state() = Some(builder);
-            }
+            *this.as_mut_state() = Some(builder);
             Ok::<_, HttpServerError>(())
         },
         vec![Argument::by_val("host"), Argument::by_val("port")],
@@ -76,11 +76,7 @@ pub fn make_server_class() -> DynamicClass<Option<Builder<AddrIncoming>>> {
         |this, _| {
             static HANDLE: AtomicPtr<ZVal> = AtomicPtr::new(null_mut());
 
-            let builder = replace(
-                unsafe { this.as_mut_state::<Option<Builder<AddrIncoming>>>() },
-                None,
-            )
-            .unwrap();
+            let builder = replace(this.as_mut_state(), None).unwrap();
             let handle = EBox::new(this.get_mut_property("onRequestHandle").ref_clone());
             HANDLE.store(EBox::into_raw(handle), Ordering::SeqCst);
 

phper/src/arrays.rs

@@ -208,7 +208,7 @@ impl ZArr {
         }
     }
 
-    pub fn entry<'a>(&mut self, key: impl Into<Key<'a>>) -> Entry<'a> {
+    pub fn entry<'a>(&mut self, _key: impl Into<Key<'a>>) -> Entry<'a> {
         todo!()
     }
 }
@@ -365,7 +365,7 @@ pub enum Entry<'a> {
 }
 
 impl<'a> Entry<'a> {
-    pub fn or_insert(&mut self, val: ZVal) -> &'a mut ZVal {
+    pub fn or_insert(&mut self, _val: ZVal) -> &'a mut ZVal {
         todo!()
     }
 }