1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
|
use tcp_connection::error::TcpTargetError;
use crate::action::{Action, ActionContext};
/// A pool of registered actions that can be processed by name
pub struct ActionPool {
/// HashMap storing action name to action implementation mapping
actions: std::collections::HashMap<&'static str, Box<dyn ActionErased>>,
}
impl ActionPool {
/// Creates a new empty ActionPool
pub fn new() -> Self {
Self {
actions: std::collections::HashMap::new(),
}
}
/// Registers an action type with the pool
///
/// Usage:
/// ```
/// action_pool.register::<MyAction, MyArgs, MyReturn>();
/// ```
pub fn register<A, Args, Return>(&mut self)
where
A: Action<Args, Return> + Send + Sync + 'static,
Args: serde::de::DeserializeOwned + Send + Sync + 'static,
Return: serde::Serialize + Send + Sync + 'static,
{
let action_name = A::action_name();
self.actions.insert(
action_name,
Box::new(ActionWrapper::<A, Args, Return>(std::marker::PhantomData)),
);
}
/// Processes an action by name with given context and arguments
///
/// Usage:
/// ```
/// let result = action_pool.process::<MyArgs, MyReturn>("my_action", context, args).await?;
/// ```
pub async fn process<'a, Args, Return>(
&'a self,
action_name: &'a str,
context: ActionContext,
args: Args,
) -> Result<Return, TcpTargetError>
where
Args: serde::de::DeserializeOwned + Send + 'static,
Return: serde::Serialize + Send + 'static,
{
if let Some(action) = self.actions.get(action_name) {
let result = action.process_erased(context, Box::new(args)).await?;
let result = *result
.downcast::<Return>()
.map_err(|_| TcpTargetError::Unsupported("InvalidArguments".to_string()))?;
Ok(result)
} else {
Err(TcpTargetError::Unsupported("InvalidAction".to_string()))
}
}
}
/// Trait for type-erased actions that can be stored in ActionPool
trait ActionErased: Send + Sync {
/// Processes the action with type-erased arguments and returns type-erased result
fn process_erased(
&self,
context: ActionContext,
args: Box<dyn std::any::Any + Send>,
) -> std::pin::Pin<
Box<
dyn std::future::Future<Output = Result<Box<dyn std::any::Any + Send>, TcpTargetError>>
+ Send,
>,
>;
}
/// Wrapper struct that implements ActionErased for concrete Action types
struct ActionWrapper<A, Args, Return>(std::marker::PhantomData<(A, Args, Return)>);
impl<A, Args, Return> ActionErased for ActionWrapper<A, Args, Return>
where
A: Action<Args, Return> + Send + Sync,
Args: serde::de::DeserializeOwned + Send + Sync + 'static,
Return: serde::Serialize + Send + Sync + 'static,
{
fn process_erased(
&self,
context: ActionContext,
args: Box<dyn std::any::Any + Send>,
) -> std::pin::Pin<
Box<
dyn std::future::Future<Output = Result<Box<dyn std::any::Any + Send>, TcpTargetError>>
+ Send,
>,
> {
Box::pin(async move {
let args = *args
.downcast::<Args>()
.map_err(|_| TcpTargetError::Unsupported("InvalidArguments".to_string()))?;
let result = A::process(context, args).await?;
Ok(Box::new(result) as Box<dyn std::any::Any + Send>)
})
}
}
|
