Improve http-client example. (#122)

Author: jmjoy

examples/http-client/src/client.rs

@@ -8,18 +8,21 @@
 // NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
 // See the Mulan PSL v2 for more details.
 
-use crate::{errors::HttpClientError, request::REQUEST_BUILDER_CLASS_NAME};
+use crate::{errors::HttpClientError, request::REQUEST_BUILDER_CLASS};
 use phper::{
     alloc::ToRefOwned,
-    classes::{ClassEntity, ClassEntry, Visibility},
+    classes::{ClassEntity, StateClass, Visibility},
     functions::Argument,
 };
 use reqwest::blocking::{Client, ClientBuilder};
 use std::{convert::Infallible, mem::take, time::Duration};
 
 const HTTP_CLIENT_BUILDER_CLASS_NAME: &str = "HttpClient\\HttpClientBuilder";
+
 const HTTP_CLIENT_CLASS_NAME: &str = "HttpClient\\HttpClient";
 
+static HTTP_CLIENT_CLASS: StateClass<Option<Client>> = StateClass::null();
+
 pub fn make_client_builder_class() -> ClassEntity<ClientBuilder> {
     // `new_with_default_state_constructor` means initialize the state of
     // `ClientBuilder` as `Default::default`.
@@ -52,11 +55,8 @@ 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 class = ClassEntry::from_globals(HTTP_CLIENT_CLASS_NAME)?;
-        let mut object = class.init_object()?;
-        unsafe {
-            *object.as_mut_state_obj().as_mut_state() = Some(client);
-        }
+        let mut object = HTTP_CLIENT_CLASS.init_object()?;
+        *object.as_mut_state() = Some(client);
         Ok::<_, phper::Error>(object)
     });
 
@@ -67,6 +67,8 @@ pub fn make_client_class() -> ClassEntity<Option<Client>> {
     let mut class =
         ClassEntity::<Option<Client>>::new_with_default_state_constructor(HTTP_CLIENT_CLASS_NAME);
 
+    class.bind(&HTTP_CLIENT_CLASS);
+
     class.add_method("__construct", Visibility::Private, |_, _| {
         Ok::<_, Infallible>(())
     });
@@ -76,10 +78,8 @@ pub fn make_client_class() -> ClassEntity<Option<Client>> {
             let url = arguments[0].expect_z_str()?.to_str().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)?.init_object()?;
-            unsafe {
-                *object.as_mut_state_obj().as_mut_state() = Some(request_builder);
-            }
+            let mut object = REQUEST_BUILDER_CLASS.init_object()?;
+            *object.as_mut_state() = Some(request_builder);
             Ok::<_, phper::Error>(object)
         })
         .argument(Argument::by_val("url"));
@@ -89,10 +89,8 @@ pub fn make_client_class() -> ClassEntity<Option<Client>> {
             let url = arguments[0].expect_z_str()?.to_str().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)?.init_object()?;
-            unsafe {
-                *object.as_mut_state_obj().as_mut_state() = Some(request_builder);
-            }
+            let mut object = REQUEST_BUILDER_CLASS.init_object()?;
+            *object.as_mut_state() = Some(request_builder);
             Ok::<_, phper::Error>(object)
         })
         .argument(Argument::by_val("url"));

examples/http-client/src/request.rs

@@ -8,34 +8,31 @@
 // NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
 // See the Mulan PSL v2 for more details.
 
-use crate::{errors::HttpClientError, response::RESPONSE_CLASS_NAME};
-use phper::{
-    classes::{ClassEntity, ClassEntry, Visibility},
-    errors::ThrowObject,
-};
+use crate::{errors::HttpClientError, response::RESPONSE_CLASS};
+use phper::classes::{ClassEntity, StateClass, Visibility};
 use reqwest::blocking::RequestBuilder;
 use std::{convert::Infallible, mem::take};
 
 pub const REQUEST_BUILDER_CLASS_NAME: &str = "HttpClient\\RequestBuilder";
 
