chrono Namespace Reference

Classes
struct	_Duration_div_mod
struct	_Duration_div_mod1
struct	_Duration_div_mod1< _CR, _Period1, _Rep2, false >
struct	_Duration_div_mod< _Rep1, _Period1, _Rep2, false >
struct	_Is_duration
struct	_Is_duration< duration< _Rep, _Period > >
struct	_Is_ratio
struct	_Is_ratio< ratio< _R1, _R2 > >
class	duration
struct	duration_values
struct	steady_clock
struct	system_clock
class	time_point
struct	treat_as_floating_point

Typedefs
template<class _Dur >
using	_As_integral = duration< typename conditional< treat_as_floating_point< typename _Dur::rep >::value, intmax_t, typename _Dur::rep >::type, typename _Dur::period >
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< int, ratio< 60 > >	minutes
typedef duration< int, ratio< 3600 > >	hours
typedef steady_clock	high_resolution_clock

Functions
template<class _To , class _Rep , class _Period >
constexpr enable_if< _Is_duration< _To >::value, _To >::type	duration_cast (const duration< _Rep, _Period > &)
template<class _Rep1 , class _Period1 , class _Rep2 , class _Period2 >
constexpr common_type< duration< _Rep1, _Period1 >, duration< _Rep2, _Period2 > >::type	operator+ (const duration< _Rep1, _Period1 > &_Left, const duration< _Rep2, _Period2 > &_Right)
template<class _Rep1 , class _Period1 , class _Rep2 , class _Period2 >
constexpr common_type< duration< _Rep1, _Period1 >, duration< _Rep2, _Period2 > >::type	operator- (const duration< _Rep1, _Period1 > &_Left, const duration< _Rep2, _Period2 > &_Right)
template<class _Rep1 , class _Period1 , class _Rep2 >
constexpr enable_if< is_convertible< _Rep2, typename common_type< _Rep1, _Rep2 >::type >::value, duration< typename common_type< _Rep1, _Rep2 >::type, _Period1 > >::type	operator* (const duration< _Rep1, _Period1 > &_Left, const _Rep2 &_Right)
template<class _Rep1 , class _Rep2 , class _Period2 >
constexpr enable_if< is_convertible< _Rep1, typename common_type< _Rep1, _Rep2 >::type >::value, duration< typename common_type< _Rep1, _Rep2 >::type, _Period2 > >::type	operator* (const _Rep1 &_Left, const duration< _Rep2, _Period2 > &_Right)
template<class _Rep1 , class _Period1 , class _Rep2 >
_Duration_div_mod< _Rep1, _Period1, _Rep2 >::type constexpr	operator/ (const duration< _Rep1, _Period1 > &_Left, const _Rep2 &_Right)
template<class _Rep1 , class _Period1 , class _Rep2 , class _Period2 >
constexpr common_type< _Rep1, _Rep2 >::type	operator/ (const duration< _Rep1, _Period1 > &_Left, const duration< _Rep2, _Period2 > &_Right)
template<class _Rep1 , class _Period1 , class _Rep2 >
constexpr _Duration_div_mod< _Rep1, _Period1, _Rep2 >::type	operator% (const duration< _Rep1, _Period1 > &_Left, const _Rep2 &_Right)
template<class _Rep1 , class _Period1 , class _Rep2 , class _Period2 >
constexpr common_type< duration< _Rep1, _Period1 >, duration< _Rep2, _Period2 > >::type	operator% (const duration< _Rep1, _Period1 > &_Left, const duration< _Rep2, _Period2 > &_Right)
template<class _Rep1 , class _Period1 , class _Rep2 , class _Period2 >
constexpr bool	operator== (const duration< _Rep1, _Period1 > &_Left, const duration< _Rep2, _Period2 > &_Right)
template<class _Rep1 , class _Period1 , class _Rep2 , class _Period2 >
constexpr bool	operator!= (const duration< _Rep1, _Period1 > &_Left, const duration< _Rep2, _Period2 > &_Right)
template<class _Rep1 , class _Period1 , class _Rep2 , class _Period2 >
constexpr bool	operator< (const duration< _Rep1, _Period1 > &_Left, const duration< _Rep2, _Period2 > &_Right)
template<class _Rep1 , class _Period1 , class _Rep2 , class _Period2 >
constexpr bool	operator<= (const duration< _Rep1, _Period1 > &_Left, const duration< _Rep2, _Period2 > &_Right)
template<class _Rep1 , class _Period1 , class _Rep2 , class _Period2 >
constexpr bool	operator> (const duration< _Rep1, _Period1 > &_Left, const duration< _Rep2, _Period2 > &_Right)
template<class _Rep1 , class _Period1 , class _Rep2 , class _Period2 >
constexpr bool	operator>= (const duration< _Rep1, _Period1 > &_Left, const duration< _Rep2, _Period2 > &_Right)
template<class _Rep , class _Period , class _To_integral >
constexpr _To_integral	_Floor (const duration< _Rep, _Period > &_Dur, const _To_integral &_Dur_integral)
template<class _To , class _Rep , class _Period >
constexpr enable_if< _Is_duration< _To >::value, _To >::type	floor (const duration< _Rep, _Period > &_Dur)
template<class _Rep , class _Period , class _To_integral >
constexpr _To_integral	_Ceil (const duration< _Rep, _Period > &_Dur, const _To_integral &_Dur_integral)
template<class _To , class _Rep , class _Period >
constexpr enable_if< _Is_duration< _To >::value, _To >::type	ceil (const duration< _Rep, _Period > &_Dur)
template<class _Rep >
constexpr make_unsigned< _Rep >::type	_Make_unsigned (_Rep _Val)
template<class _Rep >
constexpr bool	_Is_even (_Rep _Val)
template<class _Rep >
constexpr _Rep	_Bankers_divide_impl (_Rep _Truncated, _Rep _Mod, _Rep _Half_divisor, bool _Half_divisor_is_exact)
template<class _Rep >
constexpr _Rep	_Bankers_divide_tag (_Rep _Dividend, _Rep _Divisor, false_type)
template<class _Rep >
constexpr _Rep	_Bankers_divide_tag (_Rep _Dividend, _Rep _Divisor, true_type)
template<class _Rep >
constexpr _Rep	_Bankers_divide (_Rep _Dividend, _Rep _Divisor)
template<class _Rep >
constexpr bool	_Round_should_truncate (_Rep _Val, intmax_t _Val_trunc)
template<class _Rep >
constexpr intmax_t	_Round_fp_non_negative (_Rep _Val, intmax_t _Val_trunc)
template<class _Rep >
constexpr intmax_t	_Round_fp_non_negative (_Rep _Val)
template<class _Rep >
constexpr _Rep	_Round_fp (_Rep _Val)
template<class _To , class _Rep , class _Period >
constexpr _To	_Round (const duration< _Rep, _Period > &_Dur, false_type, false_type)
template<class _To , class _Rep , class _Period >
constexpr _To	_Round (const duration< _Rep, _Period > &_Dur, false_type, true_type)
template<class _To , class _Rep , class _Period , class _Source_integral >
constexpr _To	_Round (const duration< _Rep, _Period > &_Dur, true_type, _Source_integral)
template<class _To , class _Rep , class _Period >
constexpr enable_if< _Is_duration< _To >::value, _To >::type	round (const duration< _Rep, _Period > &_Dur)
template<class _Rep , class _Period >
constexpr enable_if< numeric_limits< _Rep >::is_signed, duration< _Rep, _Period > >::type	abs (const duration< _Rep, _Period > _Dur)
template<class _Clock , class _Duration , class _Rep , class _Period >
constexpr time_point< _Clock, typename common_type< _Duration, duration< _Rep, _Period > >::type >	operator+ (const time_point< _Clock, _Duration > &_Left, const duration< _Rep, _Period > &_Right)
template<class _Rep , class _Period , class _Clock , class _Duration >
constexpr time_point< _Clock, typename common_type< duration< _Rep, _Period >, _Duration >::type >	operator+ (const duration< _Rep, _Period > &_Left, const time_point< _Clock, _Duration > &_Right)
template<class _Clock , class _Duration , class _Rep , class _Period >
constexpr time_point< _Clock, typename common_type< _Duration, duration< _Rep, _Period > >::type >	operator- (const time_point< _Clock, _Duration > &_Left, const duration< _Rep, _Period > &_Right)
template<class _Clock , class _Duration1 , class _Duration2 >
constexpr common_type< _Duration1, _Duration2 >::type	operator- (const time_point< _Clock, _Duration1 > &_Left, const time_point< _Clock, _Duration2 > &_Right)
template<class _Clock , class _Duration1 , class _Duration2 >
constexpr bool	operator== (const time_point< _Clock, _Duration1 > &_Left, const time_point< _Clock, _Duration2 > &_Right)
template<class _Clock , class _Duration1 , class _Duration2 >
constexpr bool	operator!= (const time_point< _Clock, _Duration1 > &_Left, const time_point< _Clock, _Duration2 > &_Right)
template<class _Clock , class _Duration1 , class _Duration2 >
constexpr bool	operator< (const time_point< _Clock, _Duration1 > &_Left, const time_point< _Clock, _Duration2 > &_Right)
template<class _Clock , class _Duration1 , class _Duration2 >
constexpr bool	operator<= (const time_point< _Clock, _Duration1 > &_Left, const time_point< _Clock, _Duration2 > &_Right)
template<class _Clock , class _Duration1 , class _Duration2 >
constexpr bool	operator> (const time_point< _Clock, _Duration1 > &_Left, const time_point< _Clock, _Duration2 > &_Right)
template<class _Clock , class _Duration1 , class _Duration2 >
constexpr bool	operator>= (const time_point< _Clock, _Duration1 > &_Left, const time_point< _Clock, _Duration2 > &_Right)
template<class _To , class _Clock , class _Duration >
constexpr enable_if< _Is_duration< _To >::value, time_point< _Clock, _To > >::type	time_point_cast (const time_point< _Clock, _Duration > &_Time)
template<class _To , class _Clock , class _Duration >
constexpr enable_if< _Is_duration< _To >::value, time_point< _Clock, _To > >::type	floor (const time_point< _Clock, _Duration > &_Time)
template<class _To , class _Clock , class _Duration >
constexpr enable_if< _Is_duration< _To >::value, time_point< _Clock, _To > >::type	ceil (const time_point< _Clock, _Duration > &_Time)
template<class _To , class _Clock , class _Duration >
constexpr enable_if< _Is_duration< _To >::value, time_point< _Clock, _To > >::type	round (const time_point< _Clock, _Duration > &_Time)

