From 684a24fcf8155bef5fd9b286d7e66375f6c381ce Mon Sep 17 00:00:00 2001 From: yyc12345 Date: Fri, 15 May 2026 16:00:54 +0800 Subject: [PATCH] feat: update cdylib --- Cargo.lock | 46 ++++++++- LICENSE | 2 +- wfassoc-cdylib/Cargo.toml | 1 + wfassoc-cdylib/src/lib.rs | 152 +++++++++++++++++++++++++++--- wfassoc-cdylib/src/object_pool.rs | 21 ++++- 5 files changed, 202 insertions(+), 20 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 6442c8e..c33d988 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -304,6 +304,28 @@ version = "2.7.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273" +[[package]] +name = "num_enum" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d0bca838442ec211fa11de3a8b0e0e8f3a4522575b5c4c06ed722e005036f26" +dependencies = [ + "num_enum_derive", + "rustversion", +] + +[[package]] +name = "num_enum_derive" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "680998035259dcfcafe653688bf2aa6d3e2dc05e98be6ab46afb089dc84f1df8" +dependencies = [ + "proc-macro-crate", + "proc-macro2", + "quote", + "syn", +] + [[package]] name = "once_cell" version = "1.21.3" @@ -339,6 +361,15 @@ dependencies = [ "windows-link", ] +[[package]] +name = "proc-macro-crate" +version = "3.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "219cb19e96be00ab2e37d6e299658a0cfa83e52429179969b0f0121b4ac46983" +dependencies = [ + "toml_edit 0.23.9", +] + [[package]] name = "proc-macro2" version = "1.0.101" @@ -567,7 +598,7 @@ dependencies = [ "serde", "serde_spanned 0.6.9", "toml_datetime 0.6.11", - "toml_edit", + "toml_edit 0.22.27", ] [[package]] @@ -617,6 +648,18 @@ dependencies = [ "winnow", ] +[[package]] +name = "toml_edit" +version = "0.23.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d7cbc3b4b49633d57a0509303158ca50de80ae32c265093b24c414705807832" +dependencies = [ + "indexmap", + "toml_datetime 0.7.3", + "toml_parser", + "winnow", +] + [[package]] name = "toml_parser" version = "1.0.4" @@ -765,6 +808,7 @@ name = "wfassoc-cdylib" version = "0.1.0" dependencies = [ "cbindgen", + "num_enum", "slotmap", "thiserror", "wfassoc", diff --git a/LICENSE b/LICENSE index 5feab28..0988fe5 100644 --- a/LICENSE +++ b/LICENSE @@ -1,6 +1,6 @@ The MIT License (MIT) -Copyright (c) 2022-2025 yyc12345 +Copyright (c) 2022-2026 yyc12345 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/wfassoc-cdylib/Cargo.toml b/wfassoc-cdylib/Cargo.toml index 1187323..02171e1 100644 --- a/wfassoc-cdylib/Cargo.toml +++ b/wfassoc-cdylib/Cargo.toml @@ -13,6 +13,7 @@ crate-type = ["cdylib"] thiserror = { workspace = true } wfassoc = { path="../wfassoc" } slotmap = "1.1.1" +num_enum = "0.7.6" [build-dependencies] cbindgen = "0.29.0" diff --git a/wfassoc-cdylib/src/lib.rs b/wfassoc-cdylib/src/lib.rs index 0b9529a..3cebe84 100644 --- a/wfassoc-cdylib/src/lib.rs +++ b/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>> = + LazyLock::new(|| RwLock::new(ObjectPool::new())); + +static PROGRAM_POOL: LazyLock>> = + 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 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 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>> = - 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>> = - 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 diff --git a/wfassoc-cdylib/src/object_pool.rs b/wfassoc-cdylib/src/object_pool.rs index 2b17ff8..029eb97 100644 --- a/wfassoc-cdylib/src/object_pool.rs +++ b/wfassoc-cdylib/src/object_pool.rs @@ -25,34 +25,40 @@ pub struct ObjectPool { } impl ObjectPool { + /// Create a new [ObjectPool]. pub fn new() -> Self { Self { objs: SlotMap::new(), } } + /// Convert [slotmap] crate's [DefaultKey] to our [Token]. fn key_to_token(key: &DefaultKey) -> Token { key.data().as_ffi() } + /// Convert our [Token] to [slotmap] crate's [DefaultKey]. fn token_to_key(token: Token) -> DefaultKey { DefaultKey::from(KeyData::from_ffi(token)) } + /// Put given object into the pool and return its token. + /// + /// The ownership of given object is transferred to the pool. pub fn allocate(&mut self, value: T) -> Result { let key = self.objs.insert(value); Ok(Self::key_to_token(&key)) } + /// Free the object in the pool corresponding to the given token. pub fn free(&mut self, token: Token) -> Result<(), Error> { let _ = self.pop(token)?; Ok(()) } - pub fn clear(&mut self) -> () { - self.objs.clear(); - } - + /// Remove the object from the pool corresponding to the given token and return it. + /// + /// The ownership of the object is transferred to the caller. pub fn pop(&mut self, token: Token) -> Result { match self.objs.remove(Self::token_to_key(token)) { Some(obj) => Ok(obj), @@ -60,12 +66,19 @@ impl ObjectPool { } } + /// Clear all objects in the pool. + pub fn clear(&mut self) -> () { + self.objs.clear(); + } + + /// Get a reference to the object in the pool corresponding to the given token. pub fn get(&self, token: Token) -> Result<&T, Error> { self.objs .get(Self::token_to_key(token)) .ok_or(Error::NoSuchToken) } + /// Get a mutable reference to the object in the pool corresponding to the given token. pub fn get_mut(&mut self, token: Token) -> Result<&mut T, Error> { self.objs .get_mut(Self::token_to_key(token))