+pub static REQUEST_BUILDER_CLASS: StateClass<Option<RequestBuilder>> = StateClass::null();
+
 pub fn make_request_builder_class() -> ClassEntity<Option<RequestBuilder>> {
     let mut class = ClassEntity::<Option<RequestBuilder>>::new_with_default_state_constructor(
         REQUEST_BUILDER_CLASS_NAME,
     );
 
+    class.bind(&REQUEST_BUILDER_CLASS);
+
     class.add_method("__construct", Visibility::Private, |_, _| {
         Ok::<_, Infallible>(())
     });
 
     class.add_method("send", Visibility::Public, |this, _arguments| {
         let state = take(this.as_mut_state());
         let response = state.unwrap().send().map_err(HttpClientError::Reqwest)?;
-        let mut object = ClassEntry::from_globals(RESPONSE_CLASS_NAME)
-            .map_err(ThrowObject::from_throwable)?
-            .new_object([])?;
-        unsafe {
-            *object.as_mut_state_obj().as_mut_state() = Some(response);
-        }
+        let mut object = RESPONSE_CLASS.new_object([])?;
+        *object.as_mut_state() = Some(response);
         Ok::<_, phper::Error>(object)
     });
 

examples/http-client/src/response.rs

@@ -11,18 +11,22 @@
 use crate::errors::HttpClientError;
 use phper::{
     arrays::{InsertKey, ZArray},
-    classes::{ClassEntity, Visibility},
+    classes::{ClassEntity, StateClass, Visibility},
     values::ZVal,
 };
 use reqwest::blocking::Response;
 use std::mem::take;
 
 pub const RESPONSE_CLASS_NAME: &str = "HttpClient\\Response";
 
+pub static RESPONSE_CLASS: StateClass<Option<Response>> = StateClass::null();
+
 pub fn make_response_class() -> ClassEntity<Option<Response>> {
     let mut class =
         ClassEntity::<Option<Response>>::new_with_default_state_constructor(RESPONSE_CLASS_NAME);
 
+    class.bind(&RESPONSE_CLASS);
+
     class.add_method("body", Visibility::Public, |this, _arguments| {
         let response = take(this.as_mut_state());
         let response = response.ok_or(HttpClientError::ResponseHadRead)?;

phper-doc/doc/_02_quick_start/_02_write_a_simple_http_client/index.md

@@ -193,14 +193,19 @@ Now let's begin to finish the logic.
 
    use phper::{
        alloc::ToRefOwned,
-       classes::Visibility,
+       classes::{StateClass, Visibility},
        functions::Argument,
    };
    use reqwest::blocking::{Client, ClientBuilder};
    use std::{mem::take, time::Duration};
 
    const HTTP_CLIENT_BUILDER_CLASS_NAME: &str = "HttpClient\\HttpClientBuilder";
+
    const HTTP_CLIENT_CLASS_NAME: &str = "HttpClient\\HttpClient";
+
+   // The static StateClass is bind to ClassEntity of HttpClient, When the class registered,
+   // the StateClass will be initialized, so you can use it to new stateful object, etc.
+   static HTTP_CLIENT_CLASS: StateClass<Option<Client>> = StateClass::null();
 
    pub fn make_client_builder_class() -> ClassEntity<ClientBuilder> {
        // `new_with_default_state_constructor` means initialize the state of `ClientBuilder` as
@@ -234,10 +239,8 @@ Now let's begin to finish the logic.
        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()?;
-           unsafe {
-               *object.as_mut_state_obj().as_mut_state() = Some(client);
-           }
+           let mut object = HTTP_CLIENT_CLASS.init_object()?;
+           *object.as_mut_state() = Some(client);
            Ok::<_, phper::Error>(object)
        });
 

phper/src/classes.rs

@@ -280,6 +280,8 @@ impl<T> StateClass<T> {
     }
 }
 
+unsafe impl<T> Sync for StateClass<T> {}
+
 pub(crate) type StateConstructor = dyn Fn() -> *mut dyn Any;
 
 pub(crate) type StateCloner = dyn Fn(*const dyn Any) -> *mut dyn Any;