File Manager

X7ROOT File Manager

Current Path: /usr/include/c++/8

?? ..
?? algorithm(2.46 KB)
?? any(18.17 KB)
?? array(11.38 KB)
?? atomic(40.09 KB)
?? backward
?? bits
?? bitset(44.83 KB)
?? cassert(1.61 KB)
?? ccomplex(1.3 KB)
?? cctype(2.35 KB)
?? cerrno(1.73 KB)
?? cfenv(2 KB)
?? cfloat(1.84 KB)
?? charconv(16.32 KB)
?? chrono(29.17 KB)
?? cinttypes(2.11 KB)
?? ciso646(1.43 KB)
?? climits(1.87 KB)
?? clocale(1.86 KB)
?? cmath(47.01 KB)
?? codecvt(5.22 KB)
?? complex(53.26 KB)
?? complex.h(1.56 KB)
?? condition_variable(8.74 KB)
?? csetjmp(1.9 KB)
?? csignal(1.81 KB)
?? cstdalign(1.37 KB)
?? cstdarg(1.82 KB)
?? cstdbool(1.37 KB)
?? cstddef(6.29 KB)
?? cstdint(2.12 KB)
?? cstdio(4.33 KB)
?? cstdlib(6.18 KB)
?? cstring(3.05 KB)
?? ctgmath(1.33 KB)
?? ctime(2.08 KB)
?? cuchar(2.16 KB)
?? cwchar(6.36 KB)
?? cwctype(2.73 KB)
?? cxxabi.h(21.46 KB)
?? debug
?? decimal
?? deque(2.6 KB)
?? exception(4.69 KB)
?? experimental
?? ext
?? fenv.h(1.97 KB)
?? filesystem(1.4 KB)
?? forward_list(1.54 KB)
?? fstream(35.92 KB)
?? functional(36.87 KB)
?? future(49.49 KB)
?? initializer_list(2.9 KB)
?? iomanip(16.16 KB)
?? ios(1.56 KB)
?? iosfwd(6.76 KB)
?? iostream(2.63 KB)
?? istream(32.07 KB)
?? iterator(2.58 KB)
?? limits(67.56 KB)
?? list(2.53 KB)
?? locale(1.45 KB)
?? map(2.5 KB)
?? math.h(4.26 KB)
?? memory(4.6 KB)
?? mutex(17.8 KB)
?? new(7.34 KB)
?? numeric(5.32 KB)
?? optional(42.93 KB)
?? ostream(21.57 KB)
?? parallel
?? profile
?? queue(2.41 KB)
?? random(1.65 KB)
?? ratio(19.42 KB)
?? regex(1.85 KB)
?? scoped_allocator(15.84 KB)
?? set(2.5 KB)
?? shared_mutex(18.95 KB)
?? sstream(26.24 KB)
?? stack(2.33 KB)
?? stdexcept(7.79 KB)
?? stdlib.h(2.2 KB)
?? streambuf(29.31 KB)
?? string(1.89 KB)
?? string_view(20.3 KB)
?? system_error(11.25 KB)
?? tgmath.h(1.33 KB)
?? thread(10.27 KB)
?? tr1
?? tr2
?? tuple(58.94 KB)
?? type_traits(83.86 KB)
?? typeindex(3.02 KB)
?? typeinfo(7.51 KB)
?? unordered_map(1.8 KB)
?? unordered_set(1.8 KB)
?? utility(12.01 KB)
?? valarray(39.33 KB)
?? variant(47.11 KB)
?? vector(2.68 KB)
?? x86_64-redhat-linux

Editing: condition_variable

// <condition_variable> -*- 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
// <http://www.gnu.org/licenses/>.

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

#ifndef _GLIBCXX_CONDITION_VARIABLE
#define _GLIBCXX_CONDITION_VARIABLE 1

#pragma GCC system_header

#if __cplusplus < 201103L
# include <bits/c++0x_warning.h>
#else

