tract_core/ops/
macros.rs

1#[macro_export]
2macro_rules! as_op {
3    () => {
4        fn as_op(&self) -> &dyn Op {
5            self
6        }
7
8        fn as_op_mut(&mut self) -> &mut dyn Op {
9            self
10        }
11    };
12}
13
14#[macro_export]
15macro_rules! op_as_typed_op {
16    () => {
17        fn as_typed(&self) -> Option<&dyn TypedOp> {
18            Some(self)
19        }
20    };
21}
22
23#[macro_export]
24macro_rules! not_a_typed_op {
25    () => {
26        fn as_typed(&self) -> Option<&dyn TypedOp> {
27            None
28        }
29    };
30}
31
32#[macro_export]
33macro_rules! args_1 {
34    ($inputs:expr) => {{
35        let mut inputs = $inputs;
36        if inputs.len() != 1 {
37            $crate::internal::bail!("Expected 1 arg, got {:?}", inputs)
38        }
39        let result = inputs.pop().unwrap();
40        result
41    }};
42}
43
44#[macro_export]
45macro_rules! args_2 {
46    ($inputs:expr) => {{
47        let mut inputs = $inputs;
48        if inputs.len() != 2 {
49            $crate::internal::bail!("Expected 2 arg, got {:?}", inputs)
50        }
51        inputs.reverse();
52        let result = (inputs.pop().unwrap(), inputs.pop().unwrap());
53        result
54    }};
55}
56
57#[allow(unused_macros)]
58#[macro_export]
59macro_rules! args_3 {
60    ($inputs:expr) => {{
61        let mut inputs = $inputs;
62        if inputs.len() != 3 {
63            $crate::internal::bail!("Expected 3 arg, got {:?}", inputs)
64        }
65        inputs.reverse();
66        let result = (inputs.pop().unwrap(), inputs.pop().unwrap(), inputs.pop().unwrap());
67        result
68    }};
69}
70
71#[allow(unused_macros)]
72#[macro_export]
73macro_rules! args_4 {
74    ($inputs:expr) => {{
75        let mut inputs = $inputs;
76        if inputs.len() != 4 {
77            $crate::internal::bail!("Expected 4 arg, got {:?}", inputs)
78        }
79        inputs.reverse();
80        let result = (
81            inputs.pop().unwrap(),
82            inputs.pop().unwrap(),
83            inputs.pop().unwrap(),
84            inputs.pop().unwrap(),
85        );
86        result
87    }};
88}
89
90#[allow(unused_macros)]
91#[macro_export]
92macro_rules! args_5 {
93    ($inputs:expr) => {{
94        let mut inputs = $inputs;
95        if inputs.len() != 5 {
96            $crate::internal::bail!("Expected 5 arg, got {:?}", inputs)
97        }
98        inputs.reverse();
99        let result = (
100            inputs.pop().unwrap(),
101            inputs.pop().unwrap(),
102            inputs.pop().unwrap(),
103            inputs.pop().unwrap(),
104            inputs.pop().unwrap(),
105        );
106        result
107    }};
108}
109
110#[allow(unused_macros)]
111#[macro_export]
112macro_rules! args_6 {
113    ($inputs:expr) => {{
114        let mut inputs = $inputs;
115        if inputs.len() != 6 {
116            $crate::internal::bail!("Expected 6 arg, got {:?}", inputs)
117        }
118        inputs.reverse();
119        let result = (
120            inputs.pop().unwrap(),
121            inputs.pop().unwrap(),
122            inputs.pop().unwrap(),
123            inputs.pop().unwrap(),
124            inputs.pop().unwrap(),
125            inputs.pop().unwrap(),
126        );
127        result
128    }};
129}
130
131#[allow(unused_macros)]
132#[macro_export]
133macro_rules! args_7 {
134    ($inputs:expr) => {{
135        let mut inputs = $inputs;
136        if inputs.len() != 7 {
137            $crate::internal::bail!("Expected 7 arg, got {:?}", inputs)
138        }
139        inputs.reverse();
140        let result = (
141            inputs.pop().unwrap(),
142            inputs.pop().unwrap(),
143            inputs.pop().unwrap(),
144            inputs.pop().unwrap(),
145            inputs.pop().unwrap(),
146            inputs.pop().unwrap(),
147            inputs.pop().unwrap(),
148        );
149        result
150    }};
151}
152
153#[allow(unused_macros)]
154#[macro_export]
155macro_rules! args_8 {
156    ($inputs:expr) => {{
157        let mut inputs = $inputs;
158        if inputs.len() != 8 {
159            $crate::internal::bail!("Expected 8 arg, got {:?}", inputs)
160        }
161        inputs.reverse();
162        let result = (
163            inputs.pop().unwrap(),
164            inputs.pop().unwrap(),
165            inputs.pop().unwrap(),
166            inputs.pop().unwrap(),
167            inputs.pop().unwrap(),
168            inputs.pop().unwrap(),
169            inputs.pop().unwrap(),
170            inputs.pop().unwrap(),
171        );
172        result
173    }};
174}
175
176#[macro_export]
177macro_rules! impl_op_same_as {
178    () => {
179        fn same_as(&self, other: &dyn Op) -> bool {
180            if let Some(other) = other.downcast_ref::<Self>() {
181                self == other
182            } else {
183                false
184            }
185        }
186    };
187}
188
189#[macro_export]
190macro_rules! assert_close {
191    ($left:expr, $right:expr) => ({
192        match (&$left, &$right) {
193            (left_val, right_val) => {
194                if let Err(e) = left_val.close_enough(right_val, true) {
195                    panic!(r#"assertion failed: `(left ~ right)`
196  left: `{:?}`,
197 right: `{:?}`
198 {:?}"#, left_val, right_val, e)
199                }
200            }
201        }
202    });
203    ($left:expr, $right:expr,) => ({
204        assert_eq!($left, $right)
205    });
206    ($left:expr, $right:expr, $($arg:tt)+) => ({
207        match (&($left), &($right)) {
208            (left_val, right_val) => {
209                if let Err(e) = left_val.close_enough(right_val, true) {
210                    panic!(r#"assertion failed: `(left ~ right)`
211  left: `{:?}`,
212 right: `{:?}`: {}
213 {:?}"#, left_val, right_val,
214                           format_args!($($arg)+), e)
215                }
216            }
217        }
218    });
219}
220
221#[macro_export]
222macro_rules! trivial_op_state_freeeze {
223    ($state:ty) => {
224        impl $crate::ops::FrozenOpState for $state {
225            fn unfreeze(&self) -> Box<dyn OpState> {
226                Box::new(self.clone())
227            }
228        }
229        impl $crate::ops::OpStateFreeze for $state {
230            fn freeze(&self) -> Box<dyn $crate::ops::FrozenOpState> {
231                Box::new(self.clone())
232            }
233        }
234    };
235}
236
tract_core/ops/macros.rs

tract_core/ops/
macros.rs
