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        fn $fn_name(raw_params: $crate::TaskParamPointer) {
25            let $params = unsafe { &*(raw_params as *const $param_type) };
26            $body
27        }
28    };
29}
30
31/// Write a result to a raw pointer (eliminates explicit unsafe blocks)
32///
33/// This macro wraps the unsafe pointer dereference, making task code cleaner.
34///
35/// # Examples
36/// ```rust
37/// use zero_pool::{zp_write, zp_define_task_fn};
38///
39/// struct MyTaskStruct { value: u64, result: *mut u64 }
40///
41/// zp_define_task_fn!(my_task, MyTaskStruct, |params| {
42///     let result = 42u64;
43///     zp_write!(params.result, result);
44/// });
45/// ```
46#[macro_export]
47macro_rules! zp_write {
48    ($result_ptr:expr, $value:expr) => {
49        unsafe {
50            *$result_ptr = $value;
51        }
52    };
53}
54
55/// Write a value to a specific index in a collection via raw pointer
56///
57/// This macro eliminates explicit unsafe blocks when writing to indexed collections.
58///
59/// # Examples
60/// ```rust
61/// use zero_pool::{zp_write_indexed, zp_define_task_fn};
62///
63/// struct BatchTaskStruct { index: usize, results: *mut Vec<u64> }
64///
65/// zp_define_task_fn!(batch_task, BatchTaskStruct, |params| {
66///     let sum = 42u64;
67///     zp_write_indexed!(params.results, params.index, sum);
68/// });
69/// ```
70#[macro_export]
71macro_rules! zp_write_indexed {
72    ($collection_ptr:expr, $index:expr, $value:expr) => {
73        unsafe {
74            (&mut (*$collection_ptr))[$index] = $value;
75        }
76    };
77}
78
79/// Submit a batch of mixed task types with type safety
80///
81/// This macro allows submitting tasks of different types in a single batch,
82/// handling the type erasure automatically.
83///
84/// # Examples
85/// ```rust
86/// use zero_pool::{ZeroPool, zp_submit_batch_mixed, zp_define_task_fn, zp_write};
87///
88/// struct Task1Struct { value: u64, result: *mut u64 }
89/// struct Task2Struct { value: u64, result: *mut u64 }
90///
91/// zp_define_task_fn!(task1_fn, Task1Struct, |params| {
92///     zp_write!(params.result, params.value * 2);
93/// });
94/// zp_define_task_fn!(task2_fn, Task2Struct, |params| {
95///     zp_write!(params.result, params.value * 3);
96/// });
97///
98/// let pool = ZeroPool::new();
99/// let mut result1 = 0u64;
100/// let mut result2 = 0u64;
101/// let task1 = Task1Struct { value: 5, result: &mut result1 };
102/// let task2 = Task2Struct { value: 7, result: &mut result2 };
103/// let future = zp_submit_batch_mixed!(pool, [
104///     (&task1, task1_fn),
105///     (&task2, task2_fn),
106/// ]);
107/// future.wait();
108/// ```
109#[macro_export]
110macro_rules! zp_submit_batch_mixed {
111    ($pool:expr, [$( ($params:expr, $task_fn:ident) ),* $(,)?]) => {{
112        let tasks: Vec<$crate::TaskItem> = vec![
113            $(
114                ($task_fn as $crate::TaskFnPointer, $params as *const _ as $crate::TaskParamPointer)
115            ),*
116        ];
117
118        $pool.submit_raw_task_batch(&tasks)
119    }};
120}
zero_pool/macros.rs

zero_pool/
macros.rs