#include <chrono>
#include <bits/std_mutex.h>
#include <ext/concurrence.h>
#include <bits/alloc_traits.h>
#include <bits/allocator.h>
#include <bits/unique_ptr.h>
#include <bits/shared_ptr.h>
#include <bits/cxxabi_forced.h>

#if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1)

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

/**
   * @defgroup condition_variables Condition Variables
   * @ingroup concurrency
   *
   * Classes for condition_variable support.
   * @{
   */

/// cv_status
  enum class cv_status { no_timeout, timeout };

/// condition_variable
  class condition_variable
  {
    typedef chrono::system_clock	__clock_t;
    typedef __gthread_cond_t		__native_type;

#ifdef __GTHREAD_COND_INIT
    __native_type			_M_cond = __GTHREAD_COND_INIT;
#else
    __native_type			_M_cond;
#endif

public:
    typedef __native_type* 		native_handle_type;

condition_variable() noexcept;
    ~condition_variable() noexcept;

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

void
    notify_one() noexcept;

void
    notify_all() noexcept;

void
    wait(unique_lock<mutex>& __lock) noexcept;

template<typename _Predicate>
      void
      wait(unique_lock<mutex>& __lock, _Predicate __p)
      {
	while (!__p())
	  wait(__lock);
      }

template<typename _Duration>
      cv_status
      wait_until(unique_lock<mutex>& __lock,
		 const chrono::time_point<__clock_t, _Duration>& __atime)
      { return __wait_until_impl(__lock, __atime); }

template<typename _Clock, typename _Duration>
      cv_status
      wait_until(unique_lock<mutex>& __lock,
		 const chrono::time_point<_Clock, _Duration>& __atime)
      {
	// DR 887 - Sync unknown clock to known clock.
	const typename _Clock::time_point __c_entry = _Clock::now();
	const __clock_t::time_point __s_entry = __clock_t::now();
	const auto __delta = __atime - __c_entry;
	const auto __s_atime = __s_entry + __delta;

return __wait_until_impl(__lock, __s_atime);
      }

template<typename _Clock, typename _Duration, typename _Predicate>
      bool
      wait_until(unique_lock<mutex>& __lock,
		 const chrono::time_point<_Clock, _Duration>& __atime,
		 _Predicate __p)
      {
	while (!__p())
	  if (wait_until(__lock, __atime) == cv_status::timeout)
	    return __p();
	return true;
      }

template<typename _Rep, typename _Period>
      cv_status
      wait_for(unique_lock<mutex>& __lock,
	       const chrono::duration<_Rep, _Period>& __rtime)
      {
	using __dur = typename __clock_t::duration;
	auto __reltime = chrono::duration_cast<__dur>(__rtime);
	if (__reltime < __rtime)
	  ++__reltime;
	return wait_until(__lock, __clock_t::now() + __reltime);
      }

template<typename _Rep, typename _Period, typename _Predicate>
      bool
      wait_for(unique_lock<mutex>& __lock,
	       const chrono::duration<_Rep, _Period>& __rtime,
	       _Predicate __p)
      {
	using __dur = typename __clock_t::duration;
	auto __reltime = chrono::duration_cast<__dur>(__rtime);
	if (__reltime < __rtime)
	  ++__reltime;
	return wait_until(__lock, __clock_t::now() + __reltime, std::move(__p));
      }

native_handle_type
    native_handle()
    { return &_M_cond; }

private:
    template<typename _Dur>
      cv_status
      __wait_until_impl(unique_lock<mutex>& __lock,
			const chrono::time_point<__clock_t, _Dur>& __atime)
      {
	auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
	auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);

__gthread_time_t __ts =
	  {
	    static_cast<std::time_t>(__s.time_since_epoch().count()),
	    static_cast<long>(__ns.count())
	  };

__gthread_cond_timedwait(&_M_cond, __lock.mutex()->native_handle(),
				 &__ts);

return (__clock_t::now() < __atime
		? cv_status::no_timeout : cv_status::timeout);
      }
  };

void
  notify_all_at_thread_exit(condition_variable&, unique_lock<mutex>);

