00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029 #ifndef _GLIBCXX_CHRONO
00030 #define _GLIBCXX_CHRONO 1
00031
00032 #pragma GCC system_header
00033
00034 #ifndef __GXX_EXPERIMENTAL_CXX0X__
00035 # include <c++0x_warning.h>
00036 #else
00037
00038 #ifdef _GLIBCXX_INCLUDE_AS_TR1
00039 # error C++0x header cannot be included from TR1 header
00040 #endif
00041
00042 #include <ratio>
00043 #include <type_traits>
00044 #include <limits>
00045 #include <ctime>
00046
00047 #ifdef _GLIBCXX_USE_C99_STDINT_TR1
00048
00049 namespace std
00050 {
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062 namespace chrono
00063 {
00064 template<typename _Rep, typename _Period = ratio<1>>
00065 struct duration;
00066
00067 template<typename _Clock, typename _Duration = typename _Clock::duration>
00068 struct time_point;
00069 }
00070
00071
00072 template<typename _Rep1, typename _Period1, typename _Rep2, typename _Period2>
00073 struct common_type<chrono::duration<_Rep1, _Period1>,
00074 chrono::duration<_Rep2, _Period2>>
00075 {
00076 typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type,
00077 ratio<__static_gcd<_Period1::num, _Period2::num>::value,
00078 (_Period1::den / __static_gcd<_Period1::den, _Period2::den>::value)
00079 * _Period2::den>> type;
00080 };
00081
00082
00083 template<typename _Clock, typename _Duration1, typename _Duration2>
00084 struct common_type<chrono::time_point<_Clock, _Duration1>,
00085 chrono::time_point<_Clock, _Duration2>>
00086 {
00087 typedef chrono::time_point<_Clock,
00088 typename common_type<_Duration1, _Duration2>::type> type;
00089 };
00090
00091 namespace chrono
00092 {
00093
00094 template<typename _ToDuration, typename _CF, typename _CR,
00095 bool _NumIsOne = false, bool _DenIsOne = false>
00096 struct __duration_cast_impl
00097 {
00098 template<typename _Rep, typename _Period>
00099 static _ToDuration __cast(const duration<_Rep, _Period>& __d)
00100 {
00101 return _ToDuration(static_cast<
00102 typename _ToDuration::rep>(static_cast<_CR>(__d.count())
00103 * static_cast<_CR>(_CF::num)
00104 / static_cast<_CR>(_CF::den)));
00105 }
00106 };
00107
00108 template<typename _ToDuration, typename _CF, typename _CR>
00109 struct __duration_cast_impl<_ToDuration, _CF, _CR, true, true>
00110 {
00111 template<typename _Rep, typename _Period>
00112 static _ToDuration __cast(const duration<_Rep, _Period>& __d)
00113 {
00114 return _ToDuration(
00115 static_cast<typename _ToDuration::rep>(__d.count()));
00116 }
00117 };
00118
00119 template<typename _ToDuration, typename _CF, typename _CR>
00120 struct __duration_cast_impl<_ToDuration, _CF, _CR, true, false>
00121 {
00122 template<typename _Rep, typename _Period>
00123 static _ToDuration __cast(const duration<_Rep, _Period>& __d)
00124 {
00125 return _ToDuration(static_cast<typename _ToDuration::rep>(
00126 static_cast<_CR>(__d.count()) / static_cast<_CR>(_CF::den)));
00127 }
00128 };
00129
00130 template<typename _ToDuration, typename _CF, typename _CR>
00131 struct __duration_cast_impl<_ToDuration, _CF, _CR, false, true>
00132 {
00133 template<typename _Rep, typename _Period>
00134 static _ToDuration __cast(const duration<_Rep, _Period>& __d)
00135 {
00136 return _ToDuration(static_cast<typename _ToDuration::rep>(
00137 static_cast<_CR>(__d.count()) * static_cast<_CR>(_CF::num)));
00138 }
00139 };
00140
00141
00142 template<typename _ToDuration, typename _Rep, typename _Period>
00143 inline _ToDuration
00144 duration_cast(const duration<_Rep, _Period>& __d)
00145 {
00146 typedef typename
00147 ratio_divide<_Period, typename _ToDuration::period>::type __cf;
00148 typedef typename
00149 common_type<typename _ToDuration::rep, _Rep, intmax_t>::type __cr;
00150
00151 return __duration_cast_impl<_ToDuration, __cf, __cr,
00152 __cf::num == 1, __cf::den == 1>::__cast(__d);
00153 }
00154
00155
00156 template<typename _Rep>
00157 struct treat_as_floating_point
00158 : is_floating_point<_Rep>
00159 { };
00160
00161
00162 template<typename _Rep>
00163 struct duration_values
00164 {
00165 static const _Rep
00166 zero()
00167 { return _Rep(0); }
00168
00169 static const _Rep
00170 max()
00171 { return numeric_limits<_Rep>::max(); }
00172
00173 static const _Rep
00174 min()
00175 { return numeric_limits<_Rep>::min(); }
00176 };
00177
00178 template<typename _Tp>
00179 struct __is_duration
00180 : std::false_type
00181 { };
00182
00183 template<typename _Rep, typename _Period>
00184 struct __is_duration<duration<_Rep, _Period>>
00185 : std::true_type
00186 { };
00187
00188 template<typename T>
00189 struct __is_ratio
00190 : std::false_type
00191 { };
00192
00193 template<intmax_t _Num, intmax_t _Den>
00194 struct __is_ratio<ratio<_Num, _Den>>
00195 : std::true_type
00196 { };
00197
00198
00199 template<typename _Rep, typename _Period>
00200 struct duration
00201 {
00202 static_assert(!__is_duration<_Rep>::value, "rep cannot be a duration");
00203 static_assert(__is_ratio<_Period>::value,
00204 "period must be a specialization of ratio");
00205 static_assert(_Period::num > 0, "period must be positive");
00206
00207 typedef _Rep rep;
00208 typedef _Period period;
00209
00210
00211 duration() = default;
00212
00213 template<typename _Rep2>
00214 explicit duration(_Rep2 const& __rep)
00215 : __r(static_cast<rep>(__rep))
00216 {
00217 static_assert(is_convertible<_Rep2,rep>::value
00218 && (treat_as_floating_point<rep>::value
00219 || !treat_as_floating_point<_Rep2>::value),
00220 "cannot construct integral duration with floating point type");
00221 }
00222
00223 template<typename _Rep2, typename _Period2>
00224 duration(const duration<_Rep2, _Period2>& __d)
00225 : __r(duration_cast<duration>(__d).count())
00226 {
00227 static_assert(treat_as_floating_point<rep>::value == true
00228 || ratio_divide<_Period2, period>::type::den == 1,
00229 "the resulting duration is not exactly representable");
00230 }
00231
00232 ~duration() = default;
00233 duration(const duration&) = default;
00234 duration& operator=(const duration&) = default;
00235
00236
00237 rep
00238 count() const
00239 { return __r; }
00240
00241
00242 duration
00243 operator+() const
00244 { return *this; }
00245
00246 duration
00247 operator-() const
00248 { return duration(-__r); }
00249
00250 duration&
00251 operator++()
00252 {
00253 ++__r;
00254 return *this;
00255 }
00256
00257 duration
00258 operator++(int)
00259 { return duration(__r++); }
00260
00261 duration&
00262 operator--()
00263 {
00264 --__r;
00265 return *this;
00266 }
00267
00268 duration
00269 operator--(int)
00270 { return duration(__r--); }
00271
00272 duration&
00273 operator+=(const duration& __d)
00274 {
00275 __r += __d.count();
00276 return *this;
00277 }
00278
00279 duration&
00280 operator-=(const duration& __d)
00281 {
00282 __r -= __d.count();
00283 return *this;
00284 }
00285
00286 duration&
00287 operator*=(const rep& __rhs)
00288 {
00289 __r *= __rhs;
00290 return *this;
00291 }
00292
00293 duration&
00294 operator/=(const rep& __rhs)
00295 {
00296 __r /= __rhs;
00297 return *this;
00298 }
00299
00300
00301
00302 static const duration
00303 zero()
00304 { return duration(duration_values<rep>::zero()); }
00305
00306 static const duration
00307 min()
00308 { return duration(duration_values<rep>::min()); }
00309
00310 static const duration
00311 max()
00312 { return duration(duration_values<rep>::max()); }
00313
00314 private:
00315 rep __r;
00316 };
00317
00318 template<typename _Rep1, typename _Period1,
00319 typename _Rep2, typename _Period2>
00320 inline typename common_type<duration<_Rep1, _Period1>,
00321 duration<_Rep2, _Period2>>::type
00322 operator+(const duration<_Rep1, _Period1>& __lhs,
00323 const duration<_Rep2, _Period2>& __rhs)
00324 {
00325 typedef typename common_type<duration<_Rep1, _Period1>,
00326 duration<_Rep2, _Period2>>::type __ct;
00327 return __ct(__lhs) += __rhs;
00328 }
00329
00330 template<typename _Rep1, typename _Period1,
00331 typename _Rep2, typename _Period2>
00332 inline typename common_type<duration<_Rep1, _Period1>,
00333 duration<_Rep2, _Period2>>::type
00334 operator-(const duration<_Rep1, _Period1>& __lhs,
00335 const duration<_Rep2, _Period2>& __rhs)
00336 {
00337 typedef typename common_type<duration<_Rep1, _Period1>,
00338 duration<_Rep2, _Period2>>::type __ct;
00339 return __ct(__lhs) -= __rhs;
00340 }
00341
00342 template<typename _Rep1, typename _Period, typename _Rep2>
00343 inline duration<typename common_type<_Rep1, _Rep2>::type, _Period>
00344 operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
00345 {
00346 typedef typename common_type<_Rep1, _Rep2>::type __cr;
00347 return duration<__cr, _Period>(__d) *= __s;
00348 }
00349
00350 template<typename _Rep1, typename _Period, typename _Rep2>
00351 inline duration<typename common_type<_Rep1, _Rep2>::type, _Period>
00352 operator*(const _Rep2& __s, const duration<_Rep1, _Period>& __d)
00353 { return __d * __s; }
00354
00355 template<typename _Tp, typename _Up, typename _Ep = void>
00356 struct __division_impl;
00357
00358 template<typename _Rep1, typename _Period, typename _Rep2>
00359 struct __division_impl<duration<_Rep1, _Period>, _Rep2,
00360 typename enable_if<!__is_duration<_Rep2>::value>::type>
00361 {
00362 typedef typename common_type<_Rep1, _Rep2>::type __cr;
00363 typedef
00364 duration<typename common_type<_Rep1, _Rep2>::type, _Period> __rt;
00365
00366 static __rt
00367 __divide(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
00368 { return duration<__cr, _Period>(__d) /= __s; }
00369 };
00370
00371 template<typename _Rep1, typename _Period1,
00372 typename _Rep2, typename _Period2>
00373 struct __division_impl<duration<_Rep1, _Period1>,
00374 duration<_Rep2, _Period2>>
00375 {
00376 typedef typename common_type<duration<_Rep1, _Period1>,
00377 duration<_Rep2, _Period2>>::type __ct;
00378 typedef typename common_type<_Rep1, _Rep2>::type __rt;
00379
00380 static __rt
00381 __divide(const duration<_Rep1, _Period1>& __lhs,
00382 const duration<_Rep2, _Period2>& __rhs)
00383 { return __ct(__lhs).count() / __ct(__rhs).count(); }
00384 };
00385
00386 template<typename _Rep, typename _Period, typename _Up>
00387 inline typename __division_impl<duration<_Rep, _Period>, _Up>::__rt
00388 operator/(const duration<_Rep, _Period>& __d, const _Up& __u)
00389 {
00390 return
00391 __division_impl<duration<_Rep, _Period>, _Up>::__divide(__d, __u);
00392 }
00393
00394
00395 template<typename _Rep1, typename _Period1,
00396 typename _Rep2, typename _Period2>
00397 inline bool
00398 operator==(const duration<_Rep1, _Period1>& __lhs,
00399 const duration<_Rep2, _Period2>& __rhs)
00400 {
00401 typedef typename common_type<duration<_Rep1, _Period1>,
00402 duration<_Rep2, _Period2>>::type __ct;
00403 return __ct(__lhs).count() == __ct(__rhs).count();
00404 }
00405
00406 template<typename _Rep1, typename _Period1,
00407 typename _Rep2, typename _Period2>
00408 inline bool
00409 operator<(const duration<_Rep1, _Period1>& __lhs,
00410 const duration<_Rep2, _Period2>& __rhs)
00411 {
00412 typedef typename common_type<duration<_Rep1, _Period1>,
00413 duration<_Rep2, _Period2>>::type __ct;
00414 return __ct(__lhs).count() < __ct(__rhs).count();
00415 }
00416
00417 template<typename _Rep1, typename _Period1,
00418 typename _Rep2, typename _Period2>
00419 inline bool
00420 operator!=(const duration<_Rep1, _Period1>& __lhs,
00421 const duration<_Rep2, _Period2>& __rhs)
00422 { return !(__lhs == __rhs); }
00423
00424 template<typename _Rep1, typename _Period1,
00425 typename _Rep2, typename _Period2>
00426 inline bool
00427 operator<=(const duration<_Rep1, _Period1>& __lhs,
00428 const duration<_Rep2, _Period2>& __rhs)
00429 { return !(__rhs < __lhs); }
00430
00431 template<typename _Rep1, typename _Period1,
00432 typename _Rep2, typename _Period2>
00433 inline bool
00434 operator>(const duration<_Rep1, _Period1>& __lhs,
00435 const duration<_Rep2, _Period2>& __rhs)
00436 { return __rhs < __lhs; }
00437
00438 template<typename _Rep1, typename _Period1,
00439 typename _Rep2, typename _Period2>
00440 inline bool
00441 operator>=(const duration<_Rep1, _Period1>& __lhs,
00442 const duration<_Rep2, _Period2>& __rhs)
00443 { return !(__lhs < __rhs); }
00444
00445
00446 typedef duration<int64_t, nano> nanoseconds;
00447
00448
00449 typedef duration<int64_t, micro> microseconds;
00450
00451
00452 typedef duration<int64_t, milli> milliseconds;
00453
00454
00455 typedef duration<int64_t > seconds;
00456
00457
00458 typedef duration<int, ratio< 60>> minutes;
00459
00460
00461 typedef duration<int, ratio<3600>> hours;
00462
00463
00464 template<typename _Clock, typename _Duration>
00465 struct time_point
00466 {
00467 typedef _Clock clock;
00468 typedef _Duration duration;
00469 typedef typename duration::rep rep;
00470 typedef typename duration::period period;
00471
00472 time_point() : __d(duration::zero())
00473 { }
00474
00475 explicit time_point(const duration& __dur)
00476 : __d(duration::zero() + __dur)
00477 { }
00478
00479
00480 template<typename _Duration2>
00481 time_point(const time_point<clock, _Duration2>& __t)
00482 : __d(__t.time_since_epoch())
00483 { }
00484
00485
00486 duration
00487 time_since_epoch() const
00488 { return __d; }
00489
00490
00491 time_point&
00492 operator+=(const duration& __dur)
00493 {
00494 __d += __dur;
00495 return *this;
00496 }
00497
00498 time_point&
00499 operator-=(const duration& __dur)
00500 {
00501 __d -= __dur;
00502 return *this;
00503 }
00504
00505
00506
00507 static const time_point
00508 min()
00509 { return time_point(duration::min()); }
00510
00511 static const time_point
00512 max()
00513 { return time_point(duration::max()); }
00514
00515 private:
00516 duration __d;
00517 };
00518
00519
00520 template<typename _ToDuration, typename _Clock, typename _Duration>
00521 inline time_point<_Clock, _ToDuration>
00522 time_point_cast(const time_point<_Clock, _Duration>& __t)
00523 {
00524 return time_point<_Clock, _ToDuration>(
00525 duration_cast<_ToDuration>(__t.time_since_epoch()));
00526 }
00527
00528 template<typename _Clock, typename _Duration1,
00529 typename _Rep2, typename _Period2>
00530 inline time_point<_Clock,
00531 typename common_type<_Duration1, duration<_Rep2, _Period2>>::type>
00532 operator+(const time_point<_Clock, _Duration1>& __lhs,
00533 const duration<_Rep2, _Period2>& __rhs)
00534 {
00535 typedef time_point<_Clock,
00536 typename common_type<_Duration1,
00537 duration<_Rep2, _Period2>>::type> __ct;
00538 return __ct(__lhs) += __rhs;
00539 }
00540
00541 template<typename _Rep1, typename _Period1,
00542 typename _Clock, typename _Duration2>
00543 inline time_point<_Clock,
00544 typename common_type<duration<_Rep1, _Period1>, _Duration2>::type>
00545 operator+(const duration<_Rep1, _Period1>& __lhs,
00546 const time_point<_Clock, _Duration2>& __rhs)
00547 { return __rhs + __lhs; }
00548
00549 template<typename _Clock, typename _Duration1,
00550 typename _Rep2, typename _Period2>
00551 inline time_point<_Clock,
00552 typename common_type<_Duration1, duration<_Rep2, _Period2>>::type>
00553 operator-(const time_point<_Clock, _Duration1>& __lhs,
00554 const duration<_Rep2, _Period2>& __rhs)
00555 { return __lhs + (-__rhs); }
00556
00557 template<typename _Clock, typename _Duration1, typename _Duration2>
00558 inline typename common_type<_Duration1, _Duration2>::type
00559 operator-(const time_point<_Clock, _Duration1>& __lhs,
00560 const time_point<_Clock, _Duration2>& __rhs)
00561 { return __lhs.time_since_epoch() - __rhs.time_since_epoch(); }
00562
00563 template<typename _Clock, typename _Duration1, typename _Duration2>
00564 inline bool
00565 operator==(const time_point<_Clock, _Duration1>& __lhs,
00566 const time_point<_Clock, _Duration2>& __rhs)
00567 { return __lhs.time_since_epoch() == __rhs.time_since_epoch(); }
00568
00569 template<typename _Clock, typename _Duration1, typename _Duration2>
00570 inline bool
00571 operator!=(const time_point<_Clock, _Duration1>& __lhs,
00572 const time_point<_Clock, _Duration2>& __rhs)
00573 { return !(__lhs == __rhs); }
00574
00575 template<typename _Clock, typename _Duration1, typename _Duration2>
00576 inline bool
00577 operator<(const time_point<_Clock, _Duration1>& __lhs,
00578 const time_point<_Clock, _Duration2>& __rhs)
00579 { return __lhs.time_since_epoch() < __rhs.time_since_epoch(); }
00580
00581 template<typename _Clock, typename _Duration1, typename _Duration2>
00582 inline bool
00583 operator<=(const time_point<_Clock, _Duration1>& __lhs,
00584 const time_point<_Clock, _Duration2>& __rhs)
00585 { return !(__rhs < __lhs); }
00586
00587 template<typename _Clock, typename _Duration1, typename _Duration2>
00588 inline bool
00589 operator>(const time_point<_Clock, _Duration1>& __lhs,
00590 const time_point<_Clock, _Duration2>& __rhs)
00591 { return __rhs < __lhs; }
00592
00593 template<typename _Clock, typename _Duration1, typename _Duration2>
00594 inline bool
00595 operator>=(const time_point<_Clock, _Duration1>& __lhs,
00596 const time_point<_Clock, _Duration2>& __rhs)
00597 { return !(__lhs < __rhs); }
00598
00599
00600 struct system_clock
00601 {
00602 #ifdef _GLIBCXX_USE_CLOCK_REALTIME
00603 typedef chrono::nanoseconds duration;
00604 #elif defined(_GLIBCXX_USE_GETTIMEOFDAY)
00605 typedef chrono::microseconds duration;
00606 #else
00607 typedef chrono::seconds duration;
00608 #endif
00609
00610 typedef duration::rep rep;
00611 typedef duration::period period;
00612 typedef chrono::time_point<system_clock, duration> time_point;
00613
00614 static const bool is_monotonic = false;
00615
00616 static time_point
00617 now();
00618
00619
00620 static std::time_t
00621 to_time_t(const time_point& __t)
00622 {
00623 return std::time_t(
00624 duration_cast<chrono::seconds>(__t.time_since_epoch()).count());
00625 }
00626
00627 static time_point
00628 from_time_t(std::time_t __t)
00629 {
00630 return time_point_cast<system_clock::duration>(
00631 chrono::time_point<system_clock, chrono::seconds>(
00632 chrono::seconds(__t)));
00633 }
00634
00635
00636
00637
00638
00639
00640
00641
00642 };
00643
00644 #ifdef _GLIBCXX_USE_CLOCK_MONOTONIC
00645
00646 struct monotonic_clock
00647 {
00648 typedef chrono::nanoseconds duration;
00649 typedef duration::rep rep;
00650 typedef duration::period period;
00651 typedef chrono::time_point<monotonic_clock, duration> time_point;
00652
00653 static const bool is_monotonic = true;
00654
00655 static time_point
00656 now();
00657 };
00658 #else
00659 typedef system_clock monotonic_clock;
00660 #endif
00661
00662 typedef system_clock high_resolution_clock;
00663 }
00664
00665
00666 }
00667
00668 #endif //_GLIBCXX_USE_C99_STDINT_TR1
00669
00670 #endif //__GXX_EXPERIMENTAL_CXX0X__
00671
00672 #endif //_GLIBCXX_CHRONO