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 operator *(const boost::units::unit<Dim,System> & a,const boost::lambda::lambda_functor<Arg> & b)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 operator /(const boost::units::unit<Dim,System> & a,const boost::lambda::lambda_functor<Arg> & b)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 operator *(const boost::lambda::lambda_functor<Arg> & a,const boost::units::unit<Dim,System> & b)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 operator /(const boost::lambda::lambda_functor<Arg> & a,const boost::units::unit<Dim,System> & b)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 operator *(const boost::lambda::lambda_functor<Arg> & a,const boost::units::absolute<boost::units::unit<Dim,System>> & b)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 operator *(const boost::units::absolute<boost::units::unit<Dim,System>> & a,const boost::lambda::lambda_functor<Arg> & b)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 594