gmt_dos_actors/macros.rs
1#[macro_export]
2macro_rules! count {
3 () => (0usize);
4 ( $x:tt $($xs:tt)* ) => (1usize + count!($($xs)*));
5}
6
7/**
8Macro to build model
9
10## Example
11```ignore
12model!(actor1, actor2, ...)
13```
14*/
15#[macro_export]
16macro_rules! model {
17 ($($x:expr_2021),*) => ($crate::model::Model::new((vec![$(Box::new($x)),*])));
18}
19
20/* #[macro_export]
21macro_rules! impl_update {
22 ($module:ident) => {
23 impl<'a> Update for $module::Controller<'a> {
24 fn update(&mut self) {
25 log::debug!("update");
26 self.next();
27 }
28 }
29 };
30}
31#[macro_export]
32macro_rules! impl_read {
33 ($module:ident, ($var:ident, $val:ident)) => {
34 impl<'a> Read<$var> for $module::Controller<'a> {
35 fn read(&mut self, data: Arc<Data<$var>>) {
36 let $module::U::$var(val) = &mut self.$val;
37 assert_eq!(
38 data.len(),
39 val.len(),
40 "data size ({}) do not match $ident size ({})",
41 data.len(),
42 val.len()
43 );
44 unsafe { ptr::copy_nonoverlapping((**data).as_ptr(), val.as_mut_ptr(), val.len()) }
45 }
46 }
47 };
48 ($data:ty, $module:ident, ($var:ident, $val:ident)) => {
49 impl<'a> Read<$data> for $module::Controller<'a> {
50 fn read(&mut self, data: Arc<Data<$data>>) {
51 if let $module::U::$var(val) = &mut self.$val {
52 assert_eq!(
53 data.len(),
54 val.len(),
55 "data size ({}) do not match $ident size ({})",
56 data.len(),
57 val.len()
58 );
59 unsafe { ptr::copy_nonoverlapping((**data).as_ptr(), val.as_mut_ptr(), val.len()) }
60 }
61 }
62 }
63 };
64 ($module:ident, ($data:ty, $var:ident, $val:ident)) => {
65 impl<'a> Read<$data> for $module::Controller<'a> {
66 fn read(&mut self, data: Arc<Data<$data>>) {
67 if let $module::U::$var(val) = &mut self.$val {
68 assert_eq!(
69 data.len(),
70 val.len(),
71 "data size ({}) do not match $ident size ({})",
72 data.len(),
73 val.len()
74 );
75 unsafe { ptr::copy_nonoverlapping((**data).as_ptr(), val.as_mut_ptr(), val.len()) }
76 }
77 }
78 }
79 };
80 ($module:ident, ($data:ty, $var:ident, $val:ident), $(($datao:ty, $varo:ident, $valo:ident)),+) => {
81 impl<'a> Read<$data> for $module::Controller<'a> {
82 fn read(&mut self, data: Arc<Data<$data>>) {
83 if let $module::U::$var(val) = &mut self.$val {
84 assert_eq!(
85 data.len(),
86 val.len(),
87 "data size ({}) do not match $ident size ({})",
88 data.len(),
89 val.len()
90 );
91 unsafe { ptr::copy_nonoverlapping((**data).as_ptr(), val.as_mut_ptr(), val.len()) }
92 }
93 }
94 }
95 $(
96 impl<'a> Read<$datao> for $module::Controller<'a> {
97 fn read(&mut self, data: Arc<Data<$datao>>) {
98 if let $module::U::$varo(val) = &mut self.$valo {
99 assert_eq!(
100 data.len(),
101 val.len(),
102 "data size ({}) do not match $ident size ({})",
103 data.len(),
104 val.len()
105 );
106 unsafe { ptr::copy_nonoverlapping((**data).as_ptr(), val.as_mut_ptr(), val.len()) }
107 }
108 }
109 }
110 )+
111 };
112 ($module:ident, ($var:ident, $val:ident), $(($varo:ident, $valo:ident)),+) => {
113 impl<'a> Read<$var> for $module::Controller<'a> {
114 fn read(&mut self, data: Arc<Data<$var>>) {
115 if let $module::U::$var(val) = &mut self.$val {
116 assert_eq!(
117 data.len(),
118 val.len(),
119 "data size ({}) do not match $ident size ({})",
120 data.len(),
121 val.len()
122 );
123 unsafe {
124 ptr::copy_nonoverlapping((**data).as_ptr(), val.as_mut_ptr(), val.len())
125 }
126 }
127 }
128 }
129 $(
130 impl<'a> Read<$varo> for $module::Controller<'a> {
131 fn read(&mut self, data: Arc<Data<$varo>>) {
132 if let $module::U::$varo(val) = &mut self.$valo {
133 assert_eq!(
134 data.len(),
135 val.len(),
136 "data size ({}) do not match $ident size ({})",
137 data.len(),
138 val.len()
139 );
140 unsafe {
141 ptr::copy_nonoverlapping((**data).as_ptr(), val.as_mut_ptr(), val.len())
142 }
143 }
144 }
145 }
146 )+
147 };
148}
149#[macro_export]
150macro_rules! impl_write {
151 ($module:ident, ($var:ident, $val:ident)) => {
152 impl<'a> Write<$var> for $module::Controller<'a> {
153 fn write(&mut self) -> Option<Arc<Data<$var>>> {
154 let $module::Y::$var(val) = &mut self.$val;
155 let mut data = vec![0f64; val.len()];
156 unsafe { ptr::copy_nonoverlapping(val.as_ptr(), data.as_mut_ptr(), data.len()) }
157 Some(Arc::new(Data::new(data)))
158 }
159 }
160 };
161 ($data:ty, $module:ident, ($var:ident, $val:ident)) => {
162 impl<'a> Write<$data> for $module::Controller<'a> {
163 fn write(&mut self) -> Option<Arc<Data<$data>>> {
164 if let $module::Y::$var(val) = &mut self.$val {
165 let mut data = vec![0f64; val.len()];
166 unsafe { ptr::copy_nonoverlapping(val.as_ptr(), data.as_mut_ptr(), data.len()) }
167 Some(Arc::new(Data::new(data)))} else {None}
168 }
169 }
170 };
171 ($module:ident, ($data:ty, $var:ident, $val:ident)) => {
172 impl<'a> Write<$data> for $module::Controller<'a> {
173 fn write(&mut self) -> Option<Arc<Data<$data>>> {
174 let $module::Y::$var(val) = &mut self.$val;
175 let mut data = vec![0f64; val.len()];
176 unsafe { ptr::copy_nonoverlapping(val.as_ptr(), data.as_mut_ptr(), data.len()) }
177 Some(Arc::new(Data::new(data)))
178 }
179 }
180 };
181 ($module:ident, ($data:ty, $var:ident, $val:ident), $(($datao:ty, $varo:ident, $valo:ident)),+) => {
182 impl<'a> Write<$data> for $module::Controller<'a> {
183 fn write(&mut self) -> Option<Arc<Data<$data>>> {
184 if let $module::Y::$var(val) = &mut self.$val {
185 let mut data = vec![0f64; val.len()];
186 unsafe { ptr::copy_nonoverlapping(val.as_ptr(), data.as_mut_ptr(), data.len()) }
187 Some(Arc::new(Data::new(data)))} else {None}
188 }
189 }
190 $(
191 impl<'a> Write<$datao> for $module::Controller<'a> {
192 fn write(&mut self) -> Option<Arc<Data<$datao>>> {
193 if let $module::Y::$varo(val) = &mut self.$valo {
194 let mut data = vec![0f64; val.len()];
195 unsafe { ptr::copy_nonoverlapping(val.as_ptr(), data.as_mut_ptr(), data.len()) }
196 Some(Arc::new(Data::new(data)))} else {None}
197 }
198 }
199 )+
200 };
201 ($module:ident, ($var:ident, $val:ident), $(($varo:ident, $valo:ident)),+) => {
202 impl<'a> Write<$var> for $module::Controller<'a> {
203 fn write(&mut self) -> Option<Arc<Data<$var>>> {
204 if let $module::Y::$var(val) = &mut self.$val {
205 let mut data = vec![0f64; val.len()];
206 unsafe { ptr::copy_nonoverlapping(val.as_ptr(), data.as_mut_ptr(), data.len()) }
207 Some(Arc::new(Data::new(data)))} else {None}
208 }
209 }
210 $(
211 impl<'a> Write<$varo> for $module::Controller<'a> {
212 fn write(&mut self) -> Option<Arc<Data<$varo>>> {
213 if let $module::Y::$varo(val) = &mut self.$valo {
214 let mut data = vec![0f64; val.len()];
215 unsafe { ptr::copy_nonoverlapping(val.as_ptr(), data.as_mut_ptr(), data.len()) }
216 Some(Arc::new(Data::new(data)))} else {None}
217 }
218 }
219 )+
220 };
221}
222 */