1 // duration.hpp --------------------------------------------------------------// 2 3 // Copyright 2008 Howard Hinnant 4 // Copyright 2008 Beman Dawes 5 // Copyright 2009-2011 Vicente J. Botet Escriba 6 7 // Distributed under the Boost Software License, Version 1.0. 8 // See http://www.boost.org/LICENSE_1_0.txt 9 10 /* 11 12 This code was derived by Beman Dawes from Howard Hinnant's time2_demo prototype. 13 Many thanks to Howard for making his code available under the Boost license. 14 The original code was modified to conform to Boost conventions and to section 15 20.9 Time utilities [time] of the C++ committee's working paper N2798. 16 See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2798.pdf. 17 18 time2_demo contained this comment: 19 20 Much thanks to Andrei Alexandrescu, 21 Walter Brown, 22 Peter Dimov, 23 Jeff Garland, 24 Terry Golubiewski, 25 Daniel Krugler, 26 Anthony Williams. 27 */ 28 29 30 #ifndef BOOST_CHRONO_DURATION_HPP 31 #define BOOST_CHRONO_DURATION_HPP 32 33 #include <boost/chrono/config.hpp> 34 #include <boost/chrono/detail/static_assert.hpp> 35 36 #include <climits> 37 #include <limits> 38 39 40 #include <boost/mpl/logical.hpp> 41 #include <boost/ratio/ratio.hpp> 42 #include <boost/type_traits/common_type.hpp> 43 #include <boost/type_traits/is_arithmetic.hpp> 44 #include <boost/type_traits/is_convertible.hpp> 45 #include <boost/type_traits/is_floating_point.hpp> 46 #include <boost/type_traits/is_unsigned.hpp> 47 #include <boost/chrono/detail/is_evenly_divisible_by.hpp> 48 49 #include <boost/cstdint.hpp> 50 #include <boost/utility/enable_if.hpp> 51 #include <boost/detail/workaround.hpp> 52 #include <boost/integer_traits.hpp> 53 54 #if !defined(BOOST_NO_CXX11_STATIC_ASSERT) || !defined(BOOST_CHRONO_USES_MPL_ASSERT) 55 #define BOOST_CHRONO_A_DURATION_REPRESENTATION_CAN_NOT_BE_A_DURATION "A duration representation can not be a duration" 56 #define BOOST_CHRONO_SECOND_TEMPLATE_PARAMETER_OF_DURATION_MUST_BE_A_STD_RATIO "Second template parameter of duration must be a boost::ratio" 57 #define BOOST_CHRONO_DURATION_PERIOD_MUST_BE_POSITIVE "duration period must be positive" 58 #define BOOST_CHRONO_SECOND_TEMPLATE_PARAMETER_OF_TIME_POINT_MUST_BE_A_BOOST_CHRONO_DURATION "Second template parameter of time_point must be a boost::chrono::duration" 59 #endif 60 61 #ifndef BOOST_CHRONO_HEADER_ONLY 62 // this must occur after all of the includes and before any code appears: 63 #include <boost/config/abi_prefix.hpp> // must be the last #include 64 #endif 65 66 //----------------------------------------------------------------------------// 67 // // 68 // 20.9 Time utilities [time] // 69 // synopsis // 70 // // 71 //----------------------------------------------------------------------------// 72 73 namespace boost { 74 namespace chrono { 75 76 template <class Rep, class Period = ratio<1> > 77 class duration; 78 79 namespace detail 80 { 81 template <class T> 82 struct is_duration 83 : boost::false_type {}; 84 85 template <class Rep, class Period> 86 struct is_duration<duration<Rep, Period> > 87 : boost::true_type {}; 88 89 template <class Duration, class Rep, bool = is_duration<Rep>::value> 90 struct duration_divide_result 91 { 92 }; 93 94 template <class Duration, class Rep2, 95 bool = ( 96 ((boost::is_convertible<typename Duration::rep, 97 typename common_type<typename Duration::rep, Rep2>::type>::value)) 98 && ((boost::is_convertible<Rep2, 99 typename common_type<typename Duration::rep, Rep2>::type>::value)) 100 ) 101 > 102 struct duration_divide_imp 103 { 104 }; 105 106 template <class Rep1, class Period, class Rep2> 107 struct duration_divide_imp<duration<Rep1, Period>, Rep2, true> 108 { 109 typedef duration<typename common_type<Rep1, Rep2>::type, Period> type; 110 }; 111 112 template <class Rep1, class Period, class Rep2> 113 struct duration_divide_result<duration<Rep1, Period>, Rep2, false> 114 : duration_divide_imp<duration<Rep1, Period>, Rep2> 115 { 116 }; 117 118 /// 119 template <class Rep, class Duration, bool = is_duration<Rep>::value> 120 struct duration_divide_result2 121 { 122 }; 123 124 template <class Rep, class Duration, 125 bool = ( 126 ((boost::is_convertible<typename Duration::rep, 127 typename common_type<typename Duration::rep, Rep>::type>::value)) 128 && ((boost::is_convertible<Rep, 129 typename common_type<typename Duration::rep, Rep>::type>::value)) 130 ) 131 > 132 struct duration_divide_imp2 133 { 134 }; 135 136 template <class Rep1, class Rep2, class Period > 137 struct duration_divide_imp2<Rep1, duration<Rep2, Period>, true> 138 { 139 //typedef typename common_type<Rep1, Rep2>::type type; 140 typedef double type; 141 }; 142 143 template <class Rep1, class Rep2, class Period > 144 struct duration_divide_result2<Rep1, duration<Rep2, Period>, false> 145 : duration_divide_imp2<Rep1, duration<Rep2, Period> > 146 { 147 }; 148 149 /// 150 template <class Duration, class Rep, bool = is_duration<Rep>::value> 151 struct duration_modulo_result 152 { 153 }; 154 155 template <class Duration, class Rep2, 156 bool = ( 157 //boost::is_convertible<typename Duration::rep, 158 //typename common_type<typename Duration::rep, Rep2>::type>::value 159 //&& 160 boost::is_convertible<Rep2, 161 typename common_type<typename Duration::rep, Rep2>::type>::value 162 ) 163 > 164 struct duration_modulo_imp 165 { 166 }; 167 168 template <class Rep1, class Period, class Rep2> 169 struct duration_modulo_imp<duration<Rep1, Period>, Rep2, true> 170 { 171 typedef duration<typename common_type<Rep1, Rep2>::type, Period> type; 172 }; 173 174 template <class Rep1, class Period, class Rep2> 175 struct duration_modulo_result<duration<Rep1, Period>, Rep2, false> 176 : duration_modulo_imp<duration<Rep1, Period>, Rep2> 177 { 178 }; 179 180 } // namespace detail 181 } // namespace chrono 182 183 184 // common_type trait specializations 185 186 template <class Rep1, class Period1, class Rep2, class Period2> 187 struct common_type<chrono::duration<Rep1, Period1>, 188 chrono::duration<Rep2, Period2> >; 189 190 191 namespace chrono { 192 193 // customization traits 194 template <class Rep> struct treat_as_floating_point; 195 template <class Rep> struct duration_values; 196 197 // convenience typedefs 198 typedef duration<boost::int_least64_t, nano> nanoseconds; // at least 64 bits needed 199 typedef duration<boost::int_least64_t, micro> microseconds; // at least 55 bits needed 200 typedef duration<boost::int_least64_t, milli> milliseconds; // at least 45 bits needed 201 typedef duration<boost::int_least64_t> seconds; // at least 35 bits needed 202 typedef duration<boost::int_least32_t, ratio< 60> > minutes; // at least 29 bits needed 203 typedef duration<boost::int_least32_t, ratio<3600> > hours; // at least 23 bits needed 204 205 //----------------------------------------------------------------------------// 206 // duration helpers // 207 //----------------------------------------------------------------------------// 208 209 namespace detail 210 { 211 212 // duration_cast 213 214 // duration_cast is the heart of this whole prototype. It can convert any 215 // duration to any other. It is also (implicitly) used in converting 216 // time_points. The conversion is always exact if possible. And it is 217 // always as efficient as hand written code. If different representations 218 // are involved, care is taken to never require implicit conversions. 219 // Instead static_cast is used explicitly for every required conversion. 220 // If there are a mixture of integral and floating point representations, 221 // the use of common_type ensures that the most logical "intermediate" 222 // representation is used. 223 template <class FromDuration, class ToDuration, 224 class Period, 225 bool PeriodNumEq1, 226 bool PeriodDenEq1> 227 struct duration_cast_aux; 228 229 // When the two periods are the same, all that is left to do is static_cast from 230 // the source representation to the target representation (which may be a no-op). 231 // This conversion is always exact as long as the static_cast from the source 232 // representation to the destination representation is exact. 233 template <class FromDuration, class ToDuration, class Period> 234 struct duration_cast_aux<FromDuration, ToDuration, Period, true, true> 235 { operator ()boost::chrono::detail::duration_cast_aux236 BOOST_CONSTEXPR ToDuration operator()(const FromDuration& fd) const 237 { 238 return ToDuration(static_cast<typename ToDuration::rep>(fd.count())); 239 } 240 }; 241 242 // When the numerator of FromPeriod / ToPeriod is 1, then all we need to do is 243 // divide by the denominator of FromPeriod / ToPeriod. The common_type of 244 // the two representations is used for the intermediate computation before 245 // static_cast'ing to the destination. 246 // This conversion is generally not exact because of the division (but could be 247 // if you get lucky on the run time value of fd.count()). 248 template <class FromDuration, class ToDuration, class Period> 249 struct duration_cast_aux<FromDuration, ToDuration, Period, true, false> 250 { operator ()boost::chrono::detail::duration_cast_aux251 BOOST_CONSTEXPR ToDuration operator()(const FromDuration& fd) const 252 { 253 typedef typename common_type< 254 typename ToDuration::rep, 255 typename FromDuration::rep, 256 boost::intmax_t>::type C; 257 return ToDuration(static_cast<typename ToDuration::rep>( 258 static_cast<C>(fd.count()) / static_cast<C>(Period::den))); 259 } 260 }; 261 262 // When the denominator of FromPeriod / ToPeriod is 1, then all we need to do is 263 // multiply by the numerator of FromPeriod / ToPeriod. The common_type of 264 // the two representations is used for the intermediate computation before 265 // static_cast'ing to the destination. 266 // This conversion is always exact as long as the static_cast's involved are exact. 267 template <class FromDuration, class ToDuration, class Period> 268 struct duration_cast_aux<FromDuration, ToDuration, Period, false, true> 269 { operator ()boost::chrono::detail::duration_cast_aux270 BOOST_CONSTEXPR ToDuration operator()(const FromDuration& fd) const 271 { 272 typedef typename common_type< 273 typename ToDuration::rep, 274 typename FromDuration::rep, 275 boost::intmax_t>::type C; 276 return ToDuration(static_cast<typename ToDuration::rep>( 277 static_cast<C>(fd.count()) * static_cast<C>(Period::num))); 278 } 279 }; 280 281 // When neither the numerator or denominator of FromPeriod / ToPeriod is 1, then we need to 282 // multiply by the numerator and divide by the denominator of FromPeriod / ToPeriod. The 283 // common_type of the two representations is used for the intermediate computation before 284 // static_cast'ing to the destination. 285 // This conversion is generally not exact because of the division (but could be 286 // if you get lucky on the run time value of fd.count()). 287 template <class FromDuration, class ToDuration, class Period> 288 struct duration_cast_aux<FromDuration, ToDuration, Period, false, false> 289 { operator ()boost::chrono::detail::duration_cast_aux290 BOOST_CONSTEXPR ToDuration operator()(const FromDuration& fd) const 291 { 292 typedef typename common_type< 293 typename ToDuration::rep, 294 typename FromDuration::rep, 295 boost::intmax_t>::type C; 296 return ToDuration(static_cast<typename ToDuration::rep>( 297 static_cast<C>(fd.count()) * static_cast<C>(Period::num) 298 / static_cast<C>(Period::den))); 299 } 300 }; 301 302 template <class FromDuration, class ToDuration> 303 struct duration_cast { 304 typedef typename ratio_divide<typename FromDuration::period, 305 typename ToDuration::period>::type Period; 306 typedef duration_cast_aux< 307 FromDuration, 308 ToDuration, 309 Period, 310 Period::num == 1, 311 Period::den == 1 312 > Aux; operator ()boost::chrono::detail::duration_cast313 BOOST_CONSTEXPR ToDuration operator()(const FromDuration& fd) const 314 { 315 return Aux()(fd); 316 } 317 }; 318 319 } // namespace detail 320 321 //----------------------------------------------------------------------------// 322 // // 323 // 20.9.2 Time-related traits [time.traits] // 324 // // 325 //----------------------------------------------------------------------------// 326 //----------------------------------------------------------------------------// 327 // 20.9.2.1 treat_as_floating_point [time.traits.is_fp] // 328 // Probably should have been treat_as_floating_point. Editor notifed. // 329 //----------------------------------------------------------------------------// 330 331 // Support bidirectional (non-exact) conversions for floating point rep types 332 // (or user defined rep types which specialize treat_as_floating_point). 333 template <class Rep> 334 struct treat_as_floating_point : boost::is_floating_point<Rep> {}; 335 336 //----------------------------------------------------------------------------// 337 // 20.9.2.2 duration_values [time.traits.duration_values] // 338 //----------------------------------------------------------------------------// 339 340 namespace detail { 341 template <class T, bool = is_arithmetic<T>::value> 342 struct chrono_numeric_limits { lowestboost::chrono::detail::chrono_numeric_limits343 static BOOST_CHRONO_LIB_CONSTEXPR T lowest() BOOST_CHRONO_LIB_NOEXCEPT_OR_THROW {return (std::numeric_limits<T>::min) ();} 344 }; 345 346 template <class T> 347 struct chrono_numeric_limits<T,true> { lowestboost::chrono::detail::chrono_numeric_limits348 static BOOST_CHRONO_LIB_CONSTEXPR T lowest() BOOST_CHRONO_LIB_NOEXCEPT_OR_THROW {return (std::numeric_limits<T>::min) ();} 349 }; 350 351 template <> 352 struct chrono_numeric_limits<float,true> { lowestboost::chrono::detail::chrono_numeric_limits353 static BOOST_CHRONO_LIB_CONSTEXPR float lowest() BOOST_CHRONO_LIB_NOEXCEPT_OR_THROW 354 { 355 return -(std::numeric_limits<float>::max) (); 356 } 357 }; 358 359 template <> 360 struct chrono_numeric_limits<double,true> { lowestboost::chrono::detail::chrono_numeric_limits361 static BOOST_CHRONO_LIB_CONSTEXPR double lowest() BOOST_CHRONO_LIB_NOEXCEPT_OR_THROW 362 { 363 return -(std::numeric_limits<double>::max) (); 364 } 365 }; 366 367 template <> 368 struct chrono_numeric_limits<long double,true> { lowestboost::chrono::detail::chrono_numeric_limits369 static BOOST_CHRONO_LIB_CONSTEXPR long double lowest() BOOST_CHRONO_LIB_NOEXCEPT_OR_THROW 370 { 371 return -(std::numeric_limits<long double>::max)(); 372 } 373 }; 374 375 template <class T> 376 struct numeric_limits : chrono_numeric_limits<typename remove_cv<T>::type> 377 {}; 378 379 } 380 template <class Rep> 381 struct duration_values 382 { zeroboost::chrono::duration_values383 static BOOST_CONSTEXPR Rep zero() {return Rep(0);} BOOST_PREVENT_MACRO_SUBSTITUTIONboost::chrono::duration_values384 static BOOST_CHRONO_LIB_CONSTEXPR Rep max BOOST_PREVENT_MACRO_SUBSTITUTION () 385 { 386 return (std::numeric_limits<Rep>::max)(); 387 } 388 BOOST_PREVENT_MACRO_SUBSTITUTIONboost::chrono::duration_values389 static BOOST_CHRONO_LIB_CONSTEXPR Rep min BOOST_PREVENT_MACRO_SUBSTITUTION () 390 { 391 return detail::numeric_limits<Rep>::lowest(); 392 } 393 }; 394 395 } // namespace chrono 396 397 //----------------------------------------------------------------------------// 398 // 20.9.2.3 Specializations of common_type [time.traits.specializations] // 399 //----------------------------------------------------------------------------// 400 401 template <class Rep1, class Period1, class Rep2, class Period2> 402 struct common_type<chrono::duration<Rep1, Period1>, 403 chrono::duration<Rep2, Period2> > 404 { 405 typedef chrono::duration<typename common_type<Rep1, Rep2>::type, 406 typename boost::ratio_gcd<Period1, Period2>::type> type; 407 }; 408 409 410 //----------------------------------------------------------------------------// 411 // // 412 // 20.9.3 Class template duration [time.duration] // 413 // // 414 //----------------------------------------------------------------------------// 415 416 417 namespace chrono { 418 419 template <class Rep, class Period> 420 class BOOST_SYMBOL_VISIBLE duration 421 { 422 //BOOST_CHRONO_STATIC_ASSERT(boost::is_integral<Rep>::value, BOOST_CHRONO_A_DURATION_REPRESENTATION_MUST_BE_INTEGRAL, ()); 423 BOOST_CHRONO_STATIC_ASSERT(!boost::chrono::detail::is_duration<Rep>::value, 424 BOOST_CHRONO_A_DURATION_REPRESENTATION_CAN_NOT_BE_A_DURATION, ()); 425 BOOST_CHRONO_STATIC_ASSERT(boost::ratio_detail::is_ratio<typename Period::type>::value, 426 BOOST_CHRONO_SECOND_TEMPLATE_PARAMETER_OF_DURATION_MUST_BE_A_STD_RATIO, ()); 427 BOOST_CHRONO_STATIC_ASSERT(Period::num>0, 428 BOOST_CHRONO_DURATION_PERIOD_MUST_BE_POSITIVE, ()); 429 public: 430 typedef Rep rep; 431 typedef Period period; 432 private: 433 rep rep_; 434 public: 435 436 #if defined BOOST_NO_CXX11_DEFAULTED_FUNCTIONS 437 BOOST_FORCEINLINE BOOST_CONSTEXPR duration()438 duration() : rep_(duration_values<rep>::zero()) { } 439 #else 440 BOOST_CONSTEXPR duration() BOOST_NOEXCEPT {}; 441 #endif 442 template <class Rep2> 443 BOOST_SYMBOL_VISIBLE BOOST_FORCEINLINE BOOST_CONSTEXPR duration(const Rep2 & r,typename boost::enable_if<mpl::and_<boost::is_convertible<Rep2,rep>,mpl::or_<treat_as_floating_point<rep>,mpl::and_<mpl::not_<treat_as_floating_point<rep>>,mpl::not_<treat_as_floating_point<Rep2>>>>>>::type * =0)444 explicit duration(const Rep2& r 445 , typename boost::enable_if < 446 mpl::and_ < 447 boost::is_convertible<Rep2, rep>, 448 mpl::or_ < 449 treat_as_floating_point<rep>, 450 mpl::and_ < 451 mpl::not_ < treat_as_floating_point<rep> >, 452 mpl::not_ < treat_as_floating_point<Rep2> > 453 > 454 > 455 > 456 >::type* = 0 457 ) : rep_(r) { } 458 #if defined BOOST_NO_CXX11_DEFAULTED_FUNCTIONS operator =(const duration & rhs)459 duration& operator=(const duration& rhs) 460 { 461 if (&rhs != this) rep_= rhs.rep_; 462 return *this; 463 } 464 #else 465 duration& operator=(const duration& rhs) = default; 466 #endif 467 // conversions 468 template <class Rep2, class Period2> 469 BOOST_FORCEINLINE BOOST_CONSTEXPR duration(const duration<Rep2,Period2> & d,typename boost::enable_if<mpl::or_<treat_as_floating_point<rep>,mpl::and_<chrono_detail::is_evenly_divisible_by<Period2,period>,mpl::not_<treat_as_floating_point<Rep2>>>>>::type * =0)470 duration(const duration<Rep2, Period2>& d 471 , typename boost::enable_if < 472 mpl::or_ < 473 treat_as_floating_point<rep>, 474 mpl::and_ < 475 chrono_detail::is_evenly_divisible_by<Period2, period>, 476 mpl::not_ < treat_as_floating_point<Rep2> > 477 > 478 > 479 >::type* = 0 480 ) 481 : rep_(chrono::detail::duration_cast<duration<Rep2, Period2>, duration>()(d).count()) {} 482 483 // observer 484 485 BOOST_CONSTEXPR count() const486 rep count() const {return rep_;} 487 488 // arithmetic 489 490 BOOST_CONSTEXPR operator +() const491 duration operator+() const {return duration(rep_);;} 492 BOOST_CONSTEXPR operator -() const493 duration operator-() const {return duration(-rep_);} operator ++()494 duration& operator++() {++rep_; return *this;} operator ++(int)495 duration operator++(int) {return duration(rep_++);} operator --()496 duration& operator--() {--rep_; return *this;} operator --(int)497 duration operator--(int) {return duration(rep_--);} 498 operator +=(const duration & d)499 duration& operator+=(const duration& d) 500 { 501 rep_ += d.count(); return *this; 502 } operator -=(const duration & d)503 duration& operator-=(const duration& d) 504 { 505 rep_ -= d.count(); return *this; 506 } 507 operator *=(const rep & rhs)508 duration& operator*=(const rep& rhs) {rep_ *= rhs; return *this;} operator /=(const rep & rhs)509 duration& operator/=(const rep& rhs) {rep_ /= rhs; return *this;} operator %=(const rep & rhs)510 duration& operator%=(const rep& rhs) {rep_ %= rhs; return *this;} operator %=(const duration & rhs)511 duration& operator%=(const duration& rhs) 512 { 513 rep_ %= rhs.count(); return *this; 514 } 515 // 20.9.3.4 duration special values [time.duration.special] 516 zero()517 static BOOST_CONSTEXPR duration zero() 518 { 519 return duration(duration_values<rep>::zero()); 520 } BOOST_PREVENT_MACRO_SUBSTITUTION()521 static BOOST_CHRONO_LIB_CONSTEXPR duration min BOOST_PREVENT_MACRO_SUBSTITUTION () 522 { 523 return duration((duration_values<rep>::min)()); 524 } BOOST_PREVENT_MACRO_SUBSTITUTION()525 static BOOST_CHRONO_LIB_CONSTEXPR duration max BOOST_PREVENT_MACRO_SUBSTITUTION () 526 { 527 return duration((duration_values<rep>::max)()); 528 } 529 }; 530 531 //----------------------------------------------------------------------------// 532 // 20.9.3.5 duration non-member arithmetic [time.duration.nonmember] // 533 //----------------------------------------------------------------------------// 534 535 // Duration + 536 537 template <class Rep1, class Period1, class Rep2, class Period2> 538 inline BOOST_CONSTEXPR 539 typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type operator +(const duration<Rep1,Period1> & lhs,const duration<Rep2,Period2> & rhs)540 operator+(const duration<Rep1, Period1>& lhs, 541 const duration<Rep2, Period2>& rhs) 542 { 543 typedef typename common_type<duration<Rep1, Period1>, 544 duration<Rep2, Period2> >::type CD; 545 return CD(CD(lhs).count()+CD(rhs).count()); 546 } 547 548 // Duration - 549 550 template <class Rep1, class Period1, class Rep2, class Period2> 551 inline BOOST_CONSTEXPR 552 typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type operator -(const duration<Rep1,Period1> & lhs,const duration<Rep2,Period2> & rhs)553 operator-(const duration<Rep1, Period1>& lhs, 554 const duration<Rep2, Period2>& rhs) 555 { 556 typedef typename common_type<duration<Rep1, Period1>, 557 duration<Rep2, Period2> >::type CD; 558 return CD(CD(lhs).count()-CD(rhs).count()); 559 } 560 561 // Duration * 562 563 template <class Rep1, class Period, class Rep2> 564 inline BOOST_CONSTEXPR 565 typename boost::enable_if < 566 mpl::and_ < 567 boost::is_convertible<Rep1, typename common_type<Rep1, Rep2>::type>, 568 boost::is_convertible<Rep2, typename common_type<Rep1, Rep2>::type> 569 >, 570 duration<typename common_type<Rep1, Rep2>::type, Period> 571 >::type operator *(const duration<Rep1,Period> & d,const Rep2 & s)572 operator*(const duration<Rep1, Period>& d, const Rep2& s) 573 { 574 typedef typename common_type<Rep1, Rep2>::type CR; 575 typedef duration<CR, Period> CD; 576 return CD(CD(d).count()*static_cast<CR>(s)); 577 } 578 579 template <class Rep1, class Period, class Rep2> 580 inline BOOST_CONSTEXPR 581 typename boost::enable_if < 582 mpl::and_ < 583 boost::is_convertible<Rep1, typename common_type<Rep1, Rep2>::type>, 584 boost::is_convertible<Rep2, typename common_type<Rep1, Rep2>::type> 585 >, 586 duration<typename common_type<Rep1, Rep2>::type, Period> 587 >::type operator *(const Rep1 & s,const duration<Rep2,Period> & d)588 operator*(const Rep1& s, const duration<Rep2, Period>& d) 589 { 590 return d * s; 591 } 592 593 // Duration / 594 595 template <class Rep1, class Period, class Rep2> 596 inline BOOST_CONSTEXPR 597 typename boost::disable_if <boost::chrono::detail::is_duration<Rep2>, 598 typename boost::chrono::detail::duration_divide_result< 599 duration<Rep1, Period>, Rep2>::type 600 >::type operator /(const duration<Rep1,Period> & d,const Rep2 & s)601 operator/(const duration<Rep1, Period>& d, const Rep2& s) 602 { 603 typedef typename common_type<Rep1, Rep2>::type CR; 604 typedef duration<CR, Period> CD; 605 606 return CD(CD(d).count()/static_cast<CR>(s)); 607 } 608 609 template <class Rep1, class Period1, class Rep2, class Period2> 610 inline BOOST_CONSTEXPR 611 typename common_type<Rep1, Rep2>::type operator /(const duration<Rep1,Period1> & lhs,const duration<Rep2,Period2> & rhs)612 operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs) 613 { 614 typedef typename common_type<duration<Rep1, Period1>, 615 duration<Rep2, Period2> >::type CD; 616 return CD(lhs).count() / CD(rhs).count(); 617 } 618 619 #ifdef BOOST_CHRONO_EXTENSIONS 620 template <class Rep1, class Rep2, class Period> 621 inline BOOST_CONSTEXPR 622 typename boost::disable_if <boost::chrono::detail::is_duration<Rep1>, 623 typename boost::chrono::detail::duration_divide_result2< 624 Rep1, duration<Rep2, Period> >::type 625 >::type operator /(const Rep1 & s,const duration<Rep2,Period> & d)626 operator/(const Rep1& s, const duration<Rep2, Period>& d) 627 { 628 typedef typename common_type<Rep1, Rep2>::type CR; 629 typedef duration<CR, Period> CD; 630 631 return static_cast<CR>(s)/CD(d).count(); 632 } 633 #endif 634 // Duration % 635 636 template <class Rep1, class Period, class Rep2> 637 inline BOOST_CONSTEXPR 638 typename boost::disable_if <boost::chrono::detail::is_duration<Rep2>, 639 typename boost::chrono::detail::duration_modulo_result< 640 duration<Rep1, Period>, Rep2>::type 641 >::type operator %(const duration<Rep1,Period> & d,const Rep2 & s)642 operator%(const duration<Rep1, Period>& d, const Rep2& s) 643 { 644 typedef typename common_type<Rep1, Rep2>::type CR; 645 typedef duration<CR, Period> CD; 646 647 return CD(CD(d).count()%static_cast<CR>(s)); 648 } 649 650 template <class Rep1, class Period1, class Rep2, class Period2> 651 inline BOOST_CONSTEXPR 652 typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type operator %(const duration<Rep1,Period1> & lhs,const duration<Rep2,Period2> & rhs)653 operator%(const duration<Rep1, Period1>& lhs, 654 const duration<Rep2, Period2>& rhs) { 655 typedef typename common_type<duration<Rep1, Period1>, 656 duration<Rep2, Period2> >::type CD; 657 658 return CD(CD(lhs).count()%CD(rhs).count()); 659 } 660 661 662 //----------------------------------------------------------------------------// 663 // 20.9.3.6 duration comparisons [time.duration.comparisons] // 664 //----------------------------------------------------------------------------// 665 666 namespace detail 667 { 668 template <class LhsDuration, class RhsDuration> 669 struct duration_eq 670 { operator ()boost::chrono::detail::duration_eq671 BOOST_CONSTEXPR bool operator()(const LhsDuration& lhs, const RhsDuration& rhs) const 672 { 673 typedef typename common_type<LhsDuration, RhsDuration>::type CD; 674 return CD(lhs).count() == CD(rhs).count(); 675 } 676 }; 677 678 template <class LhsDuration> 679 struct duration_eq<LhsDuration, LhsDuration> 680 { operator ()boost::chrono::detail::duration_eq681 BOOST_CONSTEXPR bool operator()(const LhsDuration& lhs, const LhsDuration& rhs) const 682 { 683 return lhs.count() == rhs.count(); 684 } 685 }; 686 687 template <class LhsDuration, class RhsDuration> 688 struct duration_lt 689 { operator ()boost::chrono::detail::duration_lt690 BOOST_CONSTEXPR bool operator()(const LhsDuration& lhs, const RhsDuration& rhs) const 691 { 692 typedef typename common_type<LhsDuration, RhsDuration>::type CD; 693 return CD(lhs).count() < CD(rhs).count(); 694 } 695 }; 696 697 template <class LhsDuration> 698 struct duration_lt<LhsDuration, LhsDuration> 699 { operator ()boost::chrono::detail::duration_lt700 BOOST_CONSTEXPR bool operator()(const LhsDuration& lhs, const LhsDuration& rhs) const 701 { 702 return lhs.count() < rhs.count(); 703 } 704 }; 705 706 } // namespace detail 707 708 // Duration == 709 710 template <class Rep1, class Period1, class Rep2, class Period2> 711 inline BOOST_CONSTEXPR 712 bool operator ==(const duration<Rep1,Period1> & lhs,const duration<Rep2,Period2> & rhs)713 operator==(const duration<Rep1, Period1>& lhs, 714 const duration<Rep2, Period2>& rhs) 715 { 716 return boost::chrono::detail::duration_eq< 717 duration<Rep1, Period1>, duration<Rep2, Period2> >()(lhs, rhs); 718 } 719 720 // Duration != 721 722 template <class Rep1, class Period1, class Rep2, class Period2> 723 inline BOOST_CONSTEXPR 724 bool operator !=(const duration<Rep1,Period1> & lhs,const duration<Rep2,Period2> & rhs)725 operator!=(const duration<Rep1, Period1>& lhs, 726 const duration<Rep2, Period2>& rhs) 727 { 728 return !(lhs == rhs); 729 } 730 731 // Duration < 732 733 template <class Rep1, class Period1, class Rep2, class Period2> 734 inline BOOST_CONSTEXPR 735 bool operator <(const duration<Rep1,Period1> & lhs,const duration<Rep2,Period2> & rhs)736 operator< (const duration<Rep1, Period1>& lhs, 737 const duration<Rep2, Period2>& rhs) 738 { 739 return boost::chrono::detail::duration_lt< 740 duration<Rep1, Period1>, duration<Rep2, Period2> >()(lhs, rhs); 741 } 742 743 // Duration > 744 745 template <class Rep1, class Period1, class Rep2, class Period2> 746 inline BOOST_CONSTEXPR 747 bool operator >(const duration<Rep1,Period1> & lhs,const duration<Rep2,Period2> & rhs)748 operator> (const duration<Rep1, Period1>& lhs, 749 const duration<Rep2, Period2>& rhs) 750 { 751 return rhs < lhs; 752 } 753 754 // Duration <= 755 756 template <class Rep1, class Period1, class Rep2, class Period2> 757 inline BOOST_CONSTEXPR 758 bool operator <=(const duration<Rep1,Period1> & lhs,const duration<Rep2,Period2> & rhs)759 operator<=(const duration<Rep1, Period1>& lhs, 760 const duration<Rep2, Period2>& rhs) 761 { 762 return !(rhs < lhs); 763 } 764 765 // Duration >= 766 767 template <class Rep1, class Period1, class Rep2, class Period2> 768 inline BOOST_CONSTEXPR 769 bool operator >=(const duration<Rep1,Period1> & lhs,const duration<Rep2,Period2> & rhs)770 operator>=(const duration<Rep1, Period1>& lhs, 771 const duration<Rep2, Period2>& rhs) 772 { 773 return !(lhs < rhs); 774 } 775 776 //----------------------------------------------------------------------------// 777 // 20.9.3.7 duration_cast [time.duration.cast] // 778 //----------------------------------------------------------------------------// 779 780 // Compile-time select the most efficient algorithm for the conversion... 781 template <class ToDuration, class Rep, class Period> 782 inline BOOST_CONSTEXPR 783 typename boost::enable_if < 784 boost::chrono::detail::is_duration<ToDuration>, ToDuration>::type duration_cast(const duration<Rep,Period> & fd)785 duration_cast(const duration<Rep, Period>& fd) 786 { 787 return boost::chrono::detail::duration_cast< 788 duration<Rep, Period>, ToDuration>()(fd); 789 } 790 791 } // namespace chrono 792 } // namespace boost 793 794 #ifndef BOOST_CHRONO_HEADER_ONLY 795 // the suffix header occurs after all of our code: 796 #include <boost/config/abi_suffix.hpp> // pops abi_prefix.hpp pragmas 797 #endif 798 799 #endif // BOOST_CHRONO_DURATION_HPP 800