Variables
template<class _Rep >
constexpr bool	treat_as_floating_point_v = treat_as_floating_point<_Rep>::value

Typedef Documentation

template<class _Dur >

using chrono::_As_integral = typedef duration< typename conditional<treat_as_floating_point<typename _Dur::rep>::value, intmax_t, typename _Dur::rep>::type, typename _Dur::period>

typedef steady_clock chrono::high_resolution_clock

typedef duration<int, ratio<3600> > chrono::hours

typedef duration<long long, micro> chrono::microseconds

typedef duration<long long, milli> chrono::milliseconds

typedef duration<int, ratio<60> > chrono::minutes

typedef duration<long long, nano> chrono::nanoseconds

typedef duration<long long> chrono::seconds

Function Documentation

template<class _Rep >

constexpr _Rep chrono::_Bankers_divide ( _Rep  _Dividend, _Rep  _Divisor  )

inline

    {   // Integer divide _Dividend by _Divisor, round to nearest, ties to even
        // Assumes _Divisor > 0 because all the callers of this put
        // ratio::den as _Divisor, and ratio::den can't be negative or zero by
        // N4527 20.11.3 [ratio.ratio]/2.2
    return (_Bankers_divide_tag(_Dividend, _Divisor, is_signed<_Rep>()));
    }

