feat: update cdylib

wfassoc-cdylib/src/lib.rs

@@ -2,6 +2,7 @@ mod cstr_ffi;
 mod last_error;
 mod object_pool;
 
+use num_enum::TryFromPrimitive;
 use object_pool::ObjectPool;
 use std::sync::{LazyLock, RwLock};
 use thiserror::Error as TeError;
@@ -32,6 +33,9 @@ enum Error {
     #[error("{0}")]
     ObjectPool(#[from] object_pool::Error),
 
+    /// Error occurs when checking enum value
+    #[error("")]
+    EnumOutOfRange,
     /// Error when manipulating with poison RwLock
     #[error("RwLock is poisoning")]
     PoisonRwLock,
@@ -62,6 +66,12 @@ macro_rules! set_out_param {
     };
 }
 
+macro_rules! resolve_enum {
+    ($t:ty, $v:expr) => {
+        <$t>::try_from($v).map_err(|_| Error::EnumOutOfRange)
+    };
+}
+
 macro_rules! pull_reader {
     ($pool:expr) => {
         $pool.read().map_err(|_| Error::PoisonRwLock)
@@ -173,6 +183,54 @@ macro_rules! cffi_wrapper {
 
 // endregion
 
+// region: Object Pools
+
+static SCHEMA_POOL: LazyLock<RwLock<ObjectPool<Schema>>> =
+    LazyLock::new(|| RwLock::new(ObjectPool::new()));
+
+static PROGRAM_POOL: LazyLock<RwLock<ObjectPool<Program>>> =
+    LazyLock::new(|| RwLock::new(ObjectPool::new()));
+
+// endregion
+
+// region: Exposed Types
+
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, TryFromPrimitive)]
+pub enum Scope {
+    User = 0,
+    System = 1,
+}
+
+impl From<Scope> for wfassoc::Scope {
+    fn from(value: Scope) -> Self {
+        match value {
+            Scope::User => wfassoc::Scope::User,
+            Scope::System => wfassoc::Scope::System,
+        }
+    }
+}
+
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, TryFromPrimitive)]
+pub enum View {
+    User,
+    System,
+    Hybrid,
+}
+
+impl From<View> for wfassoc::View {
+    fn from(value: View) -> Self {
+        match value {
+            View::User => wfassoc::View::User,
+            View::System => wfassoc::View::System,
+            View::Hybrid => wfassoc::View::Hybrid,
+        }
+    }
+}
+
+// endregion
+
 // region: Exposed Functions
 
 // region: Facilities
@@ -213,9 +271,6 @@ pub extern "C" fn WFHasPrivilege() -> bool {
 
 // region: Schema
 
-static SCHEMA_POOL: LazyLock<RwLock<ObjectPool<Schema>>> =
-    LazyLock::new(|| RwLock::new(ObjectPool::new()));
-
 #[unsafe(no_mangle)]
 pub extern "C" fn WFSchemaCreate(out_schema: out_param_ty!(Token)) -> bool {
     cffi_wrapper!(|| -> (out_schema: Token) {
@@ -224,6 +279,14 @@ pub extern "C" fn WFSchemaCreate(out_schema: out_param_ty!(Token)) -> bool {
     })
 }
 
+#[unsafe(no_mangle)]
+pub extern "C" fn WFSchemaDestroy(in_schema: in_param_ty!(Token)) -> bool {
+    cffi_wrapper!(|in_schema: Token| {
+        let mut pool = pull_writer!(SCHEMA_POOL)?;
+        Ok(pool.free(in_schema)?)
+    })
+}
+
 #[unsafe(no_mangle)]
 pub extern "C" fn WFSchemaSetIdentifier(
     in_schema: in_param_ty!(Token),
@@ -402,21 +465,10 @@ pub extern "C" fn WFSchemaAddExt(
     })
 }
 
-#[unsafe(no_mangle)]
-pub extern "C" fn WFSchemaDestroy(in_schema: in_param_ty!(Token)) -> bool {
-    cffi_wrapper!(|in_schema: Token| {
-        let mut pool = pull_writer!(SCHEMA_POOL)?;
-        Ok(pool.free(in_schema)?)
-    })
-}
-
 // endregion
 
 // region: Program
 
-static PROGRAM_POOL: LazyLock<RwLock<ObjectPool<Program>>> =
-    LazyLock::new(|| RwLock::new(ObjectPool::new()));
-
 #[unsafe(no_mangle)]
 pub extern "C" fn WFProgramCreate(
     in_schema: in_param_ty!(Token),
@@ -440,6 +492,78 @@ pub extern "C" fn WFProgramDestroy(in_program: in_param_ty!(Token)) -> bool {
     })
 }
 
+#[unsafe(no_mangle)]
+pub extern "C" fn WFProgramRegister(
+    in_program: in_param_ty!(Token),
+    in_scope: in_param_ty!(u32),
+) -> bool {
+    cffi_wrapper!(|in_program: Token, in_scope: u32| {
+        let mut pool = pull_writer!(PROGRAM_POOL)?;
+        let program = pool.get_mut(in_program)?;
+        let scope = resolve_enum!(Scope, in_scope)?;
+        program.register(scope.into())?;
+        Ok(())
+    })
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn WFProgramUnregister(
+    in_program: in_param_ty!(Token),
+    in_scope: in_param_ty!(u32),
+) -> bool {
+    cffi_wrapper!(|in_program: Token, in_scope: u32| {
+        let mut pool = pull_writer!(PROGRAM_POOL)?;
+        let program = pool.get_mut(in_program)?;
+        let scope = resolve_enum!(Scope, in_scope)?;
+        program.unregister(scope.into())?;
+        Ok(())
+    })
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn WFProgramIsRegistered(
+    in_program: in_param_ty!(Token),
+    in_scope: in_param_ty!(u32),
+    out_is_registered: out_param_ty!(bool),
+) -> bool {
+    cffi_wrapper!(|in_program: Token, in_scope: u32| -> (out_is_registered: bool) {
+        let mut pool = pull_writer!(PROGRAM_POOL)?;
+        let program = pool.get_mut(in_program)?;
+        let scope = resolve_enum!(Scope, in_scope)?;
+        Ok(program.is_registered(scope.into())?)
+    })
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn WFProgramLinkExt(
+    in_program: in_param_ty!(Token),
+    in_scope: in_param_ty!(u32),
+    in_index: in_param_ty!(usize),
+) -> bool {
+    cffi_wrapper!(|in_program: Token, in_scope: u32, in_index: usize| {
+        let mut pool = pull_writer!(PROGRAM_POOL)?;
+        let program = pool.get_mut(in_program)?;
+        let scope = resolve_enum!(Scope, in_scope)?;
+        program.link_ext(scope.into(), in_index)?;
+        Ok(())
+    })
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn WFProgramUnlinkExt(
+    in_program: in_param_ty!(Token),
+    in_scope: in_param_ty!(u32),
+    in_index: in_param_ty!(usize),
+) -> bool {
+    cffi_wrapper!(|in_program: Token, in_scope: u32, in_index: usize| {
+        let mut pool = pull_writer!(PROGRAM_POOL)?;
+        let program = pool.get_mut(in_program)?;
+        let scope = resolve_enum!(Scope, in_scope)?;
+        program.unlink_ext(scope.into(), in_index)?;
+        Ok(())
+    })
+}
+
 // endregion
 
 // endregion