Add generic type for ClassEntry, and add type id checks.

Author: jmjoy

examples/http-client/Cargo.toml

@@ -14,6 +14,7 @@ crate-type = ["cdylib"]
 [dependencies]
 anyhow = "1.0.40"
 bytes = "1.0.1"
+indexmap = "1.6.2"
 phper = { version = "0.2.0-alpha.2", path = "../../phper" }
 reqwest = { version = "0.11.3", features = ["blocking"] }
 thiserror = "1.0.24"

examples/http-client/src/client.rs

@@ -35,8 +35,7 @@ pub fn make_client_class() -> DynamicClass<Client> {
             };
 
             let mut response_object =
-                Object::<Option<ReadiedResponse>>::new_by_class_name(RESPONSE_CLASS_NAME)
-                    .map_err(phper::Error::ClassNotFound)?;
+                Object::<Option<ReadiedResponse>>::new_by_class_name(RESPONSE_CLASS_NAME)?;
             *response_object.as_mut_state() = Some(readied_response);
 
             Ok::<_, HttpClientError>(response_object)

examples/http-client/src/errors.rs

@@ -1,5 +1,5 @@
 use phper::{
-    classes::{ClassEntry, DynamicClass},
+    classes::{ClassEntry, DynamicClass, StatelessClassEntry},
     errors::{Error::ClassNotFound, Throwable},
 };
 
