CYD-UI
A C++ library for building native graphic user interfaces
Loading...
Searching...
No Matches
operators_impl.inc
Go to the documentation of this file.
1
2//* for dimension-T
3
4template <typename T, typename V>
5 requires(not cydui::dimensions::is_dimension_v<V> && not cydui::dimensions::is_expression_v<V>)
6static cydui::dimensions::expression<T>
7OPERATOR(V value, const cydui::dimensions::dimension<T>& dim) {
8 using namespace cydui::dimensions;
9 expression<T> expr{};
10 expr.add_dependency(dim.impl_);
11
12 auto const_value = expr.make_node(expression<T>::node_t::CONSTANT);
13 const_value->const_value = value;
14
15 auto dim_ = expr.make_node(expression<T>::node_t::DIMENSION);
16 dim_->dimension = dim.impl_;
17
18 auto node = expr.make_node(expression<T>::node_t::ENUM);
19 node->children.push_back(const_value);
20 node->children.push_back(dim_);
21
22 expr.tree_ = node;
23 return expr;
24}
25
26template <typename T>
27static cydui::dimensions::expression<T> OPERATOR(
28 const cydui::dimensions::dimension<T>& dim1, const cydui::dimensions::dimension<T>& dim2
29) {
30 using namespace cydui::dimensions;
31 expression<T> expr{};
32 expr.add_dependency(dim1.impl_);
33 expr.add_dependency(dim2.impl_);
34
35 auto dim1_ = expr.make_node(expression<T>::node_t::DIMENSION);
36 dim1_->dimension = dim1.impl_;
37
38 auto dim2_ = expr.make_node(expression<T>::node_t::DIMENSION);
39 dim2_->dimension = dim2.impl_;
40
41 auto node = expr.make_node(expression<T>::node_t::ENUM);
42 node->children.push_back(dim1_);
43 node->children.push_back(dim2_);
44
45 expr.tree_ = node;
46 return expr;
47}
48
49template <typename T, typename V>
50 requires(not cydui::dimensions::is_dimension_v<V> && not cydui::dimensions::is_expression_v<V>)
51static cydui::dimensions::expression<T>
52OPERATOR(const cydui::dimensions::dimension<T>& dim, V value) {
53 using namespace cydui::dimensions;
54 expression<T> expr{};
55 expr.add_dependency(dim.impl_);
56
57 auto dim_ = expr.make_node(expression<T>::node_t::DIMENSION);
58 dim_->dimension = dim.impl_;
59
60 auto const_value = expr.make_node(expression<T>::node_t::CONSTANT);
61 const_value->const_value = value;
62
63 auto node = expr.make_node(expression<T>::node_t::ENUM);
64 node->children = {};
65 node->children.push_back(dim_);
66 node->children.push_back(const_value);
67
68 expr.tree_ = node;
69 return expr;
70}
71
72//* for expression-T
73template <typename T, typename V>
74 requires(not cydui::dimensions::is_dimension_v<V> && not cydui::dimensions::is_expression_v<V>)
75static cydui::dimensions::expression<T>
76OPERATOR(V value, const cydui::dimensions::expression<T>& expr) {
77 using namespace cydui::dimensions;
78 expression<T> expr_{};
79
80 auto const_value = expr_.make_node(expression<T>::node_t::CONSTANT);
81 const_value->const_value = value;
82
83 auto node = expr_.make_node(expression<T>::node_t::ENUM);
84 node->children.push_back(const_value);
85 node->children.push_back(expr_.tree_);
86
87 expr_.tree_ = node;
88 expr_.dependencies_.insert(expr.dependencies_.begin(), expr.dependencies_.end());
89 expr_.parameters_.insert(expr.parameters_.begin(), expr.parameters_.end());
90 return expr_;
91}
92
93template <typename T, typename V>
94 requires(not cydui::dimensions::is_dimension_v<V> && not cydui::dimensions::is_expression_v<V>)
95static cydui::dimensions::expression<T>
96OPERATOR(V value, cydui::dimensions::expression<T>&& expr) {
97 using namespace cydui::dimensions;
98 auto const_value = expr.make_node(expression<T>::node_t::CONSTANT);
99 const_value->const_value = value;
100
101 auto node = expr.make_node(expression<T>::node_t::ENUM);
102 node->children.push_back(const_value);
103 node->children.push_back(expr.tree_);
104
105 expr.tree_ = node;
106 return expr;
107}
108
109template <typename T>
110static cydui::dimensions::expression<T> OPERATOR(
111 const cydui::dimensions::expression<T>& expr1, const cydui::dimensions::expression<T>& expr2
112) {
113 using namespace cydui::dimensions;
114 expression<T> expr{};
115
116 auto node = expr.make_node(expression<T>::node_t::ENUM);
117 node->children = {};
118 node->children.push_back(expr1.tree_);
119 node->children.push_back(expr2.tree_);
120
121 expr.tree_ = node;
122 expr.dependencies_.insert(expr1.dependencies_.begin(), expr1.dependencies_.end());
123 expr.dependencies_.insert(expr2.dependencies_.begin(), expr2.dependencies_.end());
124 expr.parameters_.insert(expr1.parameters_.begin(), expr1.parameters_.end());
125 expr.parameters_.insert(expr2.parameters_.begin(), expr2.parameters_.end());
126 return expr;
127}
128
129template <typename T>
130static cydui::dimensions::expression<T> OPERATOR(
131 cydui::dimensions::expression<T>&& expr1, const cydui::dimensions::expression<T>& expr2
132) {
133 using namespace cydui::dimensions;
134 auto node = expr1.make_node(expression<T>::node_t::ENUM);
135 node->children.push_back(expr1.tree_);
136 node->children.push_back(expr2.tree_);
137
138 expr1.tree_ = node;
139 expr1.dependencies_.insert(expr2.dependencies_.begin(), expr2.dependencies_.end());
140 expr1.parameters_.insert(expr2.parameters_.begin(), expr2.parameters_.end());
141 return expr1;
142}
143
144template <typename T, typename V>
145 requires(not cydui::dimensions::is_dimension_v<V> && not cydui::dimensions::is_expression_v<V>)
146static cydui::dimensions::expression<T>
147OPERATOR(const cydui::dimensions::expression<T>& expr1, V value) {
148 using namespace cydui::dimensions;
149 expression<T> expr{};
150
151 auto const_value = expr.make_node(expression<T>::node_t::CONSTANT);
152 const_value->const_value = value;
153
154 auto node = expr.make_node(expression<T>::node_t::ENUM);
155 node->children.push_back(expr1.tree_);
156 node->children.push_back(const_value);
157
158 expr.tree_ = node;
159 expr.dependencies_.insert(expr1.dependencies_.begin(), expr1.dependencies_.end());
160 expr.parameters_.insert(expr1.parameters_.begin(), expr1.parameters_.end());
161 return expr;
162}
163
164//* for expression-dimension
165template <typename T>
166static cydui::dimensions::expression<T> OPERATOR(
167 const cydui::dimensions::dimension<T>& dim, const cydui::dimensions::expression<T>& expr1
168) {
169 using namespace cydui::dimensions;
170 expression<T> expr{};
171
172 auto dim_ = expr.make_node(expression<T>::node_t::DIMENSION);
173 dim_->dimension = dim.impl_;
174 expr.add_dependency(dim.impl_);
175
176 auto node = expr.make_node(expression<T>::node_t::ENUM);
177 node->children.push_back(dim_);
178 node->children.push_back(expr1.tree_);
179
180 expr.tree_ = node;
181 expr.dependencies_.insert(expr1.dependencies_.begin(), expr1.dependencies_.end());
182 expr.parameters_.insert(expr1.parameters_.begin(), expr1.parameters_.end());
183 return expr;
184}
185
186template <typename T>
187static cydui::dimensions::expression<T> OPERATOR(
188 const cydui::dimensions::expression<T>& expr1, const cydui::dimensions::dimension<T>& dim
189) {
190 using namespace cydui::dimensions;
191 expression<T> expr{};
192
193 auto dim_ = expr.make_node(expression<T>::node_t::DIMENSION);
194 dim_->dimension = dim.impl_;
195 expr.add_dependency(dim.impl_);
196
197 auto node = expr.make_node(expression<T>::node_t::ENUM);
198 node->children.push_back(expr1.tree_);
199 node->children.push_back(dim_);
200
201 expr.tree_ = node;
202 expr.dependencies_.insert(expr1.dependencies_.begin(), expr1.dependencies_.end());
203 expr.parameters_.insert(expr1.parameters_.begin(), expr1.parameters_.end());
204 return expr;
205}
206
207
208// Parameters
209template <typename S>
210static cydui::dimensions::expression<S> OPERATOR(
211 const cydui::dimensions::dimension<S>& lhs, const cydui::dimensions::parameter<S>& rhs
212) {
213 using namespace cydui::dimensions;
214 expression<S> expr{};
215
216 expr.add_dependency(lhs.impl_);
217
218 auto dim_node = expr.make_node(expression<S>::node_t::DIMENSION);
219 dim_node->dimension = lhs.impl_;
220
221 auto param_node = expr.make_node(expression<S>::node_t::PARAMETER);
222 param_node->parameter = rhs;
223
224 auto node = expr.make_node(expression<S>::node_t::ENUM);
225 node->children.push_back(dim_node);
226 node->children.push_back(param_node);
227
228 expr.parameters_.insert(rhs);
229 expr.tree_ = node;
230 return expr;
231}
232
233template <typename S>
234static cydui::dimensions::expression<S> OPERATOR(
235 const cydui::dimensions::parameter<S>& lhs, const cydui::dimensions::dimension<S>& rhs
236) {
237 using namespace cydui::dimensions;
238 expression<S> expr{};
239
240 expr.add_dependency(rhs.impl_);
241
242 auto param_node = expr.make_node(expression<S>::node_t::PARAMETER);
243 param_node->parameter = lhs;
244
245 auto dim_node = expr.make_node(expression<S>::node_t::DIMENSION);
246 dim_node->dimension = rhs.impl_;
247
248 auto node = expr.make_node(expression<S>::node_t::ENUM);
249 node->children.push_back(param_node);
250 node->children.push_back(dim_node);
251
252 expr.parameters_.insert(lhs);
253 expr.tree_ = node;
254 return expr;
255}
256
257template <typename S>
258static cydui::dimensions::expression<S> OPERATOR(
259 const cydui::dimensions::expression<S>& lhs, const cydui::dimensions::parameter<S>& rhs
260) {
261 using namespace cydui::dimensions;
262 expression<S> expr{};
263
264 expr.dependencies_.insert(lhs.dependencies_.begin(), lhs.dependencies_.end());
265 expr.parameters_.insert(lhs.parameters_.begin(), lhs.parameters_.end());
266
267 auto param_node = expr.make_node(expression<S>::node_t::PARAMETER);
268 param_node->parameter = rhs;
269
270 auto node = expr.make_node(expression<S>::node_t::ENUM);
271 node->children.push_back(lhs.tree_);
272 node->children.push_back(param_node);
273
274 expr.parameters_.insert(rhs);
275 expr.tree_ = node;
276 return expr;
277}
278
279template <typename S>
280static cydui::dimensions::expression<S> OPERATOR(
281 const cydui::dimensions::parameter<S>& lhs, const cydui::dimensions::expression<S>& rhs
282) {
283 using namespace cydui::dimensions;
284 expression<S> expr{};
285
286 expr.dependencies_.insert(rhs.dependencies_.begin(), rhs.dependencies_.end());
287 expr.parameters_.insert(rhs.parameters_.begin(), rhs.parameters_.end());
288
289 auto param_node = expr.make_node(expression<S>::node_t::PARAMETER);
290 param_node->parameter = lhs;
291
292 auto node = expr.make_node(expression<S>::node_t::ENUM);
293 node->children.push_back(param_node);
294 node->children.push_back(rhs.tree_);
295
296 expr.parameters_.insert(lhs);
297 expr.tree_ = node;
298 return expr;
299}
300
301template <typename S, typename V>
302 requires(not cydui::dimensions::is_dimension_v<V> && not cydui::dimensions::is_expression_v<V>)
303static cydui::dimensions::expression<S>
304OPERATOR(V lhs, const cydui::dimensions::parameter<S>& rhs) {
305 using namespace cydui::dimensions;
306 expression<S> expr{};
307
308 auto const_value = expr.make_node(expression<S>::node_t::CONSTANT);
309 const_value->const_value = lhs;
310
311 auto param_node = expr.make_node(expression<S>::node_t::PARAMETER);
312 param_node->parameter = rhs;
313
314 auto node = expr.make_node(expression<S>::node_t::ENUM);
315 node->children.push_back(const_value);
316 node->children.push_back(param_node);
317
318 expr.parameters_.insert(rhs);
319 expr.tree_ = node;
320 return expr;
321}
322
323template <typename S, typename V>
324 requires(not cydui::dimensions::is_dimension_v<V> && not cydui::dimensions::is_expression_v<V>)
325static cydui::dimensions::expression<S>
326OPERATOR(const cydui::dimensions::parameter<S>& lhs, V rhs) {
327 using namespace cydui::dimensions;
328 expression<S> expr{};
329
330 auto param_node = expr.make_node(expression<S>::node_t::PARAMETER);
331 param_node->parameter = lhs;
332
333 auto const_value = expr.make_node(expression<S>::node_t::CONSTANT);
334 const_value->const_value = rhs;
335
336 auto node = expr.make_node(expression<S>::node_t::ENUM);
337 node->children.push_back(param_node);
338 node->children.push_back(const_value);
339
340 expr.parameters_.insert(lhs);
341 expr.tree_ = node;
342 return expr;
343}
344
345template <typename S>
346static cydui::dimensions::expression<S> OPERATOR(
347 const cydui::dimensions::parameter<S>& lhs, const cydui::dimensions::parameter<S>& rhs
348) {
349 using namespace cydui::dimensions;
350 expression<S> expr{};
351
352 auto param1_node = expr.make_node(expression<S>::node_t::PARAMETER);
353 param1_node->parameter = lhs;
354
355 auto param2_node = expr.make_node(expression<S>::node_t::PARAMETER);
356 param2_node->parameter = rhs;
357
358 auto node = expr.make_node(expression<S>::node_t::ENUM);
359 node->children.push_back(param1_node);
360 node->children.push_back(param2_node);
361
362 expr.parameters_.insert(lhs);
363 expr.parameters_.insert(rhs);
364 expr.tree_ = node;
365 return expr;
366}
OPERATOR
#define OPERATOR
Definition _types.cppm:98
cydui::dimensions::expression::node_t::DIMENSION
@ DIMENSION
Definition expression.cppm:29
cydui::dimensions::expression::node_t::PARAMETER
@ PARAMETER
Definition expression.cppm:30
cydui::dimensions::expression::node_t::CONSTANT
@ CONSTANT
Definition expression.cppm:28
cydui::dimensions::expression::add_dependency
void add_dependency(std::shared_ptr< dimension_impl< Type > > dependency)
Definition expression.cppm:163
cydui::dimensions::expression::make_node
static node_t::sptr make_node(node_t::operation op)
Definition expression.cppm:167