zero_pool/
macros.rs

1/// Define a task function with automatic parameter dereferencing
2///
3/// This macro creates a task function that safely dereferences the raw
4/// parameter pointer to the specified type, allowing safe access to fields.
5///
6/// # Examples
7/// ```rust
8/// use zero_pool::{zp_define_task_fn, zp_write};
9///
10/// // Define your task parameter struct
11/// struct ComputeTaskStruct { iterations: usize, result: *mut u64 }
12///
13/// zp_define_task_fn!(compute_task, ComputeTaskStruct, |params| {
14///     let mut sum = 0u64;
15///     for i in 0..params.iterations {
16///         sum = sum.wrapping_add(i as u64);
17///     }
18///     zp_write!(params.result, sum);
19/// });
20/// ```
21#[macro_export]
22macro_rules! zp_define_task_fn {
23    ($fn_name:ident, $param_type:ty, |$params:ident| $body:block) => {
24        #[inline(always)]
25        fn $fn_name(raw_params: $crate::TaskParamPointer) {
26            let $params = unsafe { &*(raw_params as *const $param_type) };
27            $body
28        }
29    };
30}
31
32/// Write a result to a raw pointer (eliminates explicit unsafe blocks)
33///
34/// This macro wraps the unsafe pointer dereference, making task code cleaner.
35///
36/// # Examples
37/// ```rust
38/// use zero_pool::{zp_write, zp_define_task_fn};
39///
40/// struct MyTaskStruct { value: u64, result: *mut u64 }
41///
42/// zp_define_task_fn!(my_task, MyTaskStruct, |params| {
43///     let result = 42u64;
44///     zp_write!(params.result, result);
45/// });
46/// ```
47#[macro_export]
48macro_rules! zp_write {
49    ($result_ptr:expr, $value:expr) => {
50        unsafe {
51            *$result_ptr = $value;
52        }
53    };
54}
55
56/// Write a value to a specific index in a collection via raw pointer
57///
58/// This macro eliminates explicit unsafe blocks when writing to indexed collections.
59///
60/// # Examples
61/// ```rust
62/// use zero_pool::{zp_write_indexed, zp_define_task_fn};
63///
64/// struct BatchTaskStruct { index: usize, results: *mut Vec<u64> }
65///
66/// zp_define_task_fn!(batch_task, BatchTaskStruct, |params| {
67///     let sum = 42u64;
68///     zp_write_indexed!(params.results, params.index, sum);
69/// });
70/// ```
71#[macro_export]
72macro_rules! zp_write_indexed {
73    ($collection_ptr:expr, $index:expr, $value:expr) => {
74        unsafe {
75            (&mut (*$collection_ptr))[$index] = $value;
76        }
77    };
78}