libstdc++-v3/include/std/stop_token - gcc - Git at Google

 // <stop_token> -*- C++ -*-

 // Copyright (C) 2019-2020 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
 // <http://www.gnu.org/licenses/>.

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

 #ifndef _GLIBCXX_STOP_TOKEN
 #define _GLIBCXX_STOP_TOKEN

 #if __cplusplus > 201703L

 #include <atomic>
 #include <bits/std_mutex.h>
 #include <ext/concurrence.h>
 #include <bits/unique_ptr.h>
 #include <bits/shared_ptr.h>

 #ifdef _GLIBCXX_HAS_GTHREADS
 # define __cpp_lib_jthread 201907L
 #endif

 namespace std _GLIBCXX_VISIBILITY(default)
 {
 _GLIBCXX_BEGIN_NAMESPACE_VERSION

   /// Tag type indicating a stop_source should have no shared-stop-state.
   struct nostopstate_t { explicit nostopstate_t() = default; };
   inline constexpr nostopstate_t nostopstate{};

   /// Allow testing whether a stop request has been made on a `stop_source`.
   class stop_token
   {
   public:
     stop_token() noexcept = default;

     stop_token(const stop_token& __other) noexcept = default;
     stop_token(stop_token&& __other) noexcept = default;

     ~stop_token() = default;

     stop_token&
     operator=(const stop_token& __rhs) noexcept = default;

     stop_token&
     operator=(stop_token&& __rhs) noexcept = default;

     [[nodiscard]]
     bool
     stop_possible() const noexcept
     {
       return static_cast<bool>(_M_state);
     }

     [[nodiscard]]
     bool
     stop_requested() const noexcept
     {
       return stop_possible() && _M_state->_M_stop_requested();
     }

     void
     swap(stop_token& __rhs) noexcept
     { _M_state.swap(__rhs._M_state); }

     [[nodiscard]]
     friend bool
     operator==(const stop_token& __a, const stop_token& __b)
     { return __a._M_state == __b._M_state; }

     friend void
     swap(stop_token& __lhs, stop_token& __rhs) noexcept
     { __lhs.swap(__rhs); }

   private:
     friend class stop_source;
     template<typename _Callback>
       friend class stop_callback;

     struct _Stop_cb
     {
       void(*_M_callback)(_Stop_cb*);
       _Stop_cb* _M_prev = nullptr;
       _Stop_cb* _M_next = nullptr;

       template<typename _Cb>
 	_Stop_cb(_Cb&& __cb)
 	: _M_callback(std::forward<_Cb>(__cb))
 	{ }

       bool
       _M_linked() const noexcept
       {
         return (_M_prev != nullptr)
           || (_M_next != nullptr);
       }

       static void
       _S_execute(_Stop_cb* __cb) noexcept
       {
         __cb->_M_callback(__cb);
         __cb->_M_prev = __cb->_M_next = nullptr;
       }
     };

     struct _Stop_state_t
     {
       std::atomic<bool> _M_stopped{false};
       _Stop_cb* _M_head = nullptr;
 #ifdef _GLIBCXX_HAS_GTHREADS
       std::mutex _M_mtx;
 #endif

       _Stop_state_t() = default;

       bool
       _M_stop_requested() noexcept
       {
         return _M_stopped;
       }

       bool
       _M_request_stop()
       {
         bool __stopped = false;
         if (_M_stopped.compare_exchange_strong(__stopped, true))
           {
 #ifdef _GLIBCXX_HAS_GTHREADS
             std::lock_guard<std::mutex> __lck{_M_mtx};
 #endif
             while (_M_head)
               {
                 auto __p = _M_head;
                 _M_head = _M_head->_M_next;
                 _Stop_cb::_S_execute(__p);
               }
             return true;
           }
         return false;
       }

       bool
       _M_register_callback(_Stop_cb* __cb)
       {
 #ifdef _GLIBCXX_HAS_GTHREADS
         std::lock_guard<std::mutex> __lck{_M_mtx};
 #endif
         if (_M_stopped)
           return false;

         __cb->_M_next = _M_head;
         if (_M_head)
           {
             _M_head->_M_prev = __cb;
           }
         _M_head = __cb;
         return true;
       }

       void
       _M_remove_callback(_Stop_cb* __cb)
       {
 #ifdef _GLIBCXX_HAS_GTHREADS
         std::lock_guard<std::mutex> __lck{_M_mtx};
 #endif
         if (__cb == _M_head)
           {
             _M_head = _M_head->_M_next;
             if (_M_head)
               {
                 _M_head->_M_prev = nullptr;
               }
           }
         else if (!__cb->_M_linked())
           {
             return;
           }
         else
           {
             __cb->_M_prev->_M_next = __cb->_M_next;
             if (__cb->_M_next)
               {
                 __cb->_M_next->_M_prev = __cb->_M_prev;
               }
           }
       }
     };

     using _Stop_state = std::shared_ptr<_Stop_state_t>;
     _Stop_state _M_state;

     explicit
     stop_token(const _Stop_state& __state) noexcept
     : _M_state{__state}
     { }
   };

   /// A type that allows a stop request to be made.
   class stop_source
   {
   public:
     stop_source()
       : _M_state(std::make_shared<stop_token::_Stop_state_t>())
     { }

     explicit stop_source(std::nostopstate_t) noexcept
     { }

     stop_source(const stop_source& __other) noexcept
       : _M_state(__other._M_state)
     { }

     stop_source(stop_source&& __other) noexcept
       : _M_state(std::move(__other._M_state))
     { }

     stop_source&
     operator=(const stop_source& __rhs) noexcept
     {
       if (_M_state != __rhs._M_state)
         _M_state = __rhs._M_state;
       return *this;
     }

     stop_source&
     operator=(stop_source&& __rhs) noexcept
     {
       std::swap(_M_state, __rhs._M_state);
       return *this;
     }

     [[nodiscard]]
     bool
     stop_possible() const noexcept
     {
       return static_cast<bool>(_M_state);
     }

     [[nodiscard]]
     bool
     stop_requested() const noexcept
     {
       return stop_possible() && _M_state->_M_stop_requested();
     }

     bool
     request_stop() const noexcept
     {
       if (stop_possible())
         return _M_state->_M_request_stop();
       return false;
     }

     [[nodiscard]]
     stop_token
     get_token() const noexcept
     {
       return stop_token{_M_state};
     }

     void
     swap(stop_source& __other) noexcept
     {
       _M_state.swap(__other._M_state);
     }

     [[nodiscard]]
     friend bool
     operator==(const stop_source& __a, const stop_source& __b) noexcept
     {
       return __a._M_state == __b._M_state;
     }

     friend void
     swap(stop_source& __lhs, stop_source& __rhs) noexcept
     {
       __lhs.swap(__rhs);
     }

   private:
     stop_token::_Stop_state _M_state;
   };

   /// A wrapper for callbacks to be run when a stop request is made.
   template<typename _Callback>
     class [[nodiscard]] stop_callback
       : private stop_token::_Stop_cb
     {
     public:
       using callback_type = _Callback;

       template<typename _Cb,
                enable_if_t<is_constructible_v<_Callback, _Cb>, int> = 0>
         explicit
 	stop_callback(const stop_token& __token, _Cb&& __cb)
         noexcept(is_nothrow_constructible_v<_Callback, _Cb>)
         : _Stop_cb(&_S_execute), _M_cb(std::forward<_Cb>(__cb))
         {
 	  if (auto __state = __token._M_state)
 	    {
 	      if (__state->_M_stop_requested())
 		_S_execute(this); // ensures std::terminate on throw
 	      else if (__state->_M_register_callback(this))
 		_M_state.swap(__state);
 	    }
         }

       template<typename _Cb,
                enable_if_t<is_constructible_v<_Callback, _Cb>, int> = 0>
         explicit
 	stop_callback(stop_token&& __token, _Cb&& __cb)
         noexcept(is_nothrow_constructible_v<_Callback, _Cb>)
         : _Stop_cb(&_S_execute), _M_cb(std::forward<_Cb>(__cb))
 	{
 	  if (auto& __state = __token._M_state)
 	    {
 	      if (__state->_M_stop_requested())
 		_S_execute(this); // ensures std::terminate on throw
 	      else if (__state->_M_register_callback(this))
 		_M_state.swap(__state);
 	    }
 	}

       ~stop_callback()
       {
 	if (_M_state)
 	  {
 	    _M_state->_M_remove_callback(this);
 	  }
       }

       stop_callback(const stop_callback&) = delete;
       stop_callback& operator=(const stop_callback&) = delete;
       stop_callback(stop_callback&&) = delete;
       stop_callback& operator=(stop_callback&&) = delete;

     private:
       _Callback _M_cb;
       stop_token::_Stop_state _M_state = nullptr;

       static void
       _S_execute(_Stop_cb* __that) noexcept
       {
 	static_cast<stop_callback*>(__that)->_M_cb();
       }
     };

   template<typename _Callback>
     stop_callback(stop_token, _Callback) -> stop_callback<_Callback>;

 _GLIBCXX_END_NAMESPACE_VERSION
 } // namespace
 #endif // __cplusplus > 201703L
 #endif // _GLIBCXX_STOP_TOKEN
	// <stop_token> -- C++ --

	// Copyright (C) 2019-2020 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
	// <http://www.gnu.org/licenses/>.

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

	#ifndef _GLIBCXX_STOP_TOKEN
	#define _GLIBCXX_STOP_TOKEN

	#if __cplusplus > 201703L

	#include <atomic>
	#include <bits/std_mutex.h>
	#include <ext/concurrence.h>
	#include <bits/unique_ptr.h>
	#include <bits/shared_ptr.h>

	#ifdef _GLIBCXX_HAS_GTHREADS
	# define __cpp_lib_jthread 201907L
	#endif

	namespace std _GLIBCXX_VISIBILITY(default)
	{
	_GLIBCXX_BEGIN_NAMESPACE_VERSION

	/// Tag type indicating a stop_source should have no shared-stop-state.
	struct nostopstate_t { explicit nostopstate_t() = default; };
	inline constexpr nostopstate_t nostopstate{};

	/// Allow testing whether a stop request has been made on a `stop_source`.
	class stop_token
	{
	public:
	stop_token() noexcept = default;

	stop_token(const stop_token& __other) noexcept = default;
	stop_token(stop_token&& __other) noexcept = default;

	~stop_token() = default;

	stop_token&
	operator=(const stop_token& __rhs) noexcept = default;

	stop_token&
	operator=(stop_token&& __rhs) noexcept = default;

	[[nodiscard]]
	bool
	stop_possible() const noexcept
	{
	return static_cast<bool>(_M_state);
	}

	[[nodiscard]]
	bool
	stop_requested() const noexcept
	{
	return stop_possible() && _M_state->_M_stop_requested();
	}

	void
	swap(stop_token& __rhs) noexcept
	{ _M_state.swap(__rhs._M_state); }

	[[nodiscard]]
	friend bool
	operator==(const stop_token& __a, const stop_token& __b)
	{ return __a._M_state == __b._M_state; }

	friend void
	swap(stop_token& __lhs, stop_token& __rhs) noexcept
	{ __lhs.swap(__rhs); }

	private:
	friend class stop_source;
	template<typename _Callback>
	friend class stop_callback;

	struct _Stop_cb
	{
	void(_M_callback)(_Stop_cb);
	_Stop_cb* _M_prev = nullptr;
	_Stop_cb* _M_next = nullptr;

	template<typename _Cb>
	_Stop_cb(_Cb&& __cb)
	: _M_callback(std::forward<_Cb>(__cb))
	{ }

	bool
	_M_linked() const noexcept
	{
	return (_M_prev != nullptr)
	\|\| (_M_next != nullptr);
	}

	static void
	_S_execute(_Stop_cb* __cb) noexcept
	{
	__cb->_M_callback(__cb);
	__cb->_M_prev = __cb->_M_next = nullptr;
	}
	};

	struct _Stop_state_t
	{
	std::atomic<bool> _M_stopped{false};
	_Stop_cb* _M_head = nullptr;
	#ifdef _GLIBCXX_HAS_GTHREADS
	std::mutex _M_mtx;
	#endif

	_Stop_state_t() = default;

	bool
	_M_stop_requested() noexcept
	{
	return _M_stopped;
	}

	bool
	_M_request_stop()
	{
	bool __stopped = false;
	if (_M_stopped.compare_exchange_strong(__stopped, true))
	{
	#ifdef _GLIBCXX_HAS_GTHREADS
	std::lock_guard<std::mutex> __lck{_M_mtx};
	#endif
	while (_M_head)
	{
	auto __p = _M_head;
	_M_head = _M_head->_M_next;
	_Stop_cb::_S_execute(__p);
	}
	return true;
	}
	return false;
	}

	bool
	_M_register_callback(_Stop_cb* __cb)
	{
	#ifdef _GLIBCXX_HAS_GTHREADS
	std::lock_guard<std::mutex> __lck{_M_mtx};
	#endif
	if (_M_stopped)
	return false;

	__cb->_M_next = _M_head;
	if (_M_head)
	{
	_M_head->_M_prev = __cb;
	}
	_M_head = __cb;
	return true;
	}

	void
	_M_remove_callback(_Stop_cb* __cb)
	{
	#ifdef _GLIBCXX_HAS_GTHREADS
	std::lock_guard<std::mutex> __lck{_M_mtx};
	#endif
	if (__cb == _M_head)
	{
	_M_head = _M_head->_M_next;
	if (_M_head)
	{
	_M_head->_M_prev = nullptr;
	}
	}
	else if (!__cb->_M_linked())
	{
	return;
	}
	else
	{
	__cb->_M_prev->_M_next = __cb->_M_next;
	if (__cb->_M_next)
	{
	__cb->_M_next->_M_prev = __cb->_M_prev;
	}
	}
	}
	};

	using _Stop_state = std::shared_ptr<_Stop_state_t>;
	_Stop_state _M_state;

	explicit
	stop_token(const _Stop_state& __state) noexcept
	: _M_state{__state}
	{ }
	};

	/// A type that allows a stop request to be made.
	class stop_source
	{
	public:
	stop_source()
	: _M_state(std::make_shared<stop_token::_Stop_state_t>())
	{ }

	explicit stop_source(std::nostopstate_t) noexcept
	{ }

	stop_source(const stop_source& __other) noexcept
	: _M_state(__other._M_state)
	{ }

	stop_source(stop_source&& __other) noexcept
	: _M_state(std::move(__other._M_state))
	{ }

	stop_source&
	operator=(const stop_source& __rhs) noexcept
	{
	if (_M_state != __rhs._M_state)
	_M_state = __rhs._M_state;
	return *this;
	}

	stop_source&
	operator=(stop_source&& __rhs) noexcept
	{
	std::swap(_M_state, __rhs._M_state);
	return *this;
	}

	[[nodiscard]]
	bool
	stop_possible() const noexcept
	{
	return static_cast<bool>(_M_state);
	}

	[[nodiscard]]
	bool
	stop_requested() const noexcept
	{
	return stop_possible() && _M_state->_M_stop_requested();
	}

	bool
	request_stop() const noexcept
	{
	if (stop_possible())
	return _M_state->_M_request_stop();
	return false;
	}

	[[nodiscard]]
	stop_token
	get_token() const noexcept
	{
	return stop_token{_M_state};
	}

	void
	swap(stop_source& __other) noexcept
	{
	_M_state.swap(__other._M_state);
	}

	[[nodiscard]]
	friend bool
	operator==(const stop_source& __a, const stop_source& __b) noexcept
	{
	return __a._M_state == __b._M_state;
	}

	friend void
	swap(stop_source& __lhs, stop_source& __rhs) noexcept
	{
	__lhs.swap(__rhs);
	}

	private:
	stop_token::_Stop_state _M_state;
	};

	/// A wrapper for callbacks to be run when a stop request is made.
	template<typename _Callback>
	class [[nodiscard]] stop_callback
	: private stop_token::_Stop_cb
	{
	public:
	using callback_type = _Callback;

	template<typename _Cb,
	enable_if_t<is_constructible_v<_Callback, _Cb>, int> = 0>
	explicit
	stop_callback(const stop_token& __token, _Cb&& __cb)
	noexcept(is_nothrow_constructible_v<_Callback, _Cb>)
	: _Stop_cb(&_S_execute), _M_cb(std::forward<_Cb>(__cb))
	{
	if (auto __state = __token._M_state)
	{
	if (__state->_M_stop_requested())
	_S_execute(this); // ensures std::terminate on throw
	else if (__state->_M_register_callback(this))
	_M_state.swap(__state);
	}
	}

	template<typename _Cb,
	enable_if_t<is_constructible_v<_Callback, _Cb>, int> = 0>
	explicit
	stop_callback(stop_token&& __token, _Cb&& __cb)
	noexcept(is_nothrow_constructible_v<_Callback, _Cb>)
	: _Stop_cb(&_S_execute), _M_cb(std::forward<_Cb>(__cb))
	{
	if (auto& __state = __token._M_state)
	{
	if (__state->_M_stop_requested())
	_S_execute(this); // ensures std::terminate on throw
	else if (__state->_M_register_callback(this))
	_M_state.swap(__state);
	}
	}

	~stop_callback()
	{
	if (_M_state)
	{
	_M_state->_M_remove_callback(this);
	}
	}

	stop_callback(const stop_callback&) = delete;
	stop_callback& operator=(const stop_callback&) = delete;
	stop_callback(stop_callback&&) = delete;
	stop_callback& operator=(stop_callback&&) = delete;

	private:
	_Callback _M_cb;
	stop_token::_Stop_state _M_state = nullptr;

	static void
	_S_execute(_Stop_cb* __that) noexcept
	{
	static_cast<stop_callback*>(__that)->_M_cb();
	}
	};

	template<typename _Callback>
	stop_callback(stop_token, _Callback) -> stop_callback<_Callback>;

	_GLIBCXX_END_NAMESPACE_VERSION
	} // namespace
	#endif // __cplusplus > 201703L
	#endif // _GLIBCXX_STOP_TOKEN