template<class _Rep >

constexpr _Rep chrono::_Bankers_divide_impl ( _Rep  _Truncated, _Rep  _Mod, _Rep  _Half_divisor, bool  _Half_divisor_is_exact  )

inline

    {   // Implement _Bankers_divide for unsigned numbers
    return (_Truncated + static_cast<_Rep>(
        // strictly closer to positive infinity
        _Mod > _Half_divisor
        // equidistant, ties to even
            || (_Mod == _Half_divisor
            // The next condition detects _Half_divisor itself being truncated
            && _Half_divisor_is_exact
            && !_Is_even(_Truncated)
        )));
    }

template<class _Rep >

constexpr _Rep chrono::_Bankers_divide_tag ( _Rep  _Dividend, _Rep  _Divisor, false_type    )

inline

    {   // _Bankers_divide for unsigned numbers
    return (_Bankers_divide_impl(
        _Dividend / _Divisor,
        _Dividend % _Divisor,
        _Divisor / static_cast<_Rep>(2),
        _Is_even(_Divisor)));
    }

template<class _Rep >

constexpr _Rep chrono::_Bankers_divide_tag ( _Rep  _Dividend, _Rep  _Divisor, true_type    )

inline

    {   // Transform to unsigned then transform back
    return (static_cast<_Rep>(duration_values<_Rep>::zero() <= _Dividend
        ? _Bankers_divide_tag(_Make_unsigned(_Dividend),
            _Make_unsigned(_Divisor), false_type())
        : duration_values<_Rep>::zero() - _Bankers_divide_tag(
            duration_values<_Rep>::zero() - _Make_unsigned(_Dividend),
            _Make_unsigned(_Divisor), false_type())));
    }

