feat: add example for cdylib

wfassoc-cdylib/src/lib.rs

@@ -1,11 +1,14 @@
-
-use std::ffi::{CString, c_char};
-use thiserror::Error as TeError;
-
-mod object_pool;
-mod last_error;
 mod cstr_ffi;
-mod wrapper;
+mod last_error;
+mod object_pool;
+
+use object_pool::ObjectPool;
+use std::ffi::{CString, c_char};
+use std::sync::{LazyLock, PoisonError, RwLock};
+use thiserror::Error as TeError;
+use wfassoc::highlevel::{Program, Schema};
+
+pub use object_pool::Token;
 
 // region: Error
 
@@ -25,6 +28,13 @@ enum Error {
     /// Error when manipulating with C-style string.
     #[error("{0}")]
     CStrFfi(#[from] cstr_ffi::Error),
+    /// Error when manipulating with object pool.
+    #[error("{0}")]
+    ObjectPool(#[from] object_pool::Error),
+
+    /// Error when manipulating with poison RwLock
+    #[error("RwLock is poisoning")]
+    PoisonRwLock,
 }
 
 /// Result type used in this crate.
@@ -34,9 +44,12 @@ type Result<T> = std::result::Result<T, Error>;
 
 // region: Macros
 
-
 // endregion
 
+// region: Exposed Functions
+
+// region: Facilities
+
 #[unsafe(no_mangle)]
 pub extern "C" fn WFStartup() -> bool {
     true
@@ -59,6 +72,89 @@ pub extern "C" fn WFHasPrivilege() -> bool {
 
 #[unsafe(no_mangle)]
 pub extern "C" fn WFAdd(left: u32, right: u32, rv: *mut u32) -> bool {
-    unsafe { *rv = left + right; }
+    unsafe {
+        *rv = left + right;
+    }
     return true;
 }
+
+// endregion
+
+// region: Schema
+
+const SCHEMA_POOL: LazyLock<RwLock<ObjectPool<Schema>>> =
+    LazyLock::new(|| RwLock::new(ObjectPool::new()));
+
+#[unsafe(no_mangle)]
+pub extern "C" fn WFSchemaCreate(out_token: *mut Token) -> bool {
+    fn inner() -> Result<Token> {
+        let binding = &SCHEMA_POOL;
+        let mut pool = binding.write().map_err(|_| Error::PoisonRwLock)?;
+        Ok(pool.allocate(Schema::new())?)
+    }
+
+    match inner() {
+        Ok(rv) => {
+            unsafe { *out_token = rv };
+            true
+        }
+        Err(e) => {
+            last_error::set_last_error(e.to_string().as_str());
+            false
+        }
+    }
+}
+
+
+#[unsafe(no_mangle)]
+pub extern "C" fn WFSchemaIntoProgram(in_token: Token, out_token: *mut Token) -> bool {
+    fn inner(in_token: Token) -> Result<Token> {
+        let binding = &SCHEMA_POOL;
+        let mut pool = binding.write().map_err(|_| Error::PoisonRwLock)?;
+        let schema = pool.pop(in_token)?;
+
+        let binding = &PROGRAM_POOL;
+        let mut pool = binding.write().map_err(|_| Error::PoisonRwLock)?;
+        let program = schema.into_program()?;
+        Ok(pool.allocate(program)?)
+    }
+
+    match inner(in_token) {
+        Ok(rv) => {
+            unsafe { *out_token = rv };
+            true
+        }
+        Err(e) => {
+            last_error::set_last_error(e.to_string().as_str());
+            false
+        }
+    }
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn WFSchemaDestroy(in_token: Token) -> bool {
+    fn inner(in_token: Token) -> Result<()> {
+        let binding = &SCHEMA_POOL;
+        let mut pool = binding.write().map_err(|_| Error::PoisonRwLock)?;
+        Ok(pool.free(in_token)?)
+    }
+
+    match inner(in_token) {
+        Ok(_) => true,
+        Err(e) => {
+            last_error::set_last_error(e.to_string().as_str());
+            false
+        }
+    }
+}
+
+// endregion
+
+// region: Program
+
+const PROGRAM_POOL: LazyLock<RwLock<ObjectPool<Program>>> =
+    LazyLock::new(|| RwLock::new(ObjectPool::new()));
+
+// endregion
+
+// endregion