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! op_out_of_plan {
34 () => {
35 fn eval_out_of_plan(&self, inputs: TVec<TValue>) -> TractResult<Option<TVec<TValue>>> {
36 Ok(Some(EvalOp::eval(self, &EvalContext::out_of_plan(), inputs)?))
37 }
38 };
39}
40
41#[macro_export]
42macro_rules! not_out_of_plan {
43 () => {
44 fn eval_out_of_plan(&self, _inputs: TVec<TValue>) -> TractResult<Option<TVec<TValue>>> {
45 Ok(None)
46 }
47 };
48}
49
50#[macro_export]
51macro_rules! args_1 {
52 ($inputs:expr) => {{
53 let mut inputs = $inputs;
54 if inputs.len() != 1 {
55 $crate::internal::bail!("Expected 1 arg, got {:?}", inputs)
56 }
57 let result = inputs.pop().unwrap();
58 result
59 }};
60}
61
62#[macro_export]
63macro_rules! args_2 {
64 ($inputs:expr) => {{
65 let mut inputs = $inputs;
66 if inputs.len() != 2 {
67 $crate::internal::bail!("Expected 2 arg, got {:?}", inputs)
68 }
69 inputs.reverse();
70 let result = (inputs.pop().unwrap(), inputs.pop().unwrap());
71 result
72 }};
73}
74
75#[allow(unused_macros)]
76#[macro_export]
77macro_rules! args_3 {
78 ($inputs:expr) => {{
79 let mut inputs = $inputs;
80 if inputs.len() != 3 {
81 $crate::internal::bail!("Expected 3 arg, got {:?}", inputs)
82 }
83 inputs.reverse();
84 let result = (inputs.pop().unwrap(), inputs.pop().unwrap(), inputs.pop().unwrap());
85 result
86 }};
87}
88
89#[allow(unused_macros)]
90#[macro_export]
91macro_rules! args_4 {
92 ($inputs:expr) => {{
93 let mut inputs = $inputs;
94 if inputs.len() != 4 {
95 $crate::internal::bail!("Expected 4 arg, got {:?}", inputs)
96 }
97 inputs.reverse();
98 let result = (
99 inputs.pop().unwrap(),
100 inputs.pop().unwrap(),
101 inputs.pop().unwrap(),
102 inputs.pop().unwrap(),
103 );
104 result
105 }};
106}
107
108#[allow(unused_macros)]
109#[macro_export]
110macro_rules! args_5 {
111 ($inputs:expr) => {{
112 let mut inputs = $inputs;
113 if inputs.len() != 5 {
114 $crate::internal::bail!("Expected 5 arg, got {:?}", inputs)
115 }
116 inputs.reverse();
117 let result = (
118 inputs.pop().unwrap(),
119 inputs.pop().unwrap(),
120 inputs.pop().unwrap(),
121 inputs.pop().unwrap(),
122 inputs.pop().unwrap(),
123 );
124 result
125 }};
126}
127
128#[allow(unused_macros)]
129#[macro_export]
130macro_rules! args_6 {
131 ($inputs:expr) => {{
132 let mut inputs = $inputs;
133 if inputs.len() != 6 {
134 $crate::internal::bail!("Expected 6 arg, got {:?}", inputs)
135 }
136 inputs.reverse();
137 let result = (
138 inputs.pop().unwrap(),
139 inputs.pop().unwrap(),
140 inputs.pop().unwrap(),
141 inputs.pop().unwrap(),
142 inputs.pop().unwrap(),
143 inputs.pop().unwrap(),
144 );
145 result
146 }};
147}
148
149#[allow(unused_macros)]
150#[macro_export]
151macro_rules! args_7 {
152 ($inputs:expr) => {{
153 let mut inputs = $inputs;
154 if inputs.len() != 7 {
155 $crate::internal::bail!("Expected 7 arg, got {:?}", inputs)
156 }
157 inputs.reverse();
158 let result = (
159 inputs.pop().unwrap(),
160 inputs.pop().unwrap(),
161 inputs.pop().unwrap(),
162 inputs.pop().unwrap(),
163 inputs.pop().unwrap(),
164 inputs.pop().unwrap(),
165 inputs.pop().unwrap(),
166 );
167 result
168 }};
169}
170
171#[allow(unused_macros)]
172#[macro_export]
173macro_rules! args_8 {
174 ($inputs:expr) => {{
175 let mut inputs = $inputs;
176 if inputs.len() != 8 {
177 $crate::internal::bail!("Expected 8 arg, got {:?}", inputs)
178 }
179 inputs.reverse();
180 let result = (
181 inputs.pop().unwrap(),
182 inputs.pop().unwrap(),
183 inputs.pop().unwrap(),
184 inputs.pop().unwrap(),
185 inputs.pop().unwrap(),
186 inputs.pop().unwrap(),
187 inputs.pop().unwrap(),
188 inputs.pop().unwrap(),
189 );
190 result
191 }};
192}
193
194#[macro_export]
195macro_rules! assert_close {
196 ($left:expr, $right:expr) => ({
197 match (&$left, &$right) {
198 (left_val, right_val) => {
199 if let Err(e) = left_val.close_enough(right_val, true) {
200 panic!(r#"assertion failed: `(left ~ right)`
201 left: `{:?}`,
202 right: `{:?}`
203 {:?}"#, left_val, right_val, e)
204 }
205 }
206 }
207 });
208 ($left:expr, $right:expr,) => ({
209 assert_eq!($left, $right)
210 });
211 ($left:expr, $right:expr, $($arg:tt)+) => ({
212 match (&($left), &($right)) {
213 (left_val, right_val) => {
214 if let Err(e) = left_val.close_enough(right_val, true) {
215 panic!(r#"assertion failed: `(left ~ right)`
216 left: `{:?}`,
217 right: `{:?}`: {}
218 {:?}"#, left_val, right_val,
219 format_args!($($arg)+), e)
220 }
221 }
222 }
223 });
224}