include/chrono

// -*- C++ -*-
//===---------------------------- chrono ----------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#ifndef _LIBCPP_CHRONO
#define _LIBCPP_CHRONO

/*
 chrono synopsis

namespace std
{
namespace chrono
{

template <class ToDuration, class Rep, class Period>
constexpr
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 constexpr Rep zero();
 static constexpr Rep max();
 static constexpr 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;

 constexpr duration() = default;
 template <class Rep2>
 constexpr 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>
 constexpr 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

 constexpr rep count() const;

 // arithmetic

 constexpr duration operator+() const;
 constexpr 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 constexpr duration zero();
 static constexpr duration min();
 static constexpr 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>
 constexpr
 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>
 constexpr
 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>
 constexpr
 duration<typename common_type<Rep1, Rep2>::type, Period>
 operator*(const duration<Rep1, Period>& d, const Rep2& s);
template <class Rep1, class Period, class Rep2>
 constexpr
 duration<typename common_type<Rep1, Rep2>::type, Period>
 operator*(const Rep1& s, const duration<Rep2, Period>& d);
template <class Rep1, class Period, class Rep2>
 constexpr
 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>
 constexpr
 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>
 constexpr
 bool operator==(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
template <class Rep1, class Period1, class Rep2, class Period2>
 constexpr
 bool operator!=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
template <class Rep1, class Period1, class Rep2, class Period2>
 constexpr
 bool operator< (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
template <class Rep1, class Period1, class Rep2, class Period2>
 constexpr
 bool operator<=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
template <class Rep1, class Period1, class Rep2, class Period2>
 constexpr
 bool operator> (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
template <class Rep1, class Period1, class Rep2, class Period2>
 constexpr
 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_steady = false;

 static time_point now() noexcept;
 static time_t to_time_t (const time_point& __t) noexcept;
 static time_point from_time_t(time_t __t) noexcept;
};

class steady_clock
{
public:
 typedef nanoseconds duration;
 typedef duration::rep rep;
 typedef duration::period period;
 typedef chrono::time_point<steady_clock, duration> time_point;
 static const bool is_steady = true;

 static time_point now() noexcept;
};

typedef steady_clock high_resolution_clock;

} // chrono

} // std
*/

#include <__config>
#include <ctime>
#include <type_traits>
#include <ratio>
#include <limits>

#include <__undef_min_max>

#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif

_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 _LIBCPP_CONSTEXPR
 _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 _LIBCPP_CONSTEXPR
 _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 _LIBCPP_CONSTEXPR
 _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 _LIBCPP_CONSTEXPR
 _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
_LIBCPP_CONSTEXPR
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 _LIBCPP_CONSTEXPR _Rep zero() {return _Rep(0);}
 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep max() {return numeric_limits<_Rep>::max();}
 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _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 _LIBCPP_CONSTEXPR duration() {} // = default;
 template <class _Rep2>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 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 _LIBCPP_CONSTEXPR
 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_(_VSTD::chrono::duration_cast<duration>(__d).count()) {}

 // observer

 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR rep count() const {return __rep_;}

 // arithmetic

 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR duration operator+() const {return *this;}
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 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 _LIBCPP_CONSTEXPR duration zero() {return duration(duration_values<rep>::zero());}
 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration min() {return duration(duration_values<rep>::min());}
 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR 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 _LIBCPP_CONSTEXPR
 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 _LIBCPP_CONSTEXPR
 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
_LIBCPP_CONSTEXPR
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
_LIBCPP_CONSTEXPR
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 _LIBCPP_CONSTEXPR
 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 _LIBCPP_CONSTEXPR
 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
_LIBCPP_CONSTEXPR
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
_LIBCPP_CONSTEXPR
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
_LIBCPP_CONSTEXPR
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
_LIBCPP_CONSTEXPR
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
_LIBCPP_CONSTEXPR
typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
operator+(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
{
 typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
 return _Cd(_Cd(__lhs).count() + _Cd(__rhs).count());
}

// Duration -

template <class _Rep1, class _Period1, class _Rep2, class _Period2>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR
typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
operator-(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
{
 typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
 return _Cd(_Cd(__lhs).count() - _Cd(__rhs).count());
}

// Duration *

template <class _Rep1, class _Period, class _Rep2>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR
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;
 typedef duration<_Cr, _Period> _Cd;
 return _Cd(_Cd(__d).count() * static_cast<_Cr>(__s));
}

template <class _Rep1, class _Period, class _Rep2>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR
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
_LIBCPP_CONSTEXPR
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;
 typedef duration<_Cr, _Period> _Cd;
 return _Cd(_Cd(__d).count() / static_cast<_Cr>(__s));
}

template <class _Rep1, class _Period1, class _Rep2, class _Period2>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR
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
_LIBCPP_CONSTEXPR
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;
 typedef duration<_Cr, _Period> _Cd;
 return _Cd(_Cd(__d).count() % static_cast<_Cr>(__s));
}

template <class _Rep1, class _Period1, class _Rep2, class _Period2>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR
typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
operator%(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
{
 typedef typename common_type<_Rep1, _Rep2>::type _Cr;
 typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
 return _Cd(static_cast<_Cr>(_Cd(__lhs).count()) % static_cast<_Cr>(_Cd(__rhs).count()));
}

//////////////////////////////////////////////////////////
///////////////////// 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; return *this;}
_LIBCPP_INLINE_VISIBILITY time_point& operator-=(const duration& __d) {__d_ -= __d; return *this;}

 // special values

 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR time_point min() {return time_point(duration::min());}
 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR 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>(_VSTD::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_steady = false;

 static time_point now() _NOEXCEPT;
 static time_t to_time_t (const time_point& __t) _NOEXCEPT;
 static time_point from_time_t(time_t __t) _NOEXCEPT;
};

class _LIBCPP_VISIBLE steady_clock
{
public:
 typedef nanoseconds duration;
 typedef duration::rep rep;
 typedef duration::period period;
 typedef chrono::time_point<steady_clock, duration> time_point;
 static const bool is_steady = true;

 static time_point now() _NOEXCEPT;
};

typedef steady_clock high_resolution_clock;

} // chrono

_LIBCPP_END_NAMESPACE_STD

#endif // _LIBCPP_CHRONO