struct __at_thread_exit_elt
  {
    __at_thread_exit_elt* _M_next;
    void (*_M_cb)(void*);
  };

inline namespace _V2 {

/// condition_variable_any
  // Like above, but mutex is not required to have try_lock.
  class condition_variable_any
  {
    typedef chrono::system_clock	__clock_t;
    condition_variable			_M_cond;
    shared_ptr<mutex>			_M_mutex;

// scoped unlock - unlocks in ctor, re-locks in dtor
    template<typename _Lock>
      struct _Unlock
      {
	explicit _Unlock(_Lock& __lk) : _M_lock(__lk) { __lk.unlock(); }

~_Unlock() noexcept(false)
	{
	  if (uncaught_exception())
	    {
	      __try
	      { _M_lock.lock(); }
	      __catch(const __cxxabiv1::__forced_unwind&)
	      { __throw_exception_again; }
	      __catch(...)
	      { }
	    }
	  else
	    _M_lock.lock();
	}

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

_Lock& _M_lock;
      };

public:
    condition_variable_any() : _M_mutex(std::make_shared<mutex>()) { }
    ~condition_variable_any() = default;

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

void
    notify_one() noexcept
    {
      lock_guard<mutex> __lock(*_M_mutex);
      _M_cond.notify_one();
    }

void
    notify_all() noexcept
    {
      lock_guard<mutex> __lock(*_M_mutex);
      _M_cond.notify_all();
    }

template<typename _Lock>
      void
      wait(_Lock& __lock)
      {
	shared_ptr<mutex> __mutex = _M_mutex;
	unique_lock<mutex> __my_lock(*__mutex);
	_Unlock<_Lock> __unlock(__lock);
	// *__mutex must be unlocked before re-locking __lock so move
	// ownership of *__mutex lock to an object with shorter lifetime.
	unique_lock<mutex> __my_lock2(std::move(__my_lock));
	_M_cond.wait(__my_lock2);
      }

template<typename _Lock, typename _Predicate>
      void
      wait(_Lock& __lock, _Predicate __p)
      {
	while (!__p())
	  wait(__lock);
      }

template<typename _Lock, typename _Clock, typename _Duration>
      cv_status
      wait_until(_Lock& __lock,
		 const chrono::time_point<_Clock, _Duration>& __atime)
      {
	shared_ptr<mutex> __mutex = _M_mutex;
	unique_lock<mutex> __my_lock(*__mutex);
	_Unlock<_Lock> __unlock(__lock);
	// *__mutex must be unlocked before re-locking __lock so move
	// ownership of *__mutex lock to an object with shorter lifetime.
	unique_lock<mutex> __my_lock2(std::move(__my_lock));
	return _M_cond.wait_until(__my_lock2, __atime);
      }

template<typename _Lock, typename _Clock,
	     typename _Duration, typename _Predicate>
      bool
      wait_until(_Lock& __lock,
		 const chrono::time_point<_Clock, _Duration>& __atime,
		 _Predicate __p)
      {
	while (!__p())
	  if (wait_until(__lock, __atime) == cv_status::timeout)
	    return __p();
	return true;
      }

template<typename _Lock, typename _Rep, typename _Period>
      cv_status
      wait_for(_Lock& __lock, const chrono::duration<_Rep, _Period>& __rtime)
      { return wait_until(__lock, __clock_t::now() + __rtime); }

template<typename _Lock, typename _Rep,
	     typename _Period, typename _Predicate>
      bool
      wait_for(_Lock& __lock,
	       const chrono::duration<_Rep, _Period>& __rtime, _Predicate __p)
      { return wait_until(__lock, __clock_t::now() + __rtime, std::move(__p)); }
  };

} // end inline namespace

// @} group condition_variables
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace

#endif // _GLIBCXX_HAS_GTHREADS && _GLIBCXX_USE_C99_STDINT_TR1

#endif // C++11

#endif // _GLIBCXX_CONDITION_VARIABLE

X7ROOT File Manager

Editing: condition_variable

Upload File

Create Folder