Where Online Learning is simpler!

The C and C++ Include Header Files

/usr/include/c++/13/experimental/timer


$ cat -n /usr/include/c++/13/experimental/timer

     1	// <experimental/timer> -*- C++ -*-
     2	
     3	// Copyright (C) 2015-2023 Free Software Foundation, Inc.
     4	//
     5	// This file is part of the GNU ISO C++ Library.  This library is free
     6	// software; you can redistribute it and/or modify it under the
     7	// terms of the GNU General Public License as published by the
     8	// Free Software Foundation; either version 3, or (at your option)
     9	// any later version.
    10	
    11	// This library is distributed in the hope that it will be useful,
    12	// but WITHOUT ANY WARRANTY; without even the implied warranty of
    13	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    14	// GNU General Public License for more details.
    15	
    16	// Under Section 7 of GPL version 3, you are granted additional
    17	// permissions described in the GCC Runtime Library Exception, version
    18	// 3.1, as published by the Free Software Foundation.
    19	
    20	// You should have received a copy of the GNU General Public License and
    21	// a copy of the GCC Runtime Library Exception along with this program;
    22	// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
    23	// <http://www.gnu.org/licenses/>.
    24	
    25	/** @file experimental/timer
    26	 *  This is a TS C++ Library header.
    27	 *  @ingroup networking-ts
    28	 */
    29	
    30	#ifndef _GLIBCXX_EXPERIMENTAL_TIMER
    31	#define _GLIBCXX_EXPERIMENTAL_TIMER 1
    32	
    33	#pragma GCC system_header
    34	
    35	#include <bits/requires_hosted.h> // experimental is currently omitted
    36	
    37	#if __cplusplus >= 201402L
    38	
    39	#include <bits/chrono.h>
    40	#include <system_error>
    41	#include <thread>
    42	#include <experimental/netfwd>
    43	#include <experimental/io_context>
    44	#include <experimental/bits/net.h>
    45	
    46	namespace std _GLIBCXX_VISIBILITY(default)
    47	{
    48	_GLIBCXX_BEGIN_NAMESPACE_VERSION
    49	namespace experimental
    50	{
    51	namespace net
    52	{
    53	inline namespace v1
    54	{
    55	
    56	  /** @addtogroup networking-ts
    57	   *  @{
    58	   */
    59	
    60	  template<typename _Clock>
    61	    struct wait_traits
    62	    {
    63	      static typename _Clock::duration
    64	      to_wait_duration(const typename _Clock::duration& __d)
    65	      { return __d; }
    66	
    67	      static typename _Clock::duration
    68	      to_wait_duration(const typename _Clock::time_point& __t)
    69	      {
    70		auto __now = _Clock::now();
    71		auto __diff = __t - __now;
    72		if (__diff > _Clock::duration::max())
    73		  return _Clock::duration::max();
    74		if (__diff < _Clock::duration::min())
    75		  return _Clock::duration::min();
    76		return __diff;
    77	      }
    78	    };
    79	
    80	  template<typename _Clock, typename _WaitTraits>
    81	    class basic_waitable_timer
    82	    {
    83	    public:
    84	      // types:
    85	
    86	      using executor_type = io_context::executor_type;
    87	      using clock_type = _Clock;
    88	      using duration = typename clock_type::duration;
    89	      using time_point = typename clock_type::time_point;
    90	      using traits_type = _WaitTraits;
    91	
    92	      // construct / copy / destroy:
    93	
    94	      explicit
    95	      basic_waitable_timer(io_context& __ctx)
    96	      : _M_ex(__ctx.get_executor()), _M_expiry()
    97	      { }
    98	
    99	      basic_waitable_timer(io_context& __ctx, const time_point& __t)
   100	      : _M_ex(__ctx.get_executor()), _M_expiry(__t)
   101	      { }
   102	
   103	      basic_waitable_timer(io_context& __ctx, const duration& __d)
   104	      : _M_ex(__ctx.get_executor()), _M_expiry(_Clock::now() + __d)
   105	      { }
   106	
   107	      basic_waitable_timer(const basic_waitable_timer&) = delete;
   108	
   109	      basic_waitable_timer(basic_waitable_timer&& __rhs)
   110	      : _M_ex(std::move(__rhs._M_ex)), _M_expiry(__rhs._M_expiry)
   111	      {
   112		_M_key.swap(__rhs._M_key);
   113		__rhs._M_expiry = time_point{};
   114	      }
   115	
   116	      ~basic_waitable_timer() { cancel(); }
   117	
   118	      basic_waitable_timer& operator=(const basic_waitable_timer&) = delete;
   119	
   120	      basic_waitable_timer&
   121	      operator=(basic_waitable_timer&& __rhs)
   122	      {
   123		if (this == std::addressof(__rhs))
   124		  return *this;
   125		cancel();
   126		_M_ex = std::move(__rhs._M_ex);
   127		_M_expiry = __rhs._M_expiry;
   128		__rhs._M_expiry = time_point{};
   129		_M_key.swap(__rhs._M_key);
   130		return *this;
   131	      }
   132	
   133	      // basic_waitable_timer operations:
   134	
   135	      executor_type get_executor() noexcept { return _M_ex; }
   136	
   137	      size_t cancel() { return _M_ex.context().cancel(*this); }
   138	      size_t cancel_one() { return _M_ex.context().cancel_one(*this); }
   139	
   140	      time_point expiry() const { return _M_expiry; }
   141	
   142	      size_t expires_at(const time_point& __t)
   143	      {
   144		size_t __cancelled = cancel();
   145		_M_expiry = __t;
   146		return __cancelled;
   147	      }
   148	
   149	      size_t expires_after(const duration& __d)
   150	      { return expires_at(_Clock::now() + __d); }
   151	
   152	      void wait();
   153	      void wait(error_code& __ec);
   154	
   155	      template<typename _CompletionToken>
   156		__deduced_t<_CompletionToken, void(error_code)>
   157		async_wait(_CompletionToken&& __token)
   158		{
   159		  async_completion<_CompletionToken, void(error_code)> __init(__token);
   160		  _M_ex.context().async_wait(*this,
   161					     std::move(__init.completion_handler));
   162		  return __init.result.get();
   163		}
   164	
   165	    private:
   166	      executor_type _M_ex;
   167	      time_point _M_expiry;
   168	
   169	      struct _Key { };  // TODO move _M_expiry into here?
   170	      unique_ptr<_Key> _M_key{new _Key};
   171	
   172	      friend class io_context;
   173	    };
   174	
   175	  using system_timer = basic_waitable_timer<chrono::system_clock>;
   176	  using steady_timer = basic_waitable_timer<chrono::steady_clock>;
   177	  using high_resolution_timer
   178	    = basic_waitable_timer<chrono::high_resolution_clock>;
   179	
   180	  template<typename _Clock, typename _WaitTraits>
   181	    void
   182	    basic_waitable_timer<_Clock, _WaitTraits>::wait()
   183	    {
   184	      _M_ex.dispatch([this] {
   185		  while (clock_type::now() < _M_expiry)
   186		    this_thread::sleep_for(traits_type::to_wait_duration(_M_expiry));
   187	      }, allocator<void>{});
   188	    }
   189	
   190	  template<typename _Clock, typename _WaitTraits>
   191	    void
   192	    basic_waitable_timer<_Clock, _WaitTraits>::wait(error_code&)
   193	    {
   194	      _M_ex.dispatch([this] {
   195		  while (clock_type::now() < _M_expiry)
   196		    this_thread::sleep_for(traits_type::to_wait_duration(_M_expiry));
   197	      }, allocator<void>{});
   198	    }
   199	
   200	  /// @}
   201	
   202	} // namespace v1
   203	} // namespace net
   204	} // namespace experimental
   205	_GLIBCXX_END_NAMESPACE_VERSION
   206	} // namespace std
   207	
   208	#endif // C++14
   209	
   210	#endif // _GLIBCXX_EXPERIMENTAL_TIMER