template<class _Rep , class _Period , class _To_integral >

constexpr _To_integral chrono::_Ceil ( const duration< _Rep, _Period > &  _Dur, const _To_integral &  _Dur_integral  )

inline

    {
    return (_Dur <= _Dur_integral
        ? _Dur_integral
        : _Dur_integral + static_cast<_To_integral>(1));
    }

template<class _Rep , class _Period , class _To_integral >

constexpr _To_integral chrono::_Floor ( const duration< _Rep, _Period > &  _Dur, const _To_integral &  _Dur_integral  )

inline

    {
    return (_Dur_integral <= _Dur
        ? _Dur_integral
        : _Dur_integral - static_cast<_To_integral>(1));
    }

template<class _Rep >

constexpr bool chrono::_Is_even ( _Rep  _Val )

inline

    {   // Tests whether _Val is even
    return (_Val % 2 == 0);
    }

template<class _Rep >

constexpr make_unsigned<_Rep>::type chrono::_Make_unsigned ( _Rep  _Val )

inline

    {   // Makes _Val unsigned
    return (static_cast<typename make_unsigned<_Rep>::type>(_Val));
    }

template<class _To , class _Rep , class _Period >

constexpr _To chrono::_Round ( const duration< _Rep, _Period > &  _Dur, false_type  , false_type    )

inline

    {   // Implement round() when everything is integral
    typedef ratio_divide<_Period, typename _To::period> _CF;

    typedef typename _To::rep _ToRep;
    typedef typename common_type<_ToRep, _Rep, intmax_t>::type _CR;

#pragma warning(push)
#pragma warning(disable: 6326)  // Potential comparison of a constant with another constant.
    return (_CF::num == 1 && _CF::den == 1
            ? static_cast<_To>(static_cast<_ToRep>(_Dur.count()))
        : _CF::num != 1 && _CF::den == 1
            ? static_cast<_To>(static_cast<_ToRep>(
                static_cast<_CR>(
                    _Dur.count()) * static_cast<_CR>(_CF::num)))
        : _CF::num == 1 && _CF::den != 1
            ? static_cast<_To>(static_cast<_ToRep>(_Bankers_divide(
                static_cast<_CR>(_Dur.count()), static_cast<_CR>(_CF::den))))
        : static_cast<_To>(static_cast<_ToRep>(
            _Bankers_divide(
                static_cast<_CR>(_Dur.count()) * static_cast<_CR>(_CF::num),
                static_cast<_CR>(_CF::den)))));
#pragma warning(pop)
    }

template<class _To , class _Rep , class _Period >

constexpr _To chrono::_Round ( const duration< _Rep, _Period > &  _Dur, false_type  , true_type    )

inline

    {   // Implement round() when the target is integral, source is floating
        // Do any period adjustments in floating point values
        // (in duration_cast), then round to nearest integer, ties to even
    typedef duration<_Rep, typename _To::period> _FloatTo;
    return (static_cast<_To>(static_cast<typename _To::rep>(
        _Round_fp(chrono::duration_cast<_FloatTo>(_Dur).count()))));
    }

