<h2>File Contents: //usr/include/c++/8/chrono</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='//usr/include/c++/8/chrono'><textarea name='file_content' rows='10' cols='50'>// &lt;chrono&gt; -*- C++ -*-

// Copyright (C) 2008-2018 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// &lt;http://www.gnu.org/licenses/&gt;.

/** @file include/chrono
 *  This is a Standard C++ Library header.
 */

#ifndef _GLIBCXX_CHRONO
#define _GLIBCXX_CHRONO 1

#pragma GCC system_header

#if __cplusplus &lt; 201103L
# include &lt;bits/c++0x_warning.h&gt;
#else

#include &lt;ratio&gt;
#include &lt;type_traits&gt;
#include &lt;limits&gt;
#include &lt;ctime&gt;
#include &lt;bits/parse_numbers.h&gt; // for literals support.

#ifdef _GLIBCXX_USE_C99_STDINT_TR1

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

  /**
   * @defgroup chrono Time
   * @ingroup utilities
   *
   * Classes and functions for time.
   * @{
   */

  /** @namespace std::chrono
   *  @brief ISO C++ 2011 entities sub-namespace for time and date.
   */
  namespace chrono
  {
    template&lt;typename _Rep, typename _Period = ratio&lt;1&gt;&gt;
      struct duration;

    template&lt;typename _Clock, typename _Dur = typename _Clock::duration&gt;
      struct time_point;
  }

  // 20.11.4.3 specialization of common_type (for duration, sfinae-friendly)

  template&lt;typename _CT, typename _Period1, typename _Period2&gt;
    struct __duration_common_type_wrapper
    {
    private:
      typedef __static_gcd&lt;_Period1::num, _Period2::num&gt; __gcd_num;
      typedef __static_gcd&lt;_Period1::den, _Period2::den&gt; __gcd_den;
      typedef typename _CT::type __cr;
      typedef ratio&lt;__gcd_num::value,
        (_Period1::den / __gcd_den::value) * _Period2::den&gt; __r;
    public:
      typedef __success_type&lt;chrono::duration&lt;__cr, __r&gt;&gt; type;
    };

  template&lt;typename _Period1, typename _Period2&gt;
    struct __duration_common_type_wrapper&lt;__failure_type, _Period1, _Period2&gt;
    { typedef __failure_type type; };

  template&lt;typename _Rep1, typename _Period1, typename _Rep2, typename _Period2&gt;
    struct common_type&lt;chrono::duration&lt;_Rep1, _Period1&gt;,
             chrono::duration&lt;_Rep2, _Period2&gt;&gt;
    : public __duration_common_type_wrapper&lt;typename __member_type_wrapper&lt;
             common_type&lt;_Rep1, _Rep2&gt;&gt;::type, _Period1, _Period2&gt;::type
    { };

  // 20.11.4.3 specialization of common_type (for time_point, sfinae-friendly)

  template&lt;typename _CT, typename _Clock&gt;
    struct __timepoint_common_type_wrapper
    {
      typedef __success_type&lt;chrono::time_point&lt;_Clock, typename _CT::type&gt;&gt;
        type;
    };

  template&lt;typename _Clock&gt;
    struct __timepoint_common_type_wrapper&lt;__failure_type, _Clock&gt;
    { typedef __failure_type type; };

  template&lt;typename _Clock, typename _Duration1, typename _Duration2&gt;
    struct common_type&lt;chrono::time_point&lt;_Clock, _Duration1&gt;,
             chrono::time_point&lt;_Clock, _Duration2&gt;&gt;
    : public __timepoint_common_type_wrapper&lt;typename __member_type_wrapper&lt;
             common_type&lt;_Duration1, _Duration2&gt;&gt;::type, _Clock&gt;::type
    { };

  namespace chrono
  {
    // Primary template for duration_cast impl.
    template&lt;typename _ToDur, typename _CF, typename _CR,
	     bool _NumIsOne = false, bool _DenIsOne = false&gt;
      struct __duration_cast_impl
      {
	template&lt;typename _Rep, typename _Period&gt;
	  static constexpr _ToDur
	  __cast(const duration&lt;_Rep, _Period&gt;&amp; __d)
	  {
	    typedef typename _ToDur::rep			__to_rep;
	    return _ToDur(static_cast&lt;__to_rep&gt;(static_cast&lt;_CR&gt;(__d.count())
	      * static_cast&lt;_CR&gt;(_CF::num)
	      / static_cast&lt;_CR&gt;(_CF::den)));
	  }
      };

    template&lt;typename _ToDur, typename _CF, typename _CR&gt;
      struct __duration_cast_impl&lt;_ToDur, _CF, _CR, true, true&gt;
      {
	template&lt;typename _Rep, typename _Period&gt;
	  static constexpr _ToDur
	  __cast(const duration&lt;_Rep, _Period&gt;&amp; __d)
	  {
	    typedef typename _ToDur::rep			__to_rep;
	    return _ToDur(static_cast&lt;__to_rep&gt;(__d.count()));
	  }
      };

    template&lt;typename _ToDur, typename _CF, typename _CR&gt;
      struct __duration_cast_impl&lt;_ToDur, _CF, _CR, true, false&gt;
      {
	template&lt;typename _Rep, typename _Period&gt;
	  static constexpr _ToDur
	  __cast(const duration&lt;_Rep, _Period&gt;&amp; __d)
	  {
	    typedef typename _ToDur::rep			__to_rep;
	    return _ToDur(static_cast&lt;__to_rep&gt;(
	      static_cast&lt;_CR&gt;(__d.count()) / static_cast&lt;_CR&gt;(_CF::den)));
	  }
      };

    template&lt;typename _ToDur, typename _CF, typename _CR&gt;
      struct __duration_cast_impl&lt;_ToDur, _CF, _CR, false, true&gt;
      {
	template&lt;typename _Rep, typename _Period&gt;
	  static constexpr _ToDur
	  __cast(const duration&lt;_Rep, _Period&gt;&amp; __d)
	  {
	    typedef typename _ToDur::rep			__to_rep;
	    return _ToDur(static_cast&lt;__to_rep&gt;(
	      static_cast&lt;_CR&gt;(__d.count()) * static_cast&lt;_CR&gt;(_CF::num)));
	  }
      };

    template&lt;typename _Tp&gt;
      struct __is_duration
      : std::false_type
      { };

    template&lt;typename _Rep, typename _Period&gt;
      struct __is_duration&lt;duration&lt;_Rep, _Period&gt;&gt;
      : std::true_type
      { };

    template&lt;typename _Tp&gt;
      using __enable_if_is_duration
	= typename enable_if&lt;__is_duration&lt;_Tp&gt;::value, _Tp&gt;::type;

    template&lt;typename _Tp&gt;
      using __disable_if_is_duration
	= typename enable_if&lt;!__is_duration&lt;_Tp&gt;::value, _Tp&gt;::type;

    /// duration_cast
    template&lt;typename _ToDur, typename _Rep, typename _Period&gt;
      constexpr __enable_if_is_duration&lt;_ToDur&gt;
      duration_cast(const duration&lt;_Rep, _Period&gt;&amp; __d)
      {
	typedef typename _ToDur::period				__to_period;
	typedef typename _ToDur::rep				__to_rep;
	typedef ratio_divide&lt;_Period, __to_period&gt; 		__cf;
	typedef typename common_type&lt;__to_rep, _Rep, intmax_t&gt;::type
	  							__cr;
	typedef  __duration_cast_impl&lt;_ToDur, __cf, __cr,
				      __cf::num == 1, __cf::den == 1&gt; __dc;
	return __dc::__cast(__d);
      }

    /// treat_as_floating_point
    template&lt;typename _Rep&gt;
      struct treat_as_floating_point
      : is_floating_point&lt;_Rep&gt;
      { };

#if __cplusplus &gt; 201402L
    template &lt;typename _Rep&gt;
      inline constexpr bool treat_as_floating_point_v =
        treat_as_floating_point&lt;_Rep&gt;::value;
#endif // C++17

#if __cplusplus &gt;= 201703L
# define __cpp_lib_chrono 201611

    template&lt;typename _ToDur, typename _Rep, typename _Period&gt;
      constexpr __enable_if_is_duration&lt;_ToDur&gt;
      floor(const duration&lt;_Rep, _Period&gt;&amp; __d)
      {
	auto __to = chrono::duration_cast&lt;_ToDur&gt;(__d);
	if (__to &gt; __d)
	  return __to - _ToDur{1};
	return __to;
      }

    template&lt;typename _ToDur, typename _Rep, typename _Period&gt;
      constexpr __enable_if_is_duration&lt;_ToDur&gt;
      ceil(const duration&lt;_Rep, _Period&gt;&amp; __d)
      {
	auto __to = chrono::duration_cast&lt;_ToDur&gt;(__d);
	if (__to &lt; __d)
	  return __to + _ToDur{1};
	return __to;
      }

    template &lt;typename _ToDur, typename _Rep, typename _Period&gt;
      constexpr enable_if_t&lt;
	__and_&lt;__is_duration&lt;_ToDur&gt;,
	       __not_&lt;treat_as_floating_point&lt;typename _ToDur::rep&gt;&gt;&gt;::value,
	_ToDur&gt;
      round(const duration&lt;_Rep, _Period&gt;&amp; __d)
      {
	_ToDur __t0 = chrono::floor&lt;_ToDur&gt;(__d);
	_ToDur __t1 = __t0 + _ToDur{1};
	auto __diff0 = __d - __t0;
	auto __diff1 = __t1 - __d;
	if (__diff0 == __diff1)
	{
	    if (__t0.count() &amp; 1)
		return __t1;
	    return __t0;
	}
	else if (__diff0 &lt; __diff1)
	    return __t0;
	return __t1;
      }

    template&lt;typename _Rep, typename _Period&gt;
      constexpr
      enable_if_t&lt;numeric_limits&lt;_Rep&gt;::is_signed, duration&lt;_Rep, _Period&gt;&gt;
      abs(duration&lt;_Rep, _Period&gt; __d)
      {
	if (__d &gt;= __d.zero())
	  return __d;
	return -__d;
      }
#endif // C++17

    /// duration_values
    template&lt;typename _Rep&gt;
      struct duration_values
      {
	static constexpr _Rep
	zero() noexcept
	{ return _Rep(0); }

	static constexpr _Rep
	max() noexcept
	{ return numeric_limits&lt;_Rep&gt;::max(); }

	static constexpr _Rep
	min() noexcept
	{ return numeric_limits&lt;_Rep&gt;::lowest(); }
      };

    template&lt;typename _Tp&gt;
      struct __is_ratio
      : std::false_type
      { };

    template&lt;intmax_t _Num, intmax_t _Den&gt;
      struct __is_ratio&lt;ratio&lt;_Num, _Den&gt;&gt;
      : std::true_type
      { };

    /// duration
    template&lt;typename _Rep, typename _Period&gt;
      struct duration
      {
      private:
	template&lt;typename _Rep2&gt;
	  using __is_float = treat_as_floating_point&lt;_Rep2&gt;;

	// _Period2 is an exact multiple of _Period
	template&lt;typename _Period2&gt;
	  using __is_harmonic
	    = __bool_constant&lt;ratio_divide&lt;_Period2, _Period&gt;::den == 1&gt;;

      public:

	typedef _Rep						rep;
	typedef _Period 					period;

	static_assert(!__is_duration&lt;_Rep&gt;::value, &quot;rep cannot be a duration&quot;);
	static_assert(__is_ratio&lt;_Period&gt;::value,
		      &quot;period must be a specialization of ratio&quot;);
	static_assert(_Period::num &gt; 0, &quot;period must be positive&quot;);

	// 20.11.5.1 construction / copy / destroy
	constexpr duration() = default;

	duration(const duration&amp;) = default;

	// _GLIBCXX_RESOLVE_LIB_DEFECTS
	// 3050. Conversion specification problem in chrono::duration
	template&lt;typename _Rep2, typename = _Require&lt;
		 is_convertible&lt;const _Rep2&amp;, rep&gt;,
		 __or_&lt;__is_float&lt;rep&gt;, __not_&lt;__is_float&lt;_Rep2&gt;&gt;&gt;&gt;&gt;
	  constexpr explicit duration(const _Rep2&amp; __rep)
	  : __r(static_cast&lt;rep&gt;(__rep)) { }

	template&lt;typename _Rep2, typename _Period2, typename = _Require&lt;
		 __or_&lt;__is_float&lt;rep&gt;,
		       __and_&lt;__is_harmonic&lt;_Period2&gt;,
			      __not_&lt;__is_float&lt;_Rep2&gt;&gt;&gt;&gt;&gt;&gt;
	  constexpr duration(const duration&lt;_Rep2, _Period2&gt;&amp; __d)
	  : __r(duration_cast&lt;duration&gt;(__d).count()) { }

	~duration() = default;
	duration&amp; operator=(const duration&amp;) = default;

	// 20.11.5.2 observer
	constexpr rep
	count() const
	{ return __r; }

	// 20.11.5.3 arithmetic
	constexpr duration
	operator+() const
	{ return *this; }

	constexpr duration
	operator-() const
	{ return duration(-__r); }

	_GLIBCXX17_CONSTEXPR duration&amp;
	operator++()
	{
	  ++__r;
	  return *this;
	}

	_GLIBCXX17_CONSTEXPR duration
	operator++(int)
	{ return duration(__r++); }

	_GLIBCXX17_CONSTEXPR duration&amp;
	operator--()
	{
	  --__r;
	  return *this;
	}

	_GLIBCXX17_CONSTEXPR duration
	operator--(int)
	{ return duration(__r--); }

	_GLIBCXX17_CONSTEXPR duration&amp;
	operator+=(const duration&amp; __d)
	{
	  __r += __d.count();
	  return *this;
	}

	_GLIBCXX17_CONSTEXPR duration&amp;
	operator-=(const duration&amp; __d)
	{
	  __r -= __d.count();
	  return *this;
	}

	_GLIBCXX17_CONSTEXPR duration&amp;
	operator*=(const rep&amp; __rhs)
	{
	  __r *= __rhs;
	  return *this;
	}

	_GLIBCXX17_CONSTEXPR duration&amp;
	operator/=(const rep&amp; __rhs)
	{
	  __r /= __rhs;
	  return *this;
	}

	// DR 934.
	template&lt;typename _Rep2 = rep&gt;
	  _GLIBCXX17_CONSTEXPR
	  typename enable_if&lt;!treat_as_floating_point&lt;_Rep2&gt;::value,
			     duration&amp;&gt;::type
	  operator%=(const rep&amp; __rhs)
	  {
	    __r %= __rhs;
	    return *this;
	  }

	template&lt;typename _Rep2 = rep&gt;
	  _GLIBCXX17_CONSTEXPR
	  typename enable_if&lt;!treat_as_floating_point&lt;_Rep2&gt;::value,
			     duration&amp;&gt;::type
	  operator%=(const duration&amp; __d)
	  {
	    __r %= __d.count();
	    return *this;
	  }

	// 20.11.5.4 special values
	static constexpr duration
	zero() noexcept
	{ return duration(duration_values&lt;rep&gt;::zero()); }

	static constexpr duration
	min() noexcept
	{ return duration(duration_values&lt;rep&gt;::min()); }

	static constexpr duration
	max() noexcept
	{ return duration(duration_values&lt;rep&gt;::max()); }

      private:
	rep __r;
      };

    template&lt;typename _Rep1, typename _Period1,
	     typename _Rep2, typename _Period2&gt;
      constexpr typename common_type&lt;duration&lt;_Rep1, _Period1&gt;,
				     duration&lt;_Rep2, _Period2&gt;&gt;::type
      operator+(const duration&lt;_Rep1, _Period1&gt;&amp; __lhs,
		const duration&lt;_Rep2, _Period2&gt;&amp; __rhs)
      {
	typedef duration&lt;_Rep1, _Period1&gt;			__dur1;
	typedef duration&lt;_Rep2, _Period2&gt;			__dur2;
	typedef typename common_type&lt;__dur1,__dur2&gt;::type	__cd;
	return __cd(__cd(__lhs).count() + __cd(__rhs).count());
      }

    template&lt;typename _Rep1, typename _Period1,
	     typename _Rep2, typename _Period2&gt;
      constexpr typename common_type&lt;duration&lt;_Rep1, _Period1&gt;,
				     duration&lt;_Rep2, _Period2&gt;&gt;::type
      operator-(const duration&lt;_Rep1, _Period1&gt;&amp; __lhs,
		const duration&lt;_Rep2, _Period2&gt;&amp; __rhs)
      {
	typedef duration&lt;_Rep1, _Period1&gt;			__dur1;
	typedef duration&lt;_Rep2, _Period2&gt;			__dur2;
	typedef typename common_type&lt;__dur1,__dur2&gt;::type	__cd;
	return __cd(__cd(__lhs).count() - __cd(__rhs).count());
      }

    // SFINAE helper to obtain common_type&lt;_Rep1, _Rep2&gt; only if _Rep2
    // is implicitly convertible to it.
    // _GLIBCXX_RESOLVE_LIB_DEFECTS
    // 3050. Conversion specification problem in chrono::duration constructor
    template&lt;typename _Rep1, typename _Rep2,
	     typename _CRep = typename common_type&lt;_Rep1, _Rep2&gt;::type&gt;
      using __common_rep_t = typename
	enable_if&lt;is_convertible&lt;const _Rep2&amp;, _CRep&gt;::value, _CRep&gt;::type;

    template&lt;typename _Rep1, typename _Period, typename _Rep2&gt;
      constexpr duration&lt;__common_rep_t&lt;_Rep1, _Rep2&gt;, _Period&gt;
      operator*(const duration&lt;_Rep1, _Period&gt;&amp; __d, const _Rep2&amp; __s)
      {
	typedef duration&lt;typename common_type&lt;_Rep1, _Rep2&gt;::type, _Period&gt;
	  __cd;
	return __cd(__cd(__d).count() * __s);
      }

    template&lt;typename _Rep1, typename _Rep2, typename _Period&gt;
      constexpr duration&lt;__common_rep_t&lt;_Rep2, _Rep1&gt;, _Period&gt;
      operator*(const _Rep1&amp; __s, const duration&lt;_Rep2, _Period&gt;&amp; __d)
      { return __d * __s; }

    template&lt;typename _Rep1, typename _Period, typename _Rep2&gt;
      constexpr
      duration&lt;__common_rep_t&lt;_Rep1, __disable_if_is_duration&lt;_Rep2&gt;&gt;, _Period&gt;
      operator/(const duration&lt;_Rep1, _Period&gt;&amp; __d, const _Rep2&amp; __s)
      {
	typedef duration&lt;typename common_type&lt;_Rep1, _Rep2&gt;::type, _Period&gt;
	  __cd;
	return __cd(__cd(__d).count() / __s);
      }

    template&lt;typename _Rep1, typename _Period1,
	     typename _Rep2, typename _Period2&gt;
      constexpr typename common_type&lt;_Rep1, _Rep2&gt;::type
      operator/(const duration&lt;_Rep1, _Period1&gt;&amp; __lhs,
		const duration&lt;_Rep2, _Period2&gt;&amp; __rhs)
      {
	typedef duration&lt;_Rep1, _Period1&gt;			__dur1;
	typedef duration&lt;_Rep2, _Period2&gt;			__dur2;
	typedef typename common_type&lt;__dur1,__dur2&gt;::type	__cd;
	return __cd(__lhs).count() / __cd(__rhs).count();
      }

    // DR 934.
    template&lt;typename _Rep1, typename _Period, typename _Rep2&gt;
      constexpr
      duration&lt;__common_rep_t&lt;_Rep1, __disable_if_is_duration&lt;_Rep2&gt;&gt;, _Period&gt;
      operator%(const duration&lt;_Rep1, _Period&gt;&amp; __d, const _Rep2&amp; __s)
      {
	typedef duration&lt;typename common_type&lt;_Rep1, _Rep2&gt;::type, _Period&gt;
	  __cd;
	return __cd(__cd(__d).count() % __s);
      }

    template&lt;typename _Rep1, typename _Period1,
	     typename _Rep2, typename _Period2&gt;
      constexpr typename common_type&lt;duration&lt;_Rep1, _Period1&gt;,
				     duration&lt;_Rep2, _Period2&gt;&gt;::type
      operator%(const duration&lt;_Rep1, _Period1&gt;&amp; __lhs,
		const duration&lt;_Rep2, _Period2&gt;&amp; __rhs)
      {
	typedef duration&lt;_Rep1, _Period1&gt;			__dur1;
	typedef duration&lt;_Rep2, _Period2&gt;			__dur2;
	typedef typename common_type&lt;__dur1,__dur2&gt;::type	__cd;
	return __cd(__cd(__lhs).count() % __cd(__rhs).count());
      }

    // comparisons
    template&lt;typename _Rep1, typename _Period1,
	     typename _Rep2, typename _Period2&gt;
      constexpr bool
      operator==(const duration&lt;_Rep1, _Period1&gt;&amp; __lhs,
		 const duration&lt;_Rep2, _Period2&gt;&amp; __rhs)
      {
	typedef duration&lt;_Rep1, _Period1&gt;			__dur1;
	typedef duration&lt;_Rep2, _Period2&gt;			__dur2;
	typedef typename common_type&lt;__dur1,__dur2&gt;::type	__ct;
	return __ct(__lhs).count() == __ct(__rhs).count();
      }

    template&lt;typename _Rep1, typename _Period1,
	     typename _Rep2, typename _Period2&gt;
      constexpr bool
      operator&lt;(const duration&lt;_Rep1, _Period1&gt;&amp; __lhs,
		const duration&lt;_Rep2, _Period2&gt;&amp; __rhs)
      {
	typedef duration&lt;_Rep1, _Period1&gt;			__dur1;
	typedef duration&lt;_Rep2, _Period2&gt;			__dur2;
	typedef typename common_type&lt;__dur1,__dur2&gt;::type	__ct;
	return __ct(__lhs).count() &lt; __ct(__rhs).count();
      }

    template&lt;typename _Rep1, typename _Period1,
	     typename _Rep2, typename _Period2&gt;
      constexpr bool
      operator!=(const duration&lt;_Rep1, _Period1&gt;&amp; __lhs,
		 const duration&lt;_Rep2, _Period2&gt;&amp; __rhs)
      { return !(__lhs == __rhs); }

    template&lt;typename _Rep1, typename _Period1,
	     typename _Rep2, typename _Period2&gt;
      constexpr bool
      operator&lt;=(const duration&lt;_Rep1, _Period1&gt;&amp; __lhs,
		 const duration&lt;_Rep2, _Period2&gt;&amp; __rhs)
      { return !(__rhs &lt; __lhs); }

    template&lt;typename _Rep1, typename _Period1,
	     typename _Rep2, typename _Period2&gt;
      constexpr bool
      operator&gt;(const duration&lt;_Rep1, _Period1&gt;&amp; __lhs,
		const duration&lt;_Rep2, _Period2&gt;&amp; __rhs)
      { return __rhs &lt; __lhs; }

    template&lt;typename _Rep1, typename _Period1,
	     typename _Rep2, typename _Period2&gt;
      constexpr bool
      operator&gt;=(const duration&lt;_Rep1, _Period1&gt;&amp; __lhs,
		 const duration&lt;_Rep2, _Period2&gt;&amp; __rhs)
      { return !(__lhs &lt; __rhs); }

    /// nanoseconds
    typedef duration&lt;int64_t, nano&gt; 	    nanoseconds;

    /// microseconds
    typedef duration&lt;int64_t, micro&gt; 	    microseconds;

    /// milliseconds
    typedef duration&lt;int64_t, milli&gt; 	    milliseconds;

    /// seconds
    typedef duration&lt;int64_t&gt; 		    seconds;

    /// minutes
    typedef duration&lt;int64_t, ratio&lt; 60&gt;&gt;   minutes;

    /// hours
    typedef duration&lt;int64_t, ratio&lt;3600&gt;&gt;  hours;

    /// time_point
    template&lt;typename _Clock, typename _Dur&gt;
      struct time_point
      {
	typedef _Clock			  			clock;
	typedef _Dur		  				duration;
	typedef typename duration::rep	  			rep;
	typedef typename duration::period			period;

	constexpr time_point() : __d(duration::zero())
	{ }

	constexpr explicit time_point(const duration&amp; __dur)
	: __d(__dur)
	{ }

	// conversions
	template&lt;typename _Dur2,
		 typename = _Require&lt;is_convertible&lt;_Dur2, _Dur&gt;&gt;&gt;
	  constexpr time_point(const time_point&lt;clock, _Dur2&gt;&amp; __t)
	  : __d(__t.time_since_epoch())
	  { }

	// observer
	constexpr duration
	time_since_epoch() const
	{ return __d; }

	// arithmetic
	_GLIBCXX17_CONSTEXPR time_point&amp;
	operator+=(const duration&amp; __dur)
	{
	  __d += __dur;
	  return *this;
	}

	_GLIBCXX17_CONSTEXPR time_point&amp;
	operator-=(const duration&amp; __dur)
	{
	  __d -= __dur;
	  return *this;
	}

	// special values
	static constexpr time_point
	min() noexcept
	{ return time_point(duration::min()); }

	static constexpr time_point
	max() noexcept
	{ return time_point(duration::max()); }

      private:
	duration __d;
      };

    /// time_point_cast
    template&lt;typename _ToDur, typename _Clock, typename _Dur&gt;
      constexpr typename enable_if&lt;__is_duration&lt;_ToDur&gt;::value,
				   time_point&lt;_Clock, _ToDur&gt;&gt;::type
      time_point_cast(const time_point&lt;_Clock, _Dur&gt;&amp; __t)
      {
	typedef time_point&lt;_Clock, _ToDur&gt; 			__time_point;
	return __time_point(duration_cast&lt;_ToDur&gt;(__t.time_since_epoch()));
      }

#if __cplusplus &gt; 201402L
    template&lt;typename _ToDur, typename _Clock, typename _Dur&gt;
      constexpr
      enable_if_t&lt;__is_duration&lt;_ToDur&gt;::value, time_point&lt;_Clock, _ToDur&gt;&gt;
      floor(const time_point&lt;_Clock, _Dur&gt;&amp; __tp)
      {
	return time_point&lt;_Clock, _ToDur&gt;{
	    chrono::floor&lt;_ToDur&gt;(__tp.time_since_epoch())};
      }

    template&lt;typename _ToDur, typename _Clock, typename _Dur&gt;
      constexpr
      enable_if_t&lt;__is_duration&lt;_ToDur&gt;::value, time_point&lt;_Clock, _ToDur&gt;&gt;
      ceil(const time_point&lt;_Clock, _Dur&gt;&amp; __tp)
      {
	return time_point&lt;_Clock, _ToDur&gt;{
	    chrono::ceil&lt;_ToDur&gt;(__tp.time_since_epoch())};
      }

    template&lt;typename _ToDur, typename _Clock, typename _Dur&gt;
      constexpr enable_if_t&lt;
	__and_&lt;__is_duration&lt;_ToDur&gt;,
	       __not_&lt;treat_as_floating_point&lt;typename _ToDur::rep&gt;&gt;&gt;::value,
	time_point&lt;_Clock, _ToDur&gt;&gt;
      round(const time_point&lt;_Clock, _Dur&gt;&amp; __tp)
      {
	return time_point&lt;_Clock, _ToDur&gt;{
	    chrono::round&lt;_ToDur&gt;(__tp.time_since_epoch())};
      }
#endif // C++17

    template&lt;typename _Clock, typename _Dur1,
	     typename _Rep2, typename _Period2&gt;
      constexpr time_point&lt;_Clock,
	typename common_type&lt;_Dur1, duration&lt;_Rep2, _Period2&gt;&gt;::type&gt;
      operator+(const time_point&lt;_Clock, _Dur1&gt;&amp; __lhs,
		const duration&lt;_Rep2, _Period2&gt;&amp; __rhs)
      {
	typedef duration&lt;_Rep2, _Period2&gt;			__dur2;
	typedef typename common_type&lt;_Dur1,__dur2&gt;::type	__ct;
	typedef time_point&lt;_Clock, __ct&gt; 			__time_point;
	return __time_point(__lhs.time_since_epoch() + __rhs);
      }

    template&lt;typename _Rep1, typename _Period1,
	     typename _Clock, typename _Dur2&gt;
      constexpr time_point&lt;_Clock,
	typename common_type&lt;duration&lt;_Rep1, _Period1&gt;, _Dur2&gt;::type&gt;
      operator+(const duration&lt;_Rep1, _Period1&gt;&amp; __lhs,
		const time_point&lt;_Clock, _Dur2&gt;&amp; __rhs)
      {
	typedef duration&lt;_Rep1, _Period1&gt;			__dur1;
	typedef typename common_type&lt;__dur1,_Dur2&gt;::type	__ct;
	typedef time_point&lt;_Clock, __ct&gt; 			__time_point;
	return __time_point(__rhs.time_since_epoch() + __lhs);
      }

    template&lt;typename _Clock, typename _Dur1,
	     typename _Rep2, typename _Period2&gt;
      constexpr time_point&lt;_Clock,
	typename common_type&lt;_Dur1, duration&lt;_Rep2, _Period2&gt;&gt;::type&gt;
      operator-(const time_point&lt;_Clock, _Dur1&gt;&amp; __lhs,
		const duration&lt;_Rep2, _Period2&gt;&amp; __rhs)
      {
	typedef duration&lt;_Rep2, _Period2&gt;			__dur2;
	typedef typename common_type&lt;_Dur1,__dur2&gt;::type	__ct;
	typedef time_point&lt;_Clock, __ct&gt; 			__time_point;
	return __time_point(__lhs.time_since_epoch() -__rhs);
      }

    template&lt;typename _Clock, typename _Dur1, typename _Dur2&gt;
      constexpr typename common_type&lt;_Dur1, _Dur2&gt;::type
      operator-(const time_point&lt;_Clock, _Dur1&gt;&amp; __lhs,
		const time_point&lt;_Clock, _Dur2&gt;&amp; __rhs)
      { return __lhs.time_since_epoch() - __rhs.time_since_epoch(); }

    template&lt;typename _Clock, typename _Dur1, typename _Dur2&gt;
      constexpr bool
      operator==(const time_point&lt;_Clock, _Dur1&gt;&amp; __lhs,
		 const time_point&lt;_Clock, _Dur2&gt;&amp; __rhs)
      { return __lhs.time_since_epoch() == __rhs.time_since_epoch(); }

    template&lt;typename _Clock, typename _Dur1, typename _Dur2&gt;
      constexpr bool
      operator!=(const time_point&lt;_Clock, _Dur1&gt;&amp; __lhs,
		 const time_point&lt;_Clock, _Dur2&gt;&amp; __rhs)
      { return !(__lhs == __rhs); }

    template&lt;typename _Clock, typename _Dur1, typename _Dur2&gt;
      constexpr bool
      operator&lt;(const time_point&lt;_Clock, _Dur1&gt;&amp; __lhs,
		const time_point&lt;_Clock, _Dur2&gt;&amp; __rhs)
      { return  __lhs.time_since_epoch() &lt; __rhs.time_since_epoch(); }

    template&lt;typename _Clock, typename _Dur1, typename _Dur2&gt;
      constexpr bool
      operator&lt;=(const time_point&lt;_Clock, _Dur1&gt;&amp; __lhs,
		 const time_point&lt;_Clock, _Dur2&gt;&amp; __rhs)
      { return !(__rhs &lt; __lhs); }

    template&lt;typename _Clock, typename _Dur1, typename _Dur2&gt;
      constexpr bool
      operator&gt;(const time_point&lt;_Clock, _Dur1&gt;&amp; __lhs,
		const time_point&lt;_Clock, _Dur2&gt;&amp; __rhs)
      { return __rhs &lt; __lhs; }

    template&lt;typename _Clock, typename _Dur1, typename _Dur2&gt;
      constexpr bool
      operator&gt;=(const time_point&lt;_Clock, _Dur1&gt;&amp; __lhs,
		 const time_point&lt;_Clock, _Dur2&gt;&amp; __rhs)
      { return !(__lhs &lt; __rhs); }


    // Clocks.

    // Why nanosecond resolution as the default?
    // Why have std::system_clock always count in the highest
    // resolution (ie nanoseconds), even if on some OSes the low 3
    // or 9 decimal digits will be always zero? This allows later
    // implementations to change the system_clock::now()
    // implementation any time to provide better resolution without
    // changing function signature or units.

    // To support the (forward) evolution of the library's defined
    // clocks, wrap inside inline namespace so that the current
    // defintions of system_clock, steady_clock, and
    // high_resolution_clock types are uniquely mangled. This way, new
    // code can use the latests clocks, while the library can contain
    // compatibility definitions for previous versions.  At some
    // point, when these clocks settle down, the inlined namespaces
    // can be removed.  XXX GLIBCXX_ABI Deprecated
    inline namespace _V2 {

    /**
     *  @brief System clock.
     *
     *  Time returned represents wall time from the system-wide clock.
    */
    struct system_clock
    {
      typedef chrono::nanoseconds     				duration;
      typedef duration::rep    					rep;
      typedef duration::period 					period;
      typedef chrono::time_point&lt;system_clock, duration&gt; 	time_point;

      static_assert(system_clock::duration::min()
		    &lt; system_clock::duration::zero(),
		    &quot;a clock's minimum duration cannot be less than its epoch&quot;);

      static constexpr bool is_steady = false;

      static time_point
      now() noexcept;

      // Map to C API
      static std::time_t
      to_time_t(const time_point&amp; __t) noexcept
      {
	return std::time_t(duration_cast&lt;chrono::seconds&gt;
			   (__t.time_since_epoch()).count());
      }

      static time_point
      from_time_t(std::time_t __t) noexcept
      {
	typedef chrono::time_point&lt;system_clock, seconds&gt;	__from;
	return time_point_cast&lt;system_clock::duration&gt;
	       (__from(chrono::seconds(__t)));
      }
    };


    /**
     *  @brief Monotonic clock
     *
     *  Time returned has the property of only increasing at a uniform rate.
    */
    struct steady_clock
    {
      typedef chrono::nanoseconds 				duration;
      typedef duration::rep	  				rep;
      typedef duration::period	  				period;
      typedef chrono::time_point&lt;steady_clock, duration&gt; 	time_point;

      static constexpr bool is_steady = true;

      static time_point
      now() noexcept;
    };


    /**
     *  @brief Highest-resolution clock
     *
     *  This is the clock &quot;with the shortest tick period.&quot; Alias to
     *  std::system_clock until higher-than-nanosecond definitions
     *  become feasible.
    */
    using high_resolution_clock = system_clock;

    } // end inline namespace _V2
  } // namespace chrono

#if __cplusplus &gt; 201103L

#define __cpp_lib_chrono_udls 201304

  inline namespace literals
  {
  inline namespace chrono_literals
  {
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored &quot;-Wliteral-suffix&quot;
    template&lt;typename _Rep, unsigned long long _Val&gt;
      struct _Checked_integral_constant
      : integral_constant&lt;_Rep, static_cast&lt;_Rep&gt;(_Val)&gt;
      {
	static_assert(_Checked_integral_constant::value &gt;= 0
		      &amp;&amp; _Checked_integral_constant::value == _Val,
		      &quot;literal value cannot be represented by duration type&quot;);
      };

    template&lt;typename _Dur, char... _Digits&gt;
      constexpr _Dur __check_overflow()
      {
	using _Val = __parse_int::_Parse_int&lt;_Digits...&gt;;
	using _Rep = typename _Dur::rep;
	// TODO: should be simply integral_constant&lt;_Rep, _Val::value&gt;
	// but GCC doesn't reject narrowing conversions to _Rep.
	using _CheckedVal = _Checked_integral_constant&lt;_Rep, _Val::value&gt;;
	return _Dur{_CheckedVal::value};
      }

    constexpr chrono::duration&lt;long double, ratio&lt;3600,1&gt;&gt;
    operator&quot;&quot;h(long double __hours)
    { return chrono::duration&lt;long double, ratio&lt;3600,1&gt;&gt;{__hours}; }

    template &lt;char... _Digits&gt;
      constexpr chrono::hours
      operator&quot;&quot;h()
      { return __check_overflow&lt;chrono::hours, _Digits...&gt;(); }

    constexpr chrono::duration&lt;long double, ratio&lt;60,1&gt;&gt;
    operator&quot;&quot;min(long double __mins)
    { return chrono::duration&lt;long double, ratio&lt;60,1&gt;&gt;{__mins}; }

    template &lt;char... _Digits&gt;
      constexpr chrono::minutes
      operator&quot;&quot;min()
      { return __check_overflow&lt;chrono::minutes, _Digits...&gt;(); }

    constexpr chrono::duration&lt;long double&gt;
    operator&quot;&quot;s(long double __secs)
    { return chrono::duration&lt;long double&gt;{__secs}; }

    template &lt;char... _Digits&gt;
      constexpr chrono::seconds
      operator&quot;&quot;s()
      { return __check_overflow&lt;chrono::seconds, _Digits...&gt;(); }

    constexpr chrono::duration&lt;long double, milli&gt;
    operator&quot;&quot;ms(long double __msecs)
    { return chrono::duration&lt;long double, milli&gt;{__msecs}; }

    template &lt;char... _Digits&gt;
      constexpr chrono::milliseconds
      operator&quot;&quot;ms()
      { return __check_overflow&lt;chrono::milliseconds, _Digits...&gt;(); }

    constexpr chrono::duration&lt;long double, micro&gt;
    operator&quot;&quot;us(long double __usecs)
    { return chrono::duration&lt;long double, micro&gt;{__usecs}; }

    template &lt;char... _Digits&gt;
      constexpr chrono::microseconds
      operator&quot;&quot;us()
      { return __check_overflow&lt;chrono::microseconds, _Digits...&gt;(); }

    constexpr chrono::duration&lt;long double, nano&gt;
    operator&quot;&quot;ns(long double __nsecs)
    { return chrono::duration&lt;long double, nano&gt;{__nsecs}; }

    template &lt;char... _Digits&gt;
      constexpr chrono::nanoseconds
      operator&quot;&quot;ns()
      { return __check_overflow&lt;chrono::nanoseconds, _Digits...&gt;(); }

#pragma GCC diagnostic pop
  } // inline namespace chrono_literals
  } // inline namespace literals

  namespace chrono
  {
    using namespace literals::chrono_literals;
  } // namespace chrono

#endif // C++14

  // @} group chrono

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std

#endif //_GLIBCXX_USE_C99_STDINT_TR1

#endif // C++11

#endif //_GLIBCXX_CHRONO
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2F%2Fusr%2Finclude%2Fc%2B%2B%2F8'>⬅ Back to Directory</a>