dolphin/Source/Core/Common/StdConditionVariable.h

// Copyright 2013 Dolphin Emulator Project
// Licensed under GPLv2
// Refer to the license.txt file included.

#pragma once

#define GCC_VER(x,y,z)  ((x) * 10000 + (y) * 100 + (z))
#define GCC_VERSION GCC_VER(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)

#ifndef __has_include
#define __has_include(s) 0
#endif

#if GCC_VERSION >= GCC_VER(4,4,0) && __GXX_EXPERIMENTAL_CXX0X__

// GCC 4.4 provides <condition_variable>
#include <condition_variable> // IWYU pragma: export

#elif __has_include(<condition_variable>) && !ANDROID

// clang and libc++ provide <condition_variable> on OSX. However, the version
// of libc++ bundled with OSX 10.7 and 10.8 is buggy: it uses _ as a variable.
//
// We work around this issue by undefining and redefining _.

#include <condition_variable> // IWYU pragma: export

#elif _MSC_VER >= 1700

// The standard implementation is included since VS2012
#include <condition_variable> // IWYU pragma: export

#else

// partial std::condition_variable implementation for win32/pthread

#include "Common/StdMutex.h"

#if (_MSC_VER >= 1600) || (GCC_VERSION >= GCC_VER(4,3,0) && __GXX_EXPERIMENTAL_CXX0X__)
#define USE_RVALUE_REFERENCES
#endif

namespace std
{

class condition_variable
{
#if defined(_WIN32)
	typedef CONDITION_VARIABLE native_type;
#else
	typedef pthread_cond_t native_type;
#endif

public:

	typedef native_type* native_handle_type;

	condition_variable()
	{
#if defined(_WIN32)
		InitializeConditionVariable(&m_handle);
#else
		pthread_cond_init(&m_handle, nullptr);
#endif
	}

	~condition_variable()
	{
#ifndef _WIN32
		pthread_cond_destroy(&m_handle);
#endif
	}

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

	void notify_one()
	{
#if defined(_WIN32)
		WakeConditionVariable(&m_handle);
#else
		pthread_cond_signal(&m_handle);
#endif
	}

	void notify_all()
	{
#if defined(_WIN32)
		WakeAllConditionVariable(&m_handle);
#else
		pthread_cond_broadcast(&m_handle);
#endif
	}

	void wait(unique_lock<mutex>& lock)
	{
#ifdef _WIN32
		SleepConditionVariableSRW(&m_handle, lock.mutex()->native_handle(), INFINITE, 0);
#else
		pthread_cond_wait(&m_handle, lock.mutex()->native_handle());
#endif
	}

	template <class Predicate>
	void wait(unique_lock<mutex>& lock, Predicate pred)
	{
		while (!pred())
			wait(lock);
	}

	//template <class Clock, class Duration>
	//cv_status wait_until(unique_lock<mutex>& lock,
	//	const chrono::time_point<Clock, Duration>& abs_time);

	//template <class Clock, class Duration, class Predicate>
	//	bool wait_until(unique_lock<mutex>& lock,
	//	const chrono::time_point<Clock, Duration>& abs_time,
	//	Predicate pred);

	//template <class Rep, class Period>
	//cv_status wait_for(unique_lock<mutex>& lock,
	//	const chrono::duration<Rep, Period>& rel_time);

	//template <class Rep, class Period, class Predicate>
	//	bool wait_for(unique_lock<mutex>& lock,
	//	const chrono::duration<Rep, Period>& rel_time,
	//	Predicate pred);

	native_handle_type native_handle()
	{
		return &m_handle;
	}

private:
	native_type m_handle;
};

}

#endif