template<class _To , class _Rep , class _Period , class _Source_integral >

constexpr _To chrono::_Round ( const duration< _Rep, _Period > &  _Dur, true_type  , _Source_integral    )

inline

    {   // Implement round() when the target is floating, source is anything
        // Convert to floating point, then round to nearest integer, ties to even
    return (static_cast<_To>(_Round_fp(chrono::duration_cast<_To>(_Dur).count())));
    }

template<class _Rep >

constexpr _Rep chrono::_Round_fp ( _Rep  _Val )

inline

    {   // Rounds floating point _Val to nearest, ties to even
        // Transform to non-negative, then transform back.
    static_assert(treat_as_floating_point<_Rep>::value,
        "_Round_fp needs floating input");
    return (static_cast<_Rep>(duration_values<_Rep>::zero() <= _Val
        ? _Round_fp_non_negative(_Val)
        : (duration_values<_Rep>::zero()
            - _Round_fp_non_negative(duration_values<_Rep>::zero() - _Val))
        ));
    }

template<class _Rep >

constexpr intmax_t chrono::_Round_fp_non_negative ( _Rep  _Val, intmax_t  _Val_trunc  )

inline

    {   // Rounds non-negative floating point _Val to nearest integer, ties to even
    return (_Round_should_truncate(_Val, _Val_trunc) ? _Val_trunc : _Val_trunc + 1);
    }

template<class _Rep >

constexpr intmax_t chrono::_Round_fp_non_negative ( _Rep  _Val )

inline

    {   // Rounds non-negative floating point _Val to nearest integer, ties to even
    return (_Round_fp_non_negative(_Val, static_cast<intmax_t>(_Val)));
    }

template<class _Rep >

constexpr bool chrono::_Round_should_truncate ( _Rep  _Val, intmax_t  _Val_trunc  )

inline

    {   // Tests if floating point _Val is closer to _Val_trunc, or should tie to even
    return (_Val - static_cast<_Rep>(_Val_trunc) < static_cast<_Rep>(_Val_trunc + 1) - _Val
        || (_Val - static_cast<_Rep>(_Val_trunc) == static_cast<_Rep>(_Val_trunc + 1) - _Val
            && _Is_even(_Val_trunc)));
    }

template<class _Rep , class _Period >

constexpr enable_if<numeric_limits<_Rep>::is_signed, duration<_Rep, _Period> >::type chrono::abs ( const duration< _Rep, _Period >  _Dur )

inline

    {   // create a duration with count() the absolute value of _Dur.count()
    return (_Dur < duration<_Rep, _Period>::zero()
        ? duration<_Rep, _Period>::zero() - _Dur
        : _Dur);
    }

template<class _To , class _Rep , class _Period >

constexpr enable_if<_Is_duration<_To>::value, _To>::type chrono::ceil ( const duration< _Rep, _Period > &  _Dur )

inline

    {   // convert duration to another duration; round towards positive infinity
        // i.e. the least integral result such that _Dur <= the result
    return (_Ceil(_Dur, chrono::duration_cast<_As_integral<_To> >(_Dur)));
    }

template<class _To , class _Clock , class _Duration >

constexpr enable_if<_Is_duration<_To>::value, time_point<_Clock, _To> >::type chrono::ceil ( const time_point< _Clock, _Duration > &  _Time )

inline

    {   // change the duration type of a time_point; round towards positive infinity
    return (time_point<_Clock, _To>(
        chrono::ceil<_To>(_Time.time_since_epoch())));
    }

template<class _To , class _Rep , class _Period >

constexpr enable_if< _Is_duration< _To >::value, _To >::type chrono::duration_cast ( const duration< _Rep, _Period > &  _Dur )

