]>
Commit | Line | Data |
---|---|---|
1 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and | |
2 | // unit/quantity manipulation and conversion | |
3 | // | |
4 | // Copyright (C) 2003-2008 Matthias Christian Schabel | |
5 | // Copyright (C) 2008 Steven Watanabe | |
6 | // | |
7 | // Distributed under the Boost Software License, Version 1.0. (See | |
8 | // accompanying file LICENSE_1_0.txt or copy at | |
9 | // http://www.boost.org/LICENSE_1_0.txt) | |
10 | ||
11 | // $Id: lambda.hpp 27 2008-06-16 14:50:58Z maehne $ | |
12 | ||
13 | #ifndef BOOST_UNITS_LAMBDA_HPP | |
14 | #define BOOST_UNITS_LAMBDA_HPP | |
15 | ||
16 | ||
17 | //////////////////////////////////////////////////////////////////////// | |
18 | /// | |
19 | /// \file lambda.hpp | |
20 | /// | |
21 | /// \brief Definitions to ease the usage of Boost.Units' quantity, | |
22 | /// unit, and absolute types in functors created with the | |
23 | /// Boost.Lambda library. | |
24 | /// | |
25 | /// \author Torsten Maehne | |
26 | /// \date 2008-06-16 | |
27 | /// | |
28 | /// Boost.Lambda's return type deduction system is extented to make | |
29 | /// use of Boost.Units' typeof_helper trait classes for Boost.Units' | |
30 | /// quantity, absolute, and unit template classes. | |
31 | /// | |
32 | //////////////////////////////////////////////////////////////////////// | |
33 | ||
34 | ||
35 | #include <boost/lambda/lambda.hpp> | |
36 | #include <boost/units/units_fwd.hpp> | |
37 | #include <boost/units/detail/dimensionless_unit.hpp> | |
38 | #include <boost/units/operators.hpp> | |
39 | ||
40 | namespace boost { | |
41 | ||
42 | namespace lambda { | |
43 | ||
44 | /// Partial specialization of return type trait for action | |
45 | /// unit<Dim, System> * Y. | |
46 | template<typename System, typename Dim, typename Y> | |
47 | struct plain_return_type_2<arithmetic_action<multiply_action>, | |
48 | boost::units::unit<Dim, System>, | |
49 | Y > { | |
50 | typedef typename boost::units::multiply_typeof_helper< | |
51 | boost::units::unit<Dim, System>, Y >::type type; | |
52 | }; | |
53 | ||
54 | } // namespace lambda | |
55 | ||
56 | namespace units { | |
57 | ||
58 | template<typename System, typename Dim, typename Arg> | |
59 | struct multiply_typeof_helper<boost::units::unit<Dim, System>, boost::lambda::lambda_functor<Arg> > { | |
60 | typedef boost::lambda::lambda_functor< | |
61 | boost::lambda::lambda_functor_base< | |
62 | boost::lambda::arithmetic_action<boost::lambda::multiply_action>, | |
63 | tuple<typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type, boost::lambda::lambda_functor<Arg> > | |
64 | > | |
65 | > type; | |
66 | }; | |
67 | ||
68 | /// Disambiguating overload for action | |
69 | /// unit<Dim, System> * lambda_functor<Arg> | |
70 | /// based on \<boost/lambda/detail/operators.hpp\>. | |
71 | template<typename System, typename Dim, typename Arg> | |
72 | inline const typename multiply_typeof_helper<boost::units::unit<Dim, System>, boost::lambda::lambda_functor<Arg> >::type | |
73 | operator*(const boost::units::unit<Dim, System>& a, | |
74 | const boost::lambda::lambda_functor<Arg>& b) { | |
75 | return typename multiply_typeof_helper<boost::units::unit<Dim, System>, boost::lambda::lambda_functor<Arg> >::type::inherited | |
76 | (tuple<typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type, | |
77 | boost::lambda::lambda_functor<Arg> > | |
78 | (a, b)); | |
79 | } | |
80 | ||
81 | } // namespace units | |
82 | ||
83 | namespace lambda { | |
84 | ||
85 | /// Partial specialization of return type trait for action | |
86 | /// unit<Dim, System> / Y. | |
87 | template<typename System, typename Dim, typename Y> | |
88 | struct plain_return_type_2<arithmetic_action<divide_action>, | |
89 | boost::units::unit<Dim, System>, | |
90 | Y > { | |
91 | typedef typename boost::units::divide_typeof_helper< | |
92 | boost::units::unit<Dim, System>, Y >::type type; | |
93 | }; | |
94 | ||
95 | } // namespace lambda | |
96 | ||
97 | namespace units { | |
98 | ||
99 | template<typename System, typename Dim, typename Arg> | |
100 | struct divide_typeof_helper<boost::units::unit<Dim, System>, boost::lambda::lambda_functor<Arg> > { | |
101 | typedef boost::lambda::lambda_functor< | |
102 | boost::lambda::lambda_functor_base< | |
103 | boost::lambda::arithmetic_action<boost::lambda::divide_action>, | |
104 | tuple<typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type, boost::lambda::lambda_functor<Arg> > | |
105 | > | |
106 | > type; | |
107 | }; | |
108 | ||
109 | /// Disambiguating overload for action | |
110 | /// unit<Dim, System> / lambda_functor<Arg> | |
111 | /// based on \<boost/lambda/detail/operators.hpp\>. | |
112 | template<typename System, typename Dim, typename Arg> | |
113 | inline const typename divide_typeof_helper<boost::units::unit<Dim, System>, boost::lambda::lambda_functor<Arg> >::type | |
114 | operator/(const boost::units::unit<Dim, System>& a, | |
115 | const boost::lambda::lambda_functor<Arg>& b) { | |
116 | return typename divide_typeof_helper<boost::units::unit<Dim, System>, boost::lambda::lambda_functor<Arg> >::type::inherited | |
117 | (tuple<typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type, | |
118 | boost::lambda::lambda_functor<Arg> > | |
119 | (a, b)); | |
120 | } | |
121 | ||
122 | } // namespace units | |
123 | ||
124 | namespace lambda { | |
125 | ||
126 | /// Partial specialization of return type trait for action | |
127 | /// Y * unit<Dim, System>. | |
128 | template<typename System, typename Dim, typename Y> | |
129 | struct plain_return_type_2<arithmetic_action<multiply_action>, | |
130 | Y, | |
131 | boost::units::unit<Dim, System> > { | |
132 | typedef typename boost::units::multiply_typeof_helper< | |
133 | Y, boost::units::unit<Dim, System> >::type type; | |
134 | }; | |
135 | ||
136 | } // namespace lambda | |
137 | ||
138 | namespace units { | |
139 | ||
140 | template<typename System, typename Dim, typename Arg> | |
141 | struct multiply_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::unit<Dim, System> > { | |
142 | typedef boost::lambda::lambda_functor< | |
143 | boost::lambda::lambda_functor_base< | |
144 | boost::lambda::arithmetic_action<boost::lambda::multiply_action>, | |
145 | tuple<boost::lambda::lambda_functor<Arg>, typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type> | |
146 | > | |
147 | > type; | |
148 | }; | |
149 | ||
150 | /// Disambiguating overload for action | |
151 | /// lambda_functor<Arg> * unit<Dim, System> | |
152 | /// based on \<boost/lambda/detail/operators.hpp\>. | |
153 | template<typename System, typename Dim, typename Arg> | |
154 | inline const typename multiply_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::unit<Dim, System> >::type | |
155 | operator*(const boost::lambda::lambda_functor<Arg>& a, | |
156 | const boost::units::unit<Dim, System>& b) { | |
157 | return typename multiply_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::unit<Dim, System> >::type::inherited | |
158 | (tuple<boost::lambda::lambda_functor<Arg>, | |
159 | typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type> | |
160 | (a, b)); | |
161 | } | |
162 | ||
163 | } // namespace units | |
164 | ||
165 | namespace lambda { | |
166 | ||
167 | /// Partial specialization of return type trait for action | |
168 | /// Y / unit<Dim, System>. | |
169 | template<typename System, typename Dim, typename Y> | |
170 | struct plain_return_type_2<arithmetic_action<divide_action>, | |
171 | Y, | |
172 | boost::units::unit<Dim, System> > { | |
173 | typedef typename boost::units::divide_typeof_helper< | |
174 | Y, boost::units::unit<Dim, System> >::type type; | |
175 | }; | |
176 | ||
177 | } // namespace lambda | |
178 | ||
179 | namespace units { | |
180 | ||
181 | template<typename System, typename Dim, typename Arg> | |
182 | struct divide_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::unit<Dim, System> > { | |
183 | typedef boost::lambda::lambda_functor< | |
184 | boost::lambda::lambda_functor_base< | |
185 | boost::lambda::arithmetic_action<boost::lambda::divide_action>, | |
186 | tuple<boost::lambda::lambda_functor<Arg>, typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type> | |
187 | > | |
188 | > type; | |
189 | }; | |
190 | ||
191 | /// Disambiguating overload for action | |
192 | /// lambda_functor<Arg> / unit<Dim, System> | |
193 | /// based on \<boost/lambda/detail/operators.hpp\>. | |
194 | template<typename System, typename Dim, typename Arg> | |
195 | inline const typename divide_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::unit<Dim, System> >::type | |
196 | operator/(const boost::lambda::lambda_functor<Arg>& a, | |
197 | const boost::units::unit<Dim, System>& b) { | |
198 | return typename divide_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::unit<Dim, System> >::type::inherited | |
199 | (tuple<boost::lambda::lambda_functor<Arg>, | |
200 | typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type> | |
201 | (a, b)); | |
202 | } | |
203 | ||
204 | } // namespace units | |
205 | ||
206 | namespace lambda { | |
207 | ||
208 | /// Partial specialization of return type trait for action | |
209 | /// quantity<Unit, X> * X. | |
210 | template<typename Unit, typename X> | |
211 | struct plain_return_type_2<arithmetic_action<multiply_action>, | |
212 | boost::units::quantity<Unit, X>, | |
213 | X> { | |
214 | typedef typename boost::units::multiply_typeof_helper< | |
215 | boost::units::quantity<Unit, X>, X>::type type; | |
216 | }; | |
217 | ||
218 | /// Partial specialization of return type trait for action | |
219 | /// X * quantity<Unit, X>. | |
220 | template<typename Unit, typename X> | |
221 | struct plain_return_type_2<arithmetic_action<multiply_action>, | |
222 | X, | |
223 | boost::units::quantity<Unit, X> > { | |
224 | typedef typename boost::units::multiply_typeof_helper< | |
225 | X, boost::units::quantity<Unit, X> >::type type; | |
226 | }; | |
227 | ||
228 | /// Partial specialization of return type trait for action | |
229 | /// quantity<Unit, X> / X. | |
230 | template<typename Unit, typename X> | |
231 | struct plain_return_type_2<arithmetic_action<divide_action>, | |
232 | boost::units::quantity<Unit, X>, | |
233 | X> { | |
234 | typedef typename boost::units::divide_typeof_helper< | |
235 | boost::units::quantity<Unit, X>, X>::type type; | |
236 | }; | |
237 | ||
238 | /// Partial specialization of return type trait for action | |
239 | /// X / quantity<Unit, X>. | |
240 | template<typename Unit, typename X> | |
241 | struct plain_return_type_2<arithmetic_action<divide_action>, | |
242 | X, | |
243 | boost::units::quantity<Unit, X> > { | |
244 | typedef typename boost::units::divide_typeof_helper< | |
245 | X, boost::units::quantity<Unit, X> >::type type; | |
246 | }; | |
247 | ||
248 | /// Partial specialization of return type trait for action | |
249 | /// unit<Dim1, System1> * quantity<Unit2, Y>. | |
250 | template<typename System1, typename Dim1, typename Unit2, typename Y> | |
251 | struct plain_return_type_2<arithmetic_action<multiply_action>, | |
252 | boost::units::unit<Dim1, System1>, | |
253 | boost::units::quantity<Unit2, Y> > { | |
254 | typedef typename boost::units::multiply_typeof_helper< | |
255 | boost::units::unit<Dim1, System1>, | |
256 | boost::units::quantity<Unit2, Y> >::type type; | |
257 | }; | |
258 | ||
259 | /// Partial specialization of return type trait for action | |
260 | /// unit<Dim1, System1> / quantity<Unit2, Y>. | |
261 | template<typename System1, typename Dim1, typename Unit2, typename Y> | |
262 | struct plain_return_type_2<arithmetic_action<divide_action>, | |
263 | boost::units::unit<Dim1, System1>, | |
264 | boost::units::quantity<Unit2, Y> > { | |
265 | typedef typename boost::units::divide_typeof_helper< | |
266 | boost::units::unit<Dim1, System1>, | |
267 | boost::units::quantity<Unit2, Y> >::type type; | |
268 | }; | |
269 | ||
270 | /// Partial specialization of return type trait for action | |
271 | /// quantity<Unit1, Y> * unit<Dim2, System2>. | |
272 | template<typename Unit1, typename Y, typename System2, typename Dim2> | |
273 | struct plain_return_type_2<arithmetic_action<multiply_action>, | |
274 | boost::units::quantity<Unit1, Y>, | |
275 | boost::units::unit<Dim2, System2> > { | |
276 | typedef typename boost::units::multiply_typeof_helper< | |
277 | boost::units::quantity<Unit1, Y>, | |
278 | boost::units::unit<Dim2, System2> >::type type; | |
279 | }; | |
280 | ||
281 | /// Partial specialization of return type trait for action | |
282 | /// quantity<Unit1, Y> / unit<Dim2, System2>. | |
283 | template<typename Unit1, typename Y, typename System2, typename Dim2> | |
284 | struct plain_return_type_2<arithmetic_action<divide_action>, | |
285 | boost::units::quantity<Unit1, Y>, | |
286 | boost::units::unit<Dim2, System2> > { | |
287 | typedef typename boost::units::divide_typeof_helper< | |
288 | boost::units::quantity<Unit1, Y>, | |
289 | boost::units::unit<Dim2, System2> >::type type; | |
290 | }; | |
291 | ||
292 | /// Partial specialization of return type trait for action | |
293 | /// +quantity<Unit, Y>. | |
294 | template<typename Unit, typename Y> | |
295 | struct plain_return_type_1<unary_arithmetic_action<plus_action>, | |
296 | boost::units::quantity<Unit, Y> > { | |
297 | typedef typename boost::units::unary_plus_typeof_helper< | |
298 | boost::units::quantity<Unit, Y> >::type type; | |
299 | }; | |
300 | ||
301 | /// Partial specialization of return type trait for action | |
302 | /// -quantity<Unit, Y>. | |
303 | template<typename Unit, typename Y> | |
304 | struct plain_return_type_1<unary_arithmetic_action<minus_action>, | |
305 | boost::units::quantity<Unit, Y> > { | |
306 | typedef typename boost::units::unary_minus_typeof_helper< | |
307 | boost::units::quantity<Unit, Y> >::type type; | |
308 | }; | |
309 | ||
310 | /// Partial specialization of return type trait for action | |
311 | /// quantity<Unit1, X> + quantity<Unit2, Y>. | |
312 | template<typename Unit1, typename X, typename Unit2, typename Y> | |
313 | struct plain_return_type_2<arithmetic_action<plus_action>, | |
314 | boost::units::quantity<Unit1, X>, | |
315 | boost::units::quantity<Unit2, Y> > { | |
316 | typedef typename boost::units::add_typeof_helper< | |
317 | boost::units::quantity<Unit1, X>, | |
318 | boost::units::quantity<Unit2, Y> >::type type; | |
319 | }; | |
320 | ||
321 | /// Partial specialization of return type trait for action | |
322 | /// quantity<dimensionless, X> + Y. | |
323 | template<typename System, typename X, typename Y> | |
324 | struct plain_return_type_2<arithmetic_action<plus_action>, | |
325 | boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), X>, | |
326 | Y> { | |
327 | typedef typename boost::units::add_typeof_helper< | |
328 | boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), X>, | |
329 | Y>::type type; | |
330 | }; | |
331 | ||
332 | /// Partial specialization of return type trait for action | |
333 | /// X + quantity<dimensionless, Y>. | |
334 | template<typename System, typename X, typename Y> | |
335 | struct plain_return_type_2<arithmetic_action<plus_action>, | |
336 | X, | |
337 | boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y> > { | |
338 | typedef typename boost::units::add_typeof_helper< | |
339 | X, | |
340 | boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y> >::type type; | |
341 | }; | |
342 | ||
343 | /// Partial specialization of return type trait for action | |
344 | /// quantity<Unit1, X> - quantity<Unit2, Y>. | |
345 | template<typename Unit1, typename X, typename Unit2, typename Y> | |
346 | struct plain_return_type_2<arithmetic_action<minus_action>, | |
347 | boost::units::quantity<Unit1, X>, | |
348 | boost::units::quantity<Unit2, Y> > { | |
349 | typedef typename boost::units::subtract_typeof_helper< | |
350 | boost::units::quantity<Unit1, X>, | |
351 | boost::units::quantity<Unit2, Y> >::type type; | |
352 | }; | |
353 | ||
354 | /// Partial specialization of return type trait for action | |
355 | /// quantity<dimensionless, X> - Y. | |
356 | template<typename System, typename X, typename Y> | |
357 | struct plain_return_type_2<arithmetic_action<minus_action>, | |
358 | boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), X>, | |
359 | Y> { | |
360 | typedef typename boost::units::subtract_typeof_helper< | |
361 | boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), X>, | |
362 | Y>::type type; | |
363 | }; | |
364 | ||
365 | /// Partial specialization of return type trait for action | |
366 | /// X - quantity<dimensionless, Y>. | |
367 | template<typename System, typename X, typename Y> | |
368 | struct plain_return_type_2<arithmetic_action<minus_action>, | |
369 | X, | |
370 | boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y> > { | |
371 | typedef typename boost::units::subtract_typeof_helper< | |
372 | X, | |
373 | boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y> >::type type; | |
374 | }; | |
375 | ||
376 | /// Partial specialization of return type trait for action | |
377 | /// quantity<Unit1, X> * quantity<Unit2, Y>. | |
378 | template<typename Unit1, typename X, typename Unit2, typename Y> | |
379 | struct plain_return_type_2<arithmetic_action<multiply_action>, | |
380 | boost::units::quantity<Unit1, X>, | |
381 | boost::units::quantity<Unit2, Y> > { | |
382 | typedef typename boost::units::multiply_typeof_helper< | |
383 | boost::units::quantity<Unit1, X>, | |
384 | boost::units::quantity<Unit2, Y> >::type type; | |
385 | }; | |
386 | ||
387 | /// Partial specialization of return type trait for action | |
388 | /// quantity<Unit1, X> / quantity<Unit2, Y>. | |
389 | template<typename Unit1, typename X, typename Unit2, typename Y> | |
390 | struct plain_return_type_2<arithmetic_action<divide_action>, | |
391 | boost::units::quantity<Unit1, X>, | |
392 | boost::units::quantity<Unit2, Y> > { | |
393 | typedef typename boost::units::divide_typeof_helper< | |
394 | boost::units::quantity<Unit1, X>, | |
395 | boost::units::quantity<Unit2, Y> >::type type; | |
396 | }; | |
397 | ||
398 | ||
399 | //////////////////////////////////////////////////////////////////////// | |
400 | // Partial specialization of Boost.Lambda's trait classes for all | |
401 | // operators overloaded in <boost/units/unit.hpp> | |
402 | //////////////////////////////////////////////////////////////////////// | |
403 | ||
404 | /// Partial specialization of return type trait for action | |
405 | /// +unit<Dim, System>. | |
406 | template<typename Dim, typename System> | |
407 | struct plain_return_type_1<unary_arithmetic_action<plus_action>, | |
408 | boost::units::unit<Dim, System> > { | |
409 | typedef typename boost::units::unary_plus_typeof_helper< | |
410 | boost::units::unit<Dim, System> >::type type; | |
411 | }; | |
412 | ||
413 | /// Partial specialization of return type trait for action | |
414 | /// -unit<Dim, System>. | |
415 | template<typename Dim, typename System> | |
416 | struct plain_return_type_1<unary_arithmetic_action<minus_action>, | |
417 | boost::units::unit<Dim, System> > { | |
418 | typedef typename boost::units::unary_minus_typeof_helper< | |
419 | boost::units::unit<Dim, System> >::type type; | |
420 | }; | |
421 | ||
422 | /// Partial specialization of return type trait for action | |
423 | /// unit<Dim1, System1> + unit<Dim2, System2>. | |
424 | template<typename Dim1, typename Dim2, typename System1, typename System2> | |
425 | struct plain_return_type_2<arithmetic_action<plus_action>, | |
426 | boost::units::unit<Dim1, System1>, | |
427 | boost::units::unit<Dim2, System2> > { | |
428 | typedef typename boost::units::add_typeof_helper< | |
429 | boost::units::unit<Dim1, System1>, | |
430 | boost::units::unit<Dim2, System2> >::type type; | |
431 | }; | |
432 | ||
433 | /// Partial specialization of return type trait for action | |
434 | /// unit<Dim1, System1> - unit<Dim2, System2>. | |
435 | template<typename Dim1, typename Dim2, typename System1, typename System2> | |
436 | struct plain_return_type_2<arithmetic_action<minus_action>, | |
437 | boost::units::unit<Dim1, System1>, | |
438 | boost::units::unit<Dim2, System2> > { | |
439 | typedef typename boost::units::subtract_typeof_helper< | |
440 | boost::units::unit<Dim1, System1>, | |
441 | boost::units::unit<Dim2, System2> >::type type; | |
442 | }; | |
443 | ||
444 | /// Partial specialization of return type trait for action | |
445 | /// unit<Dim1, System1> * unit<Dim2, System2>. | |
446 | template<typename Dim1, typename Dim2, typename System1, typename System2> | |
447 | struct plain_return_type_2<arithmetic_action<multiply_action>, | |
448 | boost::units::unit<Dim1, System1>, | |
449 | boost::units::unit<Dim2, System2> > { | |
450 | typedef typename boost::units::multiply_typeof_helper< | |
451 | boost::units::unit<Dim1, System1>, | |
452 | boost::units::unit<Dim2, System2> >::type type; | |
453 | }; | |
454 | ||
455 | /// Partial specialization of return type trait for action | |
456 | /// unit<Dim1, System1> / unit<Dim2, System2>. | |
457 | template<typename Dim1, typename Dim2, typename System1, typename System2> | |
458 | struct plain_return_type_2<arithmetic_action<divide_action>, | |
459 | boost::units::unit<Dim1, System1>, | |
460 | boost::units::unit<Dim2, System2> > { | |
461 | typedef typename boost::units::divide_typeof_helper< | |
462 | boost::units::unit<Dim1, System1>, | |
463 | boost::units::unit<Dim2, System2> >::type type; | |
464 | }; | |
465 | ||
466 | ||
467 | //////////////////////////////////////////////////////////////////////// | |
468 | // Partial specialization of Boost.Lambda's trait classes for all | |
469 | // operators overloaded in <boost/units/absolute.hpp> | |
470 | //////////////////////////////////////////////////////////////////////// | |
471 | ||
472 | ||
473 | /// Partial specialization of return type trait for action | |
474 | /// absolute<Y> + Y. | |
475 | template<typename Y> | |
476 | struct plain_return_type_2<arithmetic_action<plus_action>, | |
477 | boost::units::absolute<Y>, | |
478 | Y> { | |
479 | typedef typename boost::units::absolute<Y> type; | |
480 | }; | |
481 | ||
482 | /// Partial specialization of return type trait for action | |
483 | /// Y + absolute<Y>. | |
484 | template<typename Y> | |
485 | struct plain_return_type_2<arithmetic_action<plus_action>, | |
486 | Y, | |
487 | boost::units::absolute<Y> > { | |
488 | typedef typename boost::units::absolute<Y> type; | |
489 | }; | |
490 | ||
491 | /// Partial specialization of return type trait for action | |
492 | /// absolute<Y> - Y. | |
493 | template<typename Y> | |
494 | struct plain_return_type_2<arithmetic_action<minus_action>, | |
495 | boost::units::absolute<Y>, | |
496 | Y> { | |
497 | typedef typename boost::units::absolute<Y> type; | |
498 | }; | |
499 | ||
500 | /// Partial specialization of return type trait for action | |
501 | /// absolute<Y> - absolute<Y>. | |
502 | template<typename Y> | |
503 | struct plain_return_type_2<arithmetic_action<minus_action>, | |
504 | boost::units::absolute<Y>, | |
505 | boost::units::absolute<Y> > { | |
506 | typedef Y type; | |
507 | }; | |
508 | ||
509 | /// Partial specialization of return type trait for action | |
510 | /// T * absolute<unit<D, S> >. | |
511 | template<typename D, typename S, typename T> | |
512 | struct plain_return_type_2<arithmetic_action<multiply_action>, | |
513 | T, | |
514 | boost::units::absolute<boost::units::unit<D, S> > > { | |
515 | typedef typename boost::units::quantity< | |
516 | boost::units::absolute<boost::units::unit<D, S> >, T> type; | |
517 | }; | |
518 | ||
519 | } // namespace lambda | |
520 | ||
521 | namespace units { | |
522 | ||
523 | template<typename System, typename Dim, typename Arg> | |
524 | struct multiply_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::absolute<boost::units::unit<Dim, System> > > { | |
525 | typedef boost::lambda::lambda_functor< | |
526 | boost::lambda::lambda_functor_base< | |
527 | boost::lambda::arithmetic_action<boost::lambda::multiply_action>, | |
528 | tuple<boost::lambda::lambda_functor<Arg>, | |
529 | typename boost::lambda::const_copy_argument<const boost::units::absolute<boost::units::unit<Dim, System> > >::type> | |
530 | > | |
531 | > type; | |
532 | }; | |
533 | ||
534 | /// Disambiguating overload for action | |
535 | /// lambda_functor<Arg> * absolute<unit<Dim, System> > | |
536 | /// based on \<boost/lambda/detail/operators.hpp\>. | |
537 | template<typename System, typename Dim, typename Arg> | |
538 | inline const typename multiply_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::absolute<boost::units::unit<Dim, System> > >::type | |
539 | operator*(const boost::lambda::lambda_functor<Arg>& a, | |
540 | const boost::units::absolute<boost::units::unit<Dim, System> >& b) { | |
541 | return typename multiply_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::absolute<boost::units::unit<Dim, System> > >::type::inherited | |
542 | (tuple<boost::lambda::lambda_functor<Arg>, | |
543 | typename boost::lambda::const_copy_argument<const boost::units::absolute<boost::units::unit<Dim, System> > >::type> | |
544 | (a, b)); | |
545 | } | |
546 | ||
547 | } // namespace units | |
548 | ||
549 | namespace lambda { | |
550 | ||
551 | /// Partial specialization of return type trait for action | |
552 | /// absolute<unit<D, S> > * T. | |
553 | template<typename D, typename S, typename T> | |
554 | struct plain_return_type_2<arithmetic_action<multiply_action>, | |
555 | boost::units::absolute<boost::units::unit<D, S> >, | |
556 | T> { | |
557 | typedef typename boost::units::quantity< | |
558 | boost::units::absolute<boost::units::unit<D, S> >, T> type; | |
559 | }; | |
560 | ||
561 | } // namespace lambda | |
562 | ||
563 | namespace units { | |
564 | ||
565 | template<typename System, typename Dim, typename Arg> | |
566 | struct multiply_typeof_helper<boost::units::absolute<boost::units::unit<Dim, System> >, boost::lambda::lambda_functor<Arg> > { | |
567 | typedef boost::lambda::lambda_functor< | |
568 | boost::lambda::lambda_functor_base< | |
569 | boost::lambda::arithmetic_action<boost::lambda::multiply_action>, | |
570 | tuple<typename boost::lambda::const_copy_argument<const boost::units::absolute<boost::units::unit<Dim, System> > >::type, | |
571 | boost::lambda::lambda_functor<Arg> > | |
572 | > | |
573 | > type; | |
574 | }; | |
575 | ||
576 | /// Disambiguating overload for action | |
577 | /// absolute<unit<Dim, System> > * lambda_functor<Arg> | |
578 | /// based on \<boost/lambda/detail/operators.hpp\>. | |
579 | template<typename System, typename Dim, typename Arg> | |
580 | inline const typename multiply_typeof_helper<boost::units::absolute<boost::units::unit<Dim, System> >, boost::lambda::lambda_functor<Arg> >::type | |
581 | operator*(const boost::units::absolute<boost::units::unit<Dim, System> >& a, | |
582 | const boost::lambda::lambda_functor<Arg>& b) { | |
583 | return typename multiply_typeof_helper<boost::units::absolute<boost::units::unit<Dim, System> >, boost::lambda::lambda_functor<Arg> >::type::inherited | |
584 | (tuple<typename boost::lambda::const_copy_argument<const boost::units::absolute<boost::units::unit<Dim, System> > >::type, | |
585 | boost::lambda::lambda_functor<Arg> > | |
586 | (a, b)); | |
587 | } | |
588 | ||
589 | } // namespace units | |
590 | ||
591 | } // namespace boost | |
592 | ||
593 | #endif // BOOST_UNITS_LAMBDA_HPP |