forked from OSchip/llvm-project
872 lines
29 KiB
C++
872 lines
29 KiB
C++
// -*- C++ -*-
|
|
//===---------------------------- chrono ----------------------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef _LIBCPP_CHRONO
|
|
#define _LIBCPP_CHRONO
|
|
|
|
/*
|
|
chrono synopsis
|
|
|
|
namespace std
|
|
{
|
|
namespace chrono
|
|
{
|
|
|
|
template <class ToDuration, class Rep, class Period>
|
|
ToDuration
|
|
duration_cast(const duration<Rep, Period>& fd);
|
|
|
|
template <class Rep> struct treat_as_floating_point : is_floating_point<Rep> {};
|
|
|
|
template <class Rep>
|
|
struct duration_values
|
|
{
|
|
public:
|
|
static Rep zero();
|
|
static Rep max();
|
|
static Rep min();
|
|
};
|
|
|
|
// duration
|
|
|
|
template <class Rep, class Period = ratio<1>>
|
|
class duration
|
|
{
|
|
static_assert(!__is_duration<Rep>::value, "A duration representation can not be a duration");
|
|
static_assert(__is_ratio<Period>::value, "Second template parameter of duration must be a std::ratio");
|
|
static_assert(Period::num > 0, "duration period must be positive");
|
|
public:
|
|
typedef Rep rep;
|
|
typedef Period period;
|
|
|
|
duration() = default;
|
|
template <class Rep2>
|
|
explicit duration(const Rep2& r,
|
|
typename enable_if
|
|
<
|
|
is_convertible<Rep2, rep>::value &&
|
|
(treat_as_floating_point<rep>::value ||
|
|
!treat_as_floating_point<rep>::value && !treat_as_floating_point<Rep2>::value)
|
|
>::type* = 0);
|
|
|
|
// conversions
|
|
template <class Rep2, class Period2>
|
|
duration(const duration<Rep2, Period2>& d,
|
|
typename enable_if
|
|
<
|
|
treat_as_floating_point<rep>::value ||
|
|
ratio_divide<Period2, period>::type::den == 1
|
|
>::type* = 0);
|
|
|
|
// observer
|
|
|
|
rep count() const;
|
|
|
|
// arithmetic
|
|
|
|
duration operator+() const;
|
|
duration operator-() const;
|
|
duration& operator++();
|
|
duration operator++(int);
|
|
duration& operator--();
|
|
duration operator--(int);
|
|
|
|
duration& operator+=(const duration& d);
|
|
duration& operator-=(const duration& d);
|
|
|
|
duration& operator*=(const rep& rhs);
|
|
duration& operator/=(const rep& rhs);
|
|
|
|
// special values
|
|
|
|
static duration zero();
|
|
static duration min();
|
|
static duration max();
|
|
};
|
|
|
|
typedef duration<long long, nano> nanoseconds;
|
|
typedef duration<long long, micro> microseconds;
|
|
typedef duration<long long, milli> milliseconds;
|
|
typedef duration<long long > seconds;
|
|
typedef duration< long, ratio< 60> > minutes;
|
|
typedef duration< long, ratio<3600> > hours;
|
|
|
|
template <class Clock, class Duration = typename Clock::duration>
|
|
class time_point
|
|
{
|
|
public:
|
|
typedef Clock clock;
|
|
typedef Duration duration;
|
|
typedef typename duration::rep rep;
|
|
typedef typename duration::period period;
|
|
private:
|
|
duration d_; // exposition only
|
|
|
|
public:
|
|
time_point(); // has value "epoch"
|
|
explicit time_point(const duration& d); // same as time_point() + d
|
|
|
|
// conversions
|
|
template <class Duration2>
|
|
time_point(const time_point<clock, Duration2>& t);
|
|
|
|
// observer
|
|
|
|
duration time_since_epoch() const;
|
|
|
|
// arithmetic
|
|
|
|
time_point& operator+=(const duration& d);
|
|
time_point& operator-=(const duration& d);
|
|
|
|
// special values
|
|
|
|
static constexpr time_point min();
|
|
static constexpr time_point max();
|
|
};
|
|
|
|
} // chrono
|
|
|
|
// common_type traits
|
|
template <class Rep1, class Period1, class Rep2, class Period2>
|
|
struct common_type<chrono::duration<Rep1, Period1>, chrono::duration<Rep2, Period2>>;
|
|
|
|
template <class Clock, class Duration1, class Duration2>
|
|
struct common_type<chrono::time_point<Clock, Duration1>, chrono::time_point<Clock, Duration2>>;
|
|
|
|
namespace chrono {
|
|
|
|
// duration arithmetic
|
|
template <class Rep1, class Period1, class Rep2, class Period2>
|
|
typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
|
|
operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
|
|
template <class Rep1, class Period1, class Rep2, class Period2>
|
|
typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
|
|
operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
|
|
template <class Rep1, class Period, class Rep2>
|
|
duration<typename common_type<Rep1, Rep2>::type, Period>
|
|
operator*(const duration<Rep1, Period>& d, const Rep2& s);
|
|
template <class Rep1, class Period, class Rep2>
|
|
duration<typename common_type<Rep1, Rep2>::type, Period>
|
|
operator*(const Rep1& s, const duration<Rep2, Period>& d);
|
|
template <class Rep1, class Period, class Rep2>
|
|
duration<typename common_type<Rep1, Rep2>::type, Period>
|
|
operator/(const duration<Rep1, Period>& d, const Rep2& s);
|
|
template <class Rep1, class Period1, class Rep2, class Period2>
|
|
typename common_type<Rep1, Rep2>::type
|
|
operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
|
|
|
|
// duration comparisons
|
|
template <class Rep1, class Period1, class Rep2, class Period2>
|
|
bool operator==(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
|
|
template <class Rep1, class Period1, class Rep2, class Period2>
|
|
bool operator!=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
|
|
template <class Rep1, class Period1, class Rep2, class Period2>
|
|
bool operator< (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
|
|
template <class Rep1, class Period1, class Rep2, class Period2>
|
|
bool operator<=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
|
|
template <class Rep1, class Period1, class Rep2, class Period2>
|
|
bool operator> (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
|
|
template <class Rep1, class Period1, class Rep2, class Period2>
|
|
bool operator>=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
|
|
|
|
// duration_cast
|
|
template <class ToDuration, class Rep, class Period>
|
|
ToDuration duration_cast(const duration<Rep, Period>& d);
|
|
|
|
// time_point arithmetic
|
|
template <class Clock, class Duration1, class Rep2, class Period2>
|
|
time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2>>::type>
|
|
operator+(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
|
|
template <class Rep1, class Period1, class Clock, class Duration2>
|
|
time_point<Clock, typename common_type<duration<Rep1, Period1>, Duration2>::type>
|
|
operator+(const duration<Rep1, Period1>& lhs, const time_point<Clock, Duration2>& rhs);
|
|
template <class Clock, class Duration1, class Rep2, class Period2>
|
|
time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2>>::type>
|
|
operator-(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
|
|
template <class Clock, class Duration1, class Duration2>
|
|
typename common_type<Duration1, Duration2>::type
|
|
operator-(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
|
|
|
|
// time_point comparisons
|
|
template <class Clock, class Duration1, class Duration2>
|
|
bool operator==(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
|
|
template <class Clock, class Duration1, class Duration2>
|
|
bool operator!=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
|
|
template <class Clock, class Duration1, class Duration2>
|
|
bool operator< (const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
|
|
template <class Clock, class Duration1, class Duration2>
|
|
bool operator<=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
|
|
template <class Clock, class Duration1, class Duration2>
|
|
bool operator> (const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
|
|
template <class Clock, class Duration1, class Duration2>
|
|
bool operator>=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
|
|
|
|
// time_point_cast
|
|
|
|
template <class ToDuration, class Clock, class Duration>
|
|
time_point<Clock, ToDuration> time_point_cast(const time_point<Clock, Duration>& t);
|
|
|
|
// Clocks
|
|
|
|
class system_clock
|
|
{
|
|
public:
|
|
typedef microseconds duration;
|
|
typedef duration::rep rep;
|
|
typedef duration::period period;
|
|
typedef chrono::time_point<system_clock> time_point;
|
|
static const bool is_monotonic = false;
|
|
|
|
static time_point now();
|
|
static time_t to_time_t (const time_point& __t);
|
|
static time_point from_time_t(time_t __t);
|
|
};
|
|
|
|
class monotonic_clock
|
|
{
|
|
public:
|
|
typedef nanoseconds duration;
|
|
typedef duration::rep rep;
|
|
typedef duration::period period;
|
|
typedef chrono::time_point<monotonic_clock, duration> time_point;
|
|
static const bool is_monotonic = true;
|
|
|
|
static time_point now();
|
|
};
|
|
|
|
typedef monotonic_clock high_resolution_clock;
|
|
|
|
} // chrono
|
|
|
|
} // std
|
|
*/
|
|
|
|
#include <__config>
|
|
#include <ctime>
|
|
#include <type_traits>
|
|
#include <ratio>
|
|
#include <limits>
|
|
|
|
#pragma GCC system_header
|
|
|
|
_LIBCPP_BEGIN_NAMESPACE_STD
|
|
|
|
namespace chrono
|
|
{
|
|
|
|
template <class _Rep, class _Period = ratio<1> > class _LIBCPP_VISIBLE duration;
|
|
|
|
template <class _Tp>
|
|
struct __is_duration : false_type {};
|
|
|
|
template <class _Rep, class _Period>
|
|
struct __is_duration<duration<_Rep, _Period> > : true_type {};
|
|
|
|
template <class _Rep, class _Period>
|
|
struct __is_duration<const duration<_Rep, _Period> > : true_type {};
|
|
|
|
template <class _Rep, class _Period>
|
|
struct __is_duration<volatile duration<_Rep, _Period> > : true_type {};
|
|
|
|
template <class _Rep, class _Period>
|
|
struct __is_duration<const volatile duration<_Rep, _Period> > : true_type {};
|
|
|
|
} // chrono
|
|
|
|
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
|
|
struct _LIBCPP_VISIBLE common_type<chrono::duration<_Rep1, _Period1>,
|
|
chrono::duration<_Rep2, _Period2> >
|
|
{
|
|
typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type,
|
|
typename __ratio_gcd<_Period1, _Period2>::type> type;
|
|
};
|
|
|
|
namespace chrono {
|
|
|
|
// duration_cast
|
|
|
|
template <class _FromDuration, class _ToDuration,
|
|
class _Period = typename ratio_divide<typename _FromDuration::period, typename _ToDuration::period>::type,
|
|
bool = _Period::num == 1,
|
|
bool = _Period::den == 1>
|
|
struct __duration_cast;
|
|
|
|
template <class _FromDuration, class _ToDuration, class _Period>
|
|
struct __duration_cast<_FromDuration, _ToDuration, _Period, true, true>
|
|
{
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_ToDuration operator()(const _FromDuration& __fd) const
|
|
{
|
|
return _ToDuration(static_cast<typename _ToDuration::rep>(__fd.count()));
|
|
}
|
|
};
|
|
|
|
template <class _FromDuration, class _ToDuration, class _Period>
|
|
struct __duration_cast<_FromDuration, _ToDuration, _Period, true, false>
|
|
{
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_ToDuration operator()(const _FromDuration& __fd) const
|
|
{
|
|
typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct;
|
|
return _ToDuration(static_cast<typename _ToDuration::rep>(
|
|
static_cast<_Ct>(__fd.count()) / static_cast<_Ct>(_Period::den)));
|
|
}
|
|
};
|
|
|
|
template <class _FromDuration, class _ToDuration, class _Period>
|
|
struct __duration_cast<_FromDuration, _ToDuration, _Period, false, true>
|
|
{
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_ToDuration operator()(const _FromDuration& __fd) const
|
|
{
|
|
typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct;
|
|
return _ToDuration(static_cast<typename _ToDuration::rep>(
|
|
static_cast<_Ct>(__fd.count()) * static_cast<_Ct>(_Period::num)));
|
|
}
|
|
};
|
|
|
|
template <class _FromDuration, class _ToDuration, class _Period>
|
|
struct __duration_cast<_FromDuration, _ToDuration, _Period, false, false>
|
|
{
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
_ToDuration operator()(const _FromDuration& __fd) const
|
|
{
|
|
typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct;
|
|
return _ToDuration(static_cast<typename _ToDuration::rep>(
|
|
static_cast<_Ct>(__fd.count()) * static_cast<_Ct>(_Period::num)
|
|
/ static_cast<_Ct>(_Period::den)));
|
|
}
|
|
};
|
|
|
|
template <class _ToDuration, class _Rep, class _Period>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
__is_duration<_ToDuration>::value,
|
|
_ToDuration
|
|
>::type
|
|
duration_cast(const duration<_Rep, _Period>& __fd)
|
|
{
|
|
return __duration_cast<duration<_Rep, _Period>, _ToDuration>()(__fd);
|
|
}
|
|
|
|
template <class _Rep>
|
|
struct _LIBCPP_VISIBLE treat_as_floating_point : is_floating_point<_Rep> {};
|
|
|
|
template <class _Rep>
|
|
struct _LIBCPP_VISIBLE duration_values
|
|
{
|
|
public:
|
|
_LIBCPP_INLINE_VISIBILITY static _Rep zero() {return _Rep(0);}
|
|
_LIBCPP_INLINE_VISIBILITY static _Rep max() {return numeric_limits<_Rep>::max();}
|
|
_LIBCPP_INLINE_VISIBILITY static _Rep min() {return numeric_limits<_Rep>::lowest();}
|
|
};
|
|
|
|
// duration
|
|
|
|
template <class _Rep, class _Period>
|
|
class _LIBCPP_VISIBLE duration
|
|
{
|
|
static_assert(!__is_duration<_Rep>::value, "A duration representation can not be a duration");
|
|
static_assert(__is_ratio<_Period>::value, "Second template parameter of duration must be a std::ratio");
|
|
static_assert(_Period::num > 0, "duration period must be positive");
|
|
public:
|
|
typedef _Rep rep;
|
|
typedef _Period period;
|
|
private:
|
|
rep __rep_;
|
|
public:
|
|
|
|
_LIBCPP_INLINE_VISIBILITY duration() {} // = default;
|
|
template <class _Rep2>
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
explicit duration(const _Rep2& __r,
|
|
typename enable_if
|
|
<
|
|
is_convertible<_Rep2, rep>::value &&
|
|
(treat_as_floating_point<rep>::value ||
|
|
!treat_as_floating_point<_Rep2>::value)
|
|
>::type* = 0)
|
|
: __rep_(__r) {}
|
|
|
|
// conversions
|
|
template <class _Rep2, class _Period2>
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
duration(const duration<_Rep2, _Period2>& __d,
|
|
typename enable_if
|
|
<
|
|
treat_as_floating_point<rep>::value ||
|
|
(ratio_divide<_Period2, period>::type::den == 1 &&
|
|
!treat_as_floating_point<_Rep2>::value)
|
|
>::type* = 0)
|
|
: __rep_(_STD::chrono::duration_cast<duration>(__d).count()) {}
|
|
|
|
// observer
|
|
|
|
_LIBCPP_INLINE_VISIBILITY rep count() const {return __rep_;}
|
|
|
|
// arithmetic
|
|
|
|
_LIBCPP_INLINE_VISIBILITY duration operator+() const {return *this;}
|
|
_LIBCPP_INLINE_VISIBILITY duration operator-() const {return duration(-__rep_);}
|
|
_LIBCPP_INLINE_VISIBILITY duration& operator++() {++__rep_; return *this;}
|
|
_LIBCPP_INLINE_VISIBILITY duration operator++(int) {return duration(__rep_++);}
|
|
_LIBCPP_INLINE_VISIBILITY duration& operator--() {--__rep_; return *this;}
|
|
_LIBCPP_INLINE_VISIBILITY duration operator--(int) {return duration(__rep_--);}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY duration& operator+=(const duration& __d) {__rep_ += __d.count(); return *this;}
|
|
_LIBCPP_INLINE_VISIBILITY duration& operator-=(const duration& __d) {__rep_ -= __d.count(); return *this;}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY duration& operator*=(const rep& rhs) {__rep_ *= rhs; return *this;}
|
|
_LIBCPP_INLINE_VISIBILITY duration& operator/=(const rep& rhs) {__rep_ /= rhs; return *this;}
|
|
_LIBCPP_INLINE_VISIBILITY duration& operator%=(const rep& rhs) {__rep_ %= rhs; return *this;}
|
|
_LIBCPP_INLINE_VISIBILITY duration& operator%=(const duration& rhs) {__rep_ %= rhs.count(); return *this;}
|
|
|
|
// special values
|
|
|
|
_LIBCPP_INLINE_VISIBILITY static duration zero() {return duration(duration_values<rep>::zero());}
|
|
_LIBCPP_INLINE_VISIBILITY static duration min() {return duration(duration_values<rep>::min());}
|
|
_LIBCPP_INLINE_VISIBILITY static duration max() {return duration(duration_values<rep>::max());}
|
|
};
|
|
|
|
typedef duration<long long, nano> nanoseconds;
|
|
typedef duration<long long, micro> microseconds;
|
|
typedef duration<long long, milli> milliseconds;
|
|
typedef duration<long long > seconds;
|
|
typedef duration< long, ratio< 60> > minutes;
|
|
typedef duration< long, ratio<3600> > hours;
|
|
|
|
// Duration ==
|
|
|
|
template <class _LhsDuration, class _RhsDuration>
|
|
struct __duration_eq
|
|
{
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
bool operator()(const _LhsDuration& __lhs, const _RhsDuration& __rhs)
|
|
{
|
|
typedef typename common_type<_LhsDuration, _RhsDuration>::type _Ct;
|
|
return _Ct(__lhs).count() == _Ct(__rhs).count();
|
|
}
|
|
};
|
|
|
|
template <class _LhsDuration>
|
|
struct __duration_eq<_LhsDuration, _LhsDuration>
|
|
{
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
bool operator()(const _LhsDuration& __lhs, const _LhsDuration& __rhs)
|
|
{return __lhs.count() == __rhs.count();}
|
|
};
|
|
|
|
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
bool
|
|
operator==(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
|
|
{
|
|
return __duration_eq<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >()(__lhs, __rhs);
|
|
}
|
|
|
|
// Duration !=
|
|
|
|
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
bool
|
|
operator!=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
|
|
{
|
|
return !(__lhs == __rhs);
|
|
}
|
|
|
|
// Duration <
|
|
|
|
template <class _LhsDuration, class _RhsDuration>
|
|
struct __duration_lt
|
|
{
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
bool operator()(const _LhsDuration& __lhs, const _RhsDuration& __rhs)
|
|
{
|
|
typedef typename common_type<_LhsDuration, _RhsDuration>::type _Ct;
|
|
return _Ct(__lhs).count() < _Ct(__rhs).count();
|
|
}
|
|
};
|
|
|
|
template <class _LhsDuration>
|
|
struct __duration_lt<_LhsDuration, _LhsDuration>
|
|
{
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
bool operator()(const _LhsDuration& __lhs, const _LhsDuration& __rhs)
|
|
{return __lhs.count() < __rhs.count();}
|
|
};
|
|
|
|
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
bool
|
|
operator< (const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
|
|
{
|
|
return __duration_lt<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >()(__lhs, __rhs);
|
|
}
|
|
|
|
// Duration >
|
|
|
|
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
bool
|
|
operator> (const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
|
|
{
|
|
return __rhs < __lhs;
|
|
}
|
|
|
|
// Duration <=
|
|
|
|
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
bool
|
|
operator<=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
|
|
{
|
|
return !(__rhs < __lhs);
|
|
}
|
|
|
|
// Duration >=
|
|
|
|
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
bool
|
|
operator>=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
|
|
{
|
|
return !(__lhs < __rhs);
|
|
}
|
|
|
|
// Duration +
|
|
|
|
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
|
|
operator+(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
|
|
{
|
|
typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type __r = __lhs;
|
|
__r += __rhs;
|
|
return __r;
|
|
}
|
|
|
|
// Duration -
|
|
|
|
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
|
|
operator-(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
|
|
{
|
|
typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type __r = __lhs;
|
|
__r -= __rhs;
|
|
return __r;
|
|
}
|
|
|
|
// Duration *
|
|
|
|
template <class _Rep1, class _Period, class _Rep2>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
is_convertible<_Rep2, typename common_type<_Rep1, _Rep2>::type>::value,
|
|
duration<typename common_type<_Rep1, _Rep2>::type, _Period>
|
|
>::type
|
|
operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
|
|
{
|
|
typedef typename common_type<_Rep1, _Rep2>::type _Cr;
|
|
duration<_Cr, _Period> __r = __d;
|
|
__r *= static_cast<_Cr>(__s);
|
|
return __r;
|
|
}
|
|
|
|
template <class _Rep1, class _Period, class _Rep2>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
is_convertible<_Rep1, typename common_type<_Rep1, _Rep2>::type>::value,
|
|
duration<typename common_type<_Rep1, _Rep2>::type, _Period>
|
|
>::type
|
|
operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d)
|
|
{
|
|
return __d * __s;
|
|
}
|
|
|
|
// Duration /
|
|
|
|
template <class _Duration, class _Rep, bool = __is_duration<_Rep>::value>
|
|
struct __duration_divide_result
|
|
{
|
|
};
|
|
|
|
template <class _Duration, class _Rep2,
|
|
bool = is_convertible<_Rep2,
|
|
typename common_type<typename _Duration::rep, _Rep2>::type>::value>
|
|
struct __duration_divide_imp
|
|
{
|
|
};
|
|
|
|
template <class _Rep1, class _Period, class _Rep2>
|
|
struct __duration_divide_imp<duration<_Rep1, _Period>, _Rep2, true>
|
|
{
|
|
typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period> type;
|
|
};
|
|
|
|
template <class _Rep1, class _Period, class _Rep2>
|
|
struct __duration_divide_result<duration<_Rep1, _Period>, _Rep2, false>
|
|
: __duration_divide_imp<duration<_Rep1, _Period>, _Rep2>
|
|
{
|
|
};
|
|
|
|
template <class _Rep1, class _Period, class _Rep2>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename __duration_divide_result<duration<_Rep1, _Period>, _Rep2>::type
|
|
operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
|
|
{
|
|
typedef typename common_type<_Rep1, _Rep2>::type _Cr;
|
|
duration<_Cr, _Period> __r = __d;
|
|
__r /= static_cast<_Cr>(__s);
|
|
return __r;
|
|
}
|
|
|
|
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename common_type<_Rep1, _Rep2>::type
|
|
operator/(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
|
|
{
|
|
typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Ct;
|
|
return _Ct(__lhs).count() / _Ct(__rhs).count();
|
|
}
|
|
|
|
// Duration %
|
|
|
|
template <class _Rep1, class _Period, class _Rep2>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename __duration_divide_result<duration<_Rep1, _Period>, _Rep2>::type
|
|
operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
|
|
{
|
|
typedef typename common_type<_Rep1, _Rep2>::type _Cr;
|
|
duration<_Cr, _Period> __r = __d;
|
|
__r %= static_cast<_Cr>(__s);
|
|
return __r;
|
|
}
|
|
|
|
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
|
|
operator%(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
|
|
{
|
|
typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type __r = __lhs;
|
|
__r %= __rhs;
|
|
return __r;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////
|
|
///////////////////// time_point /////////////////////////
|
|
//////////////////////////////////////////////////////////
|
|
|
|
template <class _Clock, class _Duration = typename _Clock::duration>
|
|
class _LIBCPP_VISIBLE time_point
|
|
{
|
|
static_assert(__is_duration<_Duration>::value,
|
|
"Second template parameter of time_point must be a std::chrono::duration");
|
|
public:
|
|
typedef _Clock clock;
|
|
typedef _Duration duration;
|
|
typedef typename duration::rep rep;
|
|
typedef typename duration::period period;
|
|
private:
|
|
duration __d_;
|
|
|
|
public:
|
|
_LIBCPP_INLINE_VISIBILITY time_point() : __d_(duration::zero()) {}
|
|
_LIBCPP_INLINE_VISIBILITY explicit time_point(const duration& __d) : __d_(__d) {}
|
|
|
|
// conversions
|
|
template <class _Duration2>
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
time_point(const time_point<clock, _Duration2>& t,
|
|
typename enable_if
|
|
<
|
|
is_convertible<_Duration2, duration>::value
|
|
>::type* = 0)
|
|
: __d_(t.time_since_epoch()) {}
|
|
|
|
// observer
|
|
|
|
_LIBCPP_INLINE_VISIBILITY duration time_since_epoch() const {return __d_;}
|
|
|
|
// arithmetic
|
|
|
|
_LIBCPP_INLINE_VISIBILITY time_point& operator+=(const duration& __d) {__d_ += __d;}
|
|
_LIBCPP_INLINE_VISIBILITY time_point& operator-=(const duration& __d) {__d_ -= __d;}
|
|
|
|
// special values
|
|
|
|
_LIBCPP_INLINE_VISIBILITY static time_point min() {return time_point(duration::min());}
|
|
_LIBCPP_INLINE_VISIBILITY static time_point max() {return time_point(duration::max());}
|
|
};
|
|
|
|
} // chrono
|
|
|
|
template <class _Clock, class _Duration1, class _Duration2>
|
|
struct _LIBCPP_VISIBLE common_type<chrono::time_point<_Clock, _Duration1>,
|
|
chrono::time_point<_Clock, _Duration2> >
|
|
{
|
|
typedef chrono::time_point<_Clock, typename common_type<_Duration1, _Duration2>::type> type;
|
|
};
|
|
|
|
namespace chrono {
|
|
|
|
template <class _ToDuration, class _Clock, class _Duration>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
time_point<_Clock, _ToDuration>
|
|
time_point_cast(const time_point<_Clock, _Duration>& __t)
|
|
{
|
|
return time_point<_Clock, _ToDuration>(_STD::chrono::duration_cast<_ToDuration>(__t.time_since_epoch()));
|
|
}
|
|
|
|
// time_point ==
|
|
|
|
template <class _Clock, class _Duration1, class _Duration2>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
bool
|
|
operator==(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
|
|
{
|
|
return __lhs.time_since_epoch() == __rhs.time_since_epoch();
|
|
}
|
|
|
|
// time_point !=
|
|
|
|
template <class _Clock, class _Duration1, class _Duration2>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
bool
|
|
operator!=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
|
|
{
|
|
return !(__lhs == __rhs);
|
|
}
|
|
|
|
// time_point <
|
|
|
|
template <class _Clock, class _Duration1, class _Duration2>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
bool
|
|
operator<(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
|
|
{
|
|
return __lhs.time_since_epoch() < __rhs.time_since_epoch();
|
|
}
|
|
|
|
// time_point >
|
|
|
|
template <class _Clock, class _Duration1, class _Duration2>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
bool
|
|
operator>(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
|
|
{
|
|
return __rhs < __lhs;
|
|
}
|
|
|
|
// time_point <=
|
|
|
|
template <class _Clock, class _Duration1, class _Duration2>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
bool
|
|
operator<=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
|
|
{
|
|
return !(__rhs < __lhs);
|
|
}
|
|
|
|
// time_point >=
|
|
|
|
template <class _Clock, class _Duration1, class _Duration2>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
bool
|
|
operator>=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
|
|
{
|
|
return !(__lhs < __rhs);
|
|
}
|
|
|
|
// time_point operator+(time_point x, duration y);
|
|
|
|
template <class _Clock, class _Duration1, class _Rep2, class _Period2>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type>
|
|
operator+(const time_point<_Clock, _Duration1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
|
|
{
|
|
typedef time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> _Tr;
|
|
_Tr __r(__lhs.time_since_epoch());
|
|
__r += __rhs;
|
|
return __r;
|
|
}
|
|
|
|
// time_point operator+(duration x, time_point y);
|
|
|
|
template <class _Rep1, class _Period1, class _Clock, class _Duration2>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
time_point<_Clock, typename common_type<duration<_Rep1, _Period1>, _Duration2>::type>
|
|
operator+(const duration<_Rep1, _Period1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
|
|
{
|
|
return __rhs + __lhs;
|
|
}
|
|
|
|
// time_point operator-(time_point x, duration y);
|
|
|
|
template <class _Clock, class _Duration1, class _Rep2, class _Period2>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type>
|
|
operator-(const time_point<_Clock, _Duration1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
|
|
{
|
|
return __lhs + (-__rhs);
|
|
}
|
|
|
|
// duration operator-(time_point x, time_point y);
|
|
|
|
template <class _Clock, class _Duration1, class _Duration2>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename common_type<_Duration1, _Duration2>::type
|
|
operator-(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
|
|
{
|
|
return __lhs.time_since_epoch() - __rhs.time_since_epoch();
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////
|
|
/////////////////////// clocks ///////////////////////////
|
|
//////////////////////////////////////////////////////////
|
|
|
|
class _LIBCPP_VISIBLE system_clock
|
|
{
|
|
public:
|
|
typedef microseconds duration;
|
|
typedef duration::rep rep;
|
|
typedef duration::period period;
|
|
typedef chrono::time_point<system_clock> time_point;
|
|
static const bool is_monotonic = false;
|
|
|
|
static time_point now();
|
|
static time_t to_time_t (const time_point& __t);
|
|
static time_point from_time_t(time_t __t);
|
|
};
|
|
|
|
class _LIBCPP_VISIBLE monotonic_clock
|
|
{
|
|
public:
|
|
typedef nanoseconds duration;
|
|
typedef duration::rep rep;
|
|
typedef duration::period period;
|
|
typedef chrono::time_point<monotonic_clock, duration> time_point;
|
|
static const bool is_monotonic = true;
|
|
|
|
static time_point now();
|
|
};
|
|
|
|
typedef monotonic_clock high_resolution_clock;
|
|
|
|
} // chrono
|
|
|
|
_LIBCPP_END_NAMESPACE_STD
|
|
|
|
#endif // _LIBCPP_CHRONO
|