inline

    {   // convert duration to another duration; truncate
    typedef ratio_divide<_Period, typename _To::period> _CF;

    typedef typename _To::rep _ToRep;
    typedef typename common_type<_ToRep, _Rep, intmax_t>::type _CR;

#pragma warning(push)
#pragma warning(disable: 6326)  // Potential comparison of a constant with another constant.
    return (_CF::num == 1 && _CF::den == 1
            ? static_cast<_To>(static_cast<_ToRep>(_Dur.count()))
        : _CF::num != 1 && _CF::den == 1
            ? static_cast<_To>(static_cast<_ToRep>(
                static_cast<_CR>(
                    _Dur.count()) * static_cast<_CR>(_CF::num)))
        : _CF::num == 1 && _CF::den != 1
            ? static_cast<_To>(static_cast<_ToRep>(
                static_cast<_CR>(_Dur.count())
                    / static_cast<_CR>(_CF::den)))
        : static_cast<_To>(static_cast<_ToRep>(
            static_cast<_CR>(_Dur.count()) * static_cast<_CR>(_CF::num)
                / static_cast<_CR>(_CF::den))));
#pragma warning(pop)
    }

template<class _To , class _Rep , class _Period >

constexpr enable_if<_Is_duration<_To>::value, _To>::type chrono::floor ( const duration< _Rep, _Period > &  _Dur )

inline

    {   // convert duration to another duration; round towards negative infinity
        // i.e. the greatest integral result such that the result <= _Dur
    return (_Floor(_Dur, chrono::duration_cast<_As_integral<_To> >(_Dur)));
    }

template<class _To , class _Clock , class _Duration >

constexpr enable_if<_Is_duration<_To>::value, time_point<_Clock, _To> >::type chrono::floor ( const time_point< _Clock, _Duration > &  _Time )

inline

    {   // change the duration type of a time_point; round towards negative infinity
    return (time_point<_Clock, _To>(
        chrono::floor<_To>(_Time.time_since_epoch())));
    }

template<class _Rep1 , class _Period1 , class _Rep2 , class _Period2 >

constexpr bool chrono::operator!= ( const duration< _Rep1, _Period1 > &  _Left, const duration< _Rep2, _Period2 > &  _Right  )

inline

    {   // test if duration != duration
    return (!(_Left == _Right));
    }

template<class _Clock , class _Duration1 , class _Duration2 >

constexpr bool chrono::operator!= ( const time_point< _Clock, _Duration1 > &  _Left, const time_point< _Clock, _Duration2 > &  _Right  )

inline

    {   // test for time_point != time_point
    return (!(_Left == _Right));
    }

template<class _Rep1 , class _Period1 , class _Rep2 >

constexpr _Duration_div_mod<_Rep1, _Period1, _Rep2>::type chrono::operator% ( const duration< _Rep1, _Period1 > &  _Left, const _Rep2 &  _Right  )

inline

    {   // divide duration by rep
    typedef typename common_type<_Rep1, _Rep2>::type _CR;
    typedef duration<_CR, _Period1> _CD;
    return (_CD(_CD(_Left).count() % _Right));
    }

template<class _Rep1 , class _Period1 , class _Rep2 , class _Period2 >

constexpr common_type< duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type chrono::operator% ( const duration< _Rep1, _Period1 > &  _Left, const duration< _Rep2, _Period2 > &  _Right  )

inline

    {   // divide duration by duration
    typedef typename common_type<
        duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _CD;
    return (_CD(_CD(_Left).count() % _CD(_Right).count()));
    }

template<class _Rep1 , class _Period1 , class _Rep2 >

constexpr enable_if<is_convertible<_Rep2, typename common_type<_Rep1, _Rep2>::type>::value, duration<typename common_type<_Rep1, _Rep2>::type, _Period1> >::type chrono::operator* ( const duration< _Rep1, _Period1 > &  _Left, const _Rep2 &  _Right  )

inline

    {   // multiply duration by rep
    typedef typename common_type<_Rep1, _Rep2>::type _CR;
    typedef duration<_CR, _Period1> _CD;
    return (_CD(_CD(_Left).count() * _Right));
    }

template<class _Rep1 , class _Rep2 , class _Period2 >

constexpr enable_if<is_convertible<_Rep1, typename common_type<_Rep1, _Rep2>::type>::value, duration<typename common_type<_Rep1, _Rep2>::type, _Period2> >::type chrono::operator* ( const _Rep1 &  _Left, const duration< _Rep2, _Period2 > &  _Right  )

inline

    {   // multiply rep by duration
    return (_Right * _Left);
    }