@@ -15,7 +15,7 @@ pub enum HttpClientError {
 }
 
 impl Throwable for HttpClientError {
-    fn class_entry(&self) -> &ClassEntry {
+    fn class_entry(&self) -> &StatelessClassEntry {
         ClassEntry::from_globals(EXCEPTION_CLASS_NAME).unwrap()
     }
 }

examples/http-client/src/response.rs

@@ -1,7 +1,9 @@
 use bytes::Bytes;
-use phper::classes::DynamicClass;
+use indexmap::map::IndexMap;
+use phper::{arrays::Array, classes::DynamicClass};
 use reqwest::{blocking::Response, header::HeaderMap, StatusCode};
 use std::{
+    collections::BTreeMap,
     convert::Infallible,
     mem::{zeroed, MaybeUninit},
     net::SocketAddr,
@@ -40,5 +42,24 @@ pub fn make_response_class() -> DynamicClass<Option<ReadiedResponse>> {
         vec![],
     );
 
+    class.add_method(
+        "headers",
+        |this, arguments| {
+            let readied_response = this.as_state().as_ref().unwrap();
+            let headers_map =
+                readied_response
+                    .headers
+                    .iter()
+                    .fold(IndexMap::new(), |mut acc, (key, value)| {
+                        acc.entry(key.as_str().to_owned())
+                            .or_insert(vec![])
+                            .push(value.as_bytes().to_owned());
+                        acc
+                    });
+            headers_map
+        },
+        vec![],
+    );
+
     class
 }

examples/http-client/tests/php/test.php

@@ -12,6 +12,7 @@
 $resp = $client->get("https://httpbin.org/ip");
 var_dump([
     "status" => $resp->status(),
+    "headers" => $resp->headers(),
     "body" => $resp->body(),
 ]);
 

phper/src/classes.rs

@@ -1,8 +1,8 @@
 //! Apis relate to [crate::sys::zend_class_entry].
 
+use once_cell::sync::OnceCell;
 use std::{
     any::Any,
-    collections::HashMap,
     convert::Infallible,
     marker::PhantomData,
     mem::{size_of, zeroed, ManuallyDrop},
@@ -14,23 +14,22 @@ use std::{
     },
 };
 
-use dashmap::DashMap;
-use once_cell::sync::OnceCell;
-
 use phper_alloc::EBox;
 
 use crate::{
-    errors::{ClassNotFoundError, Throwable},
+    errors::{ClassNotFoundError, StateTypeError, Throwable},
     functions::{Argument, FunctionEntity, FunctionEntry, Method},
     objects::{ExtendObject, Object},
     sys::*,
     utils::ensure_end_with_zero,
     values::{SetVal, Val},
 };
-use std::rc::Rc;
+use dashmap::DashMap;
+use std::{any::TypeId, iter::Once};
 
 pub trait Classifiable {
     fn state_constructor(&self) -> Box<StateConstructor<Box<dyn Any>>>;
+    fn state_type_id(&self) -> TypeId;
     fn class_name(&self) -> &str;
     fn methods(&mut self) -> &mut [FunctionEntity];
     fn properties(&mut self) -> &mut [PropertyEntity];
@@ -116,6 +115,10 @@ impl<T: Send + Sync> Classifiable for DynamicClass<T> {
         Box::new(move || sc().map(|x| Box::new(x) as _))
     }
 
+    fn state_type_id(&self) -> TypeId {
+        TypeId::of::<T>()
+    }
+
     fn class_name(&self) -> &str {
         &self.class_name
     }
@@ -133,22 +136,42 @@ impl<T: Send + Sync> Classifiable for DynamicClass<T> {
     }
 }
 
+/// Used to represent classes not registered by this framework,
+/// or classes that do not have or do not want to process state.
+pub type StatelessClassEntry = ClassEntry<()>;
+
 /// Wrapper of [crate::sys::zend_class_entry].
-///
-/// TODO Add generic type.
 #[repr(transparent)]
-pub struct ClassEntry {
+pub struct ClassEntry<T: 'static> {
     inner: zend_class_entry,
+    _p: PhantomData<T>,
 }
 
-impl ClassEntry {
-    // TODO After added generic type, Check generic type is relate to class_name, otherwise return error.
-    pub fn from_globals<'a>(class_name: impl AsRef<str>) -> Result<&'a Self, ClassNotFoundError> {
+impl<T: 'static> ClassEntry<T> {
+    pub fn from_globals<'a>(class_name: impl AsRef<str>) -> crate::Result<&'a Self> {
         let name = class_name.as_ref();
         let ptr: *mut Self = find_global_class_entry_ptr(name).cast();
-        unsafe {
-            ptr.as_ref()
-                .ok_or_else(|| ClassNotFoundError::new(name.to_string()))
+        let r = unsafe {
+            ptr.as_ref().ok_or_else(|| {
+                crate::Error::ClassNotFound(ClassNotFoundError::new(name.to_string()))
+            })
+        };
+        Self::check_type_id(ptr);
+        r
+    }
+
+    fn check_type_id(this: *mut Self) -> Result<(), StateTypeError> {
+        if TypeId::of::<T>() == TypeId::of::<()>() {
+            return Ok(());
+        }
+        let is = get_registered_class_type_map()
+            .get(&(this as usize))
+            .map(|t| *t == TypeId::of::<T>())
+            .unwrap_or_default();
+        if is {
+            Ok(())
+        } else {
+            Err(StateTypeError)
         }
     }
 
@@ -164,7 +187,7 @@ impl ClassEntry {
         &mut self.inner
     }
 
-    pub(crate) fn create_object<T>(&self) -> EBox<Object<T>> {
+    pub fn create_object(&self) -> EBox<Object<T>> {
         unsafe {
             let f = self.inner.__bindgen_anon_2.create_object.unwrap();
             let object = f(self.as_ptr() as *mut _);
@@ -188,7 +211,7 @@ fn find_global_class_entry_ptr(name: impl AsRef<str>) -> *mut zend_class_entry {
 
 pub struct ClassEntity {
     pub(crate) name: String,
-    pub(crate) entry: AtomicPtr<ClassEntry>,
+    pub(crate) entry: AtomicPtr<ClassEntry<Box<dyn Any>>>,
     pub(crate) classifiable: Box<dyn Classifiable>,
     pub(crate) function_entries: OnceCell<AtomicPtr<FunctionEntry>>,
 }
@@ -210,21 +233,23 @@ impl ClassEntity {
             self.function_entries().load(Ordering::SeqCst).cast(),
         );
 
-        let parent = self
+        let parent: Option<&StatelessClassEntry> = self
             .classifiable
             .parent()
             .map(|s| ClassEntry::from_globals(s).unwrap());
 
-        let class: *mut ClassEntry = match parent {
+        let class: *mut ClassEntry<()> = match parent {
             Some(parent) => {
                 zend_register_internal_class_ex(&mut class_ce, parent.as_ptr() as *mut _).cast()
             }
             None => zend_register_internal_class(&mut class_ce).cast(),
         };
-        self.entry.store(class, Ordering::SeqCst);
+        // self.entry.store(class, Ordering::SeqCst);
 
         (*class).inner.__bindgen_anon_2.create_object = Some(create_object);
 
+        get_registered_class_type_map().insert(class as usize, self.classifiable.state_type_id());
+
         // let classifiable = self.classifiable.clone();
         // get_class_constructor_map().insert(class as usize, Box::new(move || classifiable.state_constructor()));
 
@@ -275,7 +300,7 @@ impl ClassEntity {
 
     unsafe fn take_classifiable_into_function_entry(&self) -> zend_function_entry {
         let mut entry = zeroed::<zend_function_entry>();
-        let ptr = &mut entry as *mut _ as *mut ManuallyDrop<Box<StateConstructor<Box<Any>>>>;
+        let ptr = &mut entry as *mut _ as *mut ManuallyDrop<Box<StateConstructor<Box<dyn Any>>>>;
         let state_constructor = ManuallyDrop::new(self.classifiable.state_constructor());
         ptr.write(state_constructor);
         entry
@@ -305,9 +330,14 @@ pub enum Visibility {
     Private = ZEND_ACC_PRIVATE,
 }
 
+fn get_registered_class_type_map() -> &'static DashMap<usize, TypeId> {
+    static MAP: OnceCell<DashMap<usize, TypeId>> = OnceCell::new();
+    MAP.get_or_init(DashMap::new)
+}
+
 fn get_object_handlers() -> &'static zend_object_handlers {
-    static OBJECT_HANDLERS: OnceCell<zend_object_handlers> = OnceCell::new();
-    OBJECT_HANDLERS.get_or_init(|| unsafe {
+    static HANDLERS: OnceCell<zend_object_handlers> = OnceCell::new();
+    HANDLERS.get_or_init(|| unsafe {
         let mut handlers = std_object_handlers;
         handlers.offset = ExtendObject::offset() as c_int;
         handlers.free_obj = Some(free_object);
@@ -333,7 +363,7 @@ unsafe extern "C" fn create_object(ce: *mut zend_class_entry) -> *mut zend_objec
         func_ptr = func_ptr.offset(1);
     }
     func_ptr = func_ptr.offset(1);
-    let state_constructor = func_ptr as *const ManuallyDrop<Box<StateConstructor<Box<Any>>>>;
+    let state_constructor = func_ptr as *const ManuallyDrop<Box<StateConstructor<Box<dyn Any>>>>;
     let state_constructor = state_constructor.read();
 
     // Call the state constructor.

phper/src/errors.rs

@@ -1,12 +1,18 @@
 //! The errors for crate and php.
 
-use crate::{classes::ClassEntry, sys::*, Error::Other};
+use crate::{
+    classes::{ClassEntry, StatelessClassEntry},
+    sys::*,
+    Error::Other,
+};
 use anyhow::anyhow;
-use std::{convert::Infallible, error, ffi::FromBytesWithNulError, io, str::Utf8Error};
+use std::{
+    any::TypeId, 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 {
-    fn class_entry(&self) -> &ClassEntry;
+    fn class_entry(&self) -> &StatelessClassEntry;
 
     fn code(&self) -> u64 {
         0
@@ -18,7 +24,7 @@ pub trait Throwable: error::Error {
 }
 
 impl Throwable for Infallible {
-    fn class_entry(&self) -> &ClassEntry {
+    fn class_entry(&self) -> &StatelessClassEntry {
         unreachable!()
     }
 }
@@ -63,7 +69,7 @@ impl Error {
 
 // TODO Add message() implement.
 impl Throwable for Error {
-    fn class_entry(&self) -> &ClassEntry {
+    fn class_entry(&self) -> &StatelessClassEntry {
         match self {
             Self::Type(e) => e.class_entry(),
             Self::ClassNotFound(e) => e.class_entry(),
@@ -95,7 +101,7 @@ impl TypeError {
 }
 
 impl Throwable for TypeError {
-    fn class_entry(&self) -> &ClassEntry {
+    fn class_entry(&self) -> &ClassEntry<()> {
         ClassEntry::from_globals("TypeError").unwrap()
     }
 }
@@ -113,7 +119,20 @@ impl ClassNotFoundError {
 }
 
 impl Throwable for ClassNotFoundError {
-    fn class_entry(&self) -> &ClassEntry {
+    fn class_entry(&self) -> &StatelessClassEntry {
+        ClassEntry::from_globals("Error").unwrap()
+    }
+}
+
+#[derive(thiserror::Error, Debug)]
+#[error(
+    "Actual State type in generic type parameter isn't the state type registered in the class, \
+please confirm the real state type, or use StatelessClassEntry"
+)]
+pub struct StateTypeError;
+
+impl Throwable for StateTypeError {
+    fn class_entry(&self) -> &StatelessClassEntry {
         ClassEntry::from_globals("Error").unwrap()
     }
 }
@@ -137,7 +156,7 @@ impl ArgumentCountError {
 }
 
 impl Throwable for ArgumentCountError {
-    fn class_entry(&self) -> &ClassEntry {
+    fn class_entry(&self) -> &StatelessClassEntry {
         let class_name = if PHP_VERSION_ID >= 70100 {
             "ArgumentCountError"
         } else {