template<class _Rep1 , class _Period1 , class _Rep2 , class _Period2 >

constexpr common_type< duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type chrono::operator+ ( const duration< _Rep1, _Period1 > &  _Left, const duration< _Rep2, _Period2 > &  _Right  )

inline

    {   // add two durations
    typedef typename common_type<
        duration<_Rep1, _Period1>,
        duration<_Rep2, _Period2> >::type _CD;
    return (_CD(_CD(_Left).count() + _CD(_Right).count()));
    }

template<class _Clock , class _Duration , class _Rep , class _Period >

constexpr time_point<_Clock, typename common_type<_Duration, duration<_Rep, _Period> >::type> chrono::operator+ ( const time_point< _Clock, _Duration > &  _Left, const duration< _Rep, _Period > &  _Right  )

inline

    {   // add duration to time_point
    typedef time_point<_Clock, typename common_type<
        _Duration, duration<_Rep, _Period> >::type> _RT;
    return (_RT(_Left.time_since_epoch() + _Right));
    }

template<class _Rep , class _Period , class _Clock , class _Duration >

constexpr time_point<_Clock, typename common_type<duration<_Rep, _Period>, _Duration>::type> chrono::operator+ ( const duration< _Rep, _Period > &  _Left, const time_point< _Clock, _Duration > &  _Right  )

inline

    {   // add time_point to duration
    return (_Right + _Left);
    }

template<class _Rep1 , class _Period1 , class _Rep2 , class _Period2 >

constexpr common_type< duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type chrono::operator- ( const duration< _Rep1, _Period1 > &  _Left, const duration< _Rep2, _Period2 > &  _Right  )

inline

    {   // subtract two durations
    typedef typename common_type<
        duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _CD;
    return (_CD(_CD(_Left).count() - _CD(_Right).count()));
    }

template<class _Clock , class _Duration , class _Rep , class _Period >

constexpr time_point<_Clock, typename common_type<_Duration, duration<_Rep, _Period> >::type> chrono::operator- ( const time_point< _Clock, _Duration > &  _Left, const duration< _Rep, _Period > &  _Right  )

inline

    {   // subtract duration from time_point
    return (_Left + (-_Right));
    }

template<class _Clock , class _Duration1 , class _Duration2 >

constexpr common_type<_Duration1, _Duration2>::type chrono::operator- ( const time_point< _Clock, _Duration1 > &  _Left, const time_point< _Clock, _Duration2 > &  _Right  )

inline

    {   // add time_point to time_point
    return (_Left.time_since_epoch() - _Right.time_since_epoch());
    }

template<class _Rep1 , class _Period1 , class _Rep2 >

_Duration_div_mod<_Rep1, _Period1, _Rep2>::type constexpr chrono::operator/ ( const duration< _Rep1, _Period1 > &  _Left, const _Rep2 &  _Right  )

inline

    {   // divide duration by rep
    typedef typename common_type<_Rep1, _Rep2>::type _CR;
    typedef duration<_CR, _Period1> _CD;
    return (_CD(_CD(_Left).count() / _Right));
    }

template<class _Rep1 , class _Period1 , class _Rep2 , class _Period2 >

constexpr common_type<_Rep1, _Rep2>::type chrono::operator/ ( const duration< _Rep1, _Period1 > &  _Left, const duration< _Rep2, _Period2 > &  _Right  )

inline

    {   // divide duration by duration
    typedef typename common_type<
        duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _CD;
    return (_CD(_Left).count() / _CD(_Right).count());
    }

template<class _Rep1 , class _Period1 , class _Rep2 , class _Period2 >

constexpr bool chrono::operator< ( const duration< _Rep1, _Period1 > &  _Left, const duration< _Rep2, _Period2 > &  _Right  )

inline

    {   // test if duration < duration
    typedef typename common_type<
        duration<_Rep1, _Period1>,
        duration<_Rep2, _Period2> >::type _CT;
    return (_CT(_Left).count() < _CT(_Right).count());
    }

template<class _Clock , class _Duration1 , class _Duration2 >

constexpr bool chrono::operator< ( const time_point< _Clock, _Duration1 > &  _Left, const time_point< _Clock, _Duration2 > &  _Right  )

inline

    {   // test for time_point < time_point
    return (_Left.time_since_epoch() < _Right.time_since_epoch());
    }

template<class _Rep1 , class _Period1 , class _Rep2 , class _Period2 >

constexpr bool chrono::operator<= ( const duration< _Rep1, _Period1 > &  _Left, const duration< _Rep2, _Period2 > &  _Right  )

inline

    {   // test if duration <= duration
    return (!(_Right < _Left));
    }

template<class _Clock , class _Duration1 , class _Duration2 >

constexpr bool chrono::operator<= ( const time_point< _Clock, _Duration1 > &  _Left, const time_point< _Clock, _Duration2 > &  _Right  )

inline

    {   // test for time_point <= time_point
    return (!(_Right < _Left));
    }

template<class _Rep1 , class _Period1 , class _Rep2 , class _Period2 >

constexpr bool chrono::operator== ( const duration< _Rep1, _Period1 > &  _Left, const duration< _Rep2, _Period2 > &  _Right  )

inline

    {   // test if duration == duration
    typedef typename common_type<
        duration<_Rep1, _Period1>,
        duration<_Rep2, _Period2> >::type _CT;
    return (_CT(_Left).count() == _CT(_Right).count());
    }

template<class _Clock , class _Duration1 , class _Duration2 >

constexpr bool chrono::operator== ( const time_point< _Clock, _Duration1 > &  _Left, const time_point< _Clock, _Duration2 > &  _Right  )

inline

    {   // test for time_point == time_point
    return (_Left.time_since_epoch() == _Right.time_since_epoch());
    }

template<class _Rep1 , class _Period1 , class _Rep2 , class _Period2 >

constexpr bool chrono::operator> ( const duration< _Rep1, _Period1 > &  _Left, const duration< _Rep2, _Period2 > &  _Right  )

inline

    {   // test if duration > duration
    return (_Right < _Left);
    }

template<class _Clock , class _Duration1 , class _Duration2 >

constexpr bool chrono::operator> ( const time_point< _Clock, _Duration1 > &  _Left, const time_point< _Clock, _Duration2 > &  _Right  )

inline

    {   // test for time_point > time_point
    return (_Right < _Left);
    }

template<class _Rep1 , class _Period1 , class _Rep2 , class _Period2 >

constexpr bool chrono::operator>= ( const duration< _Rep1, _Period1 > &  _Left, const duration< _Rep2, _Period2 > &  _Right  )

inline

    {   // test if duration >= duration
    return (!(_Left < _Right));
    }

template<class _Clock , class _Duration1 , class _Duration2 >

constexpr bool chrono::operator>= ( const time_point< _Clock, _Duration1 > &  _Left, const time_point< _Clock, _Duration2 > &  _Right  )

inline

    {   // test for time_point >= time_point
    return (!(_Left < _Right));
    }

template<class _To , class _Rep , class _Period >

constexpr enable_if<_Is_duration<_To>::value, _To>::type chrono::round ( const duration< _Rep, _Period > &  _Dur )

inline

    {   // convert duration to another duration, round to nearest, ties to even
    return (_Round<_To>(_Dur,
        treat_as_floating_point<typename _To::rep>(),
        treat_as_floating_point<_Rep>()));
    }

template<class _To , class _Clock , class _Duration >

constexpr enable_if<_Is_duration<_To>::value, time_point<_Clock, _To> >::type chrono::round ( const time_point< _Clock, _Duration > &  _Time )

inline

    {   // change the duration type of a time_point; round to nearest, ties to even
    return (time_point<_Clock, _To>(
        chrono::round<_To>(_Time.time_since_epoch())));
    }

template<class _To , class _Clock , class _Duration >

constexpr enable_if<_Is_duration<_To>::value, time_point<_Clock, _To> >::type chrono::time_point_cast ( const time_point< _Clock, _Duration > &  _Time )

inline

    {   // change the duration type of a time_point; truncate
    return (time_point<_Clock, _To>(
        chrono::duration_cast<_To>(_Time.time_since_epoch())));
    }

Variable Documentation

template<class _Rep >

constexpr bool chrono::treat_as_floating_point_v = treat_as_floating_point<_Rep>::value