#ifndef _TINYTHREAD_H_

#define _TINYTHREAD_H_

#if !defined(_TTHREAD_PLATFORM_DEFINED_)

#if defined(_WIN32) || defined(__WIN32__) || defined(__WINDOWS__)

#define _TTHREAD_WIN32_

#else

#define _TTHREAD_POSIX_

#endif

#define _TTHREAD_PLATFORM_DEFINED_

#endif

#if defined(_TTHREAD_WIN32_)

#ifndef WIN32_LEAN_AND_MEAN

#define WIN32_LEAN_AND_MEAN

#define __UNDEF_LEAN_AND_MEAN

#endif

#include <windows.h>

#ifdef __UNDEF_LEAN_AND_MEAN

#undef WIN32_LEAN_AND_MEAN

#undef __UNDEF_LEAN_AND_MEAN

#endif

#else

#include <pthread.h>

#include <signal.h>

#include <sched.h>

#include <unistd.h>

#endif

#include <ostream>

#define TINYTHREAD_VERSION_MAJOR 1

#define TINYTHREAD_VERSION_MINOR 1

#define TINYTHREAD_VERSION (TINYTHREAD_VERSION_MAJOR * 100 + TINYTHREAD_VERSION_MINOR)

#if (__cplusplus > 199711L) || (defined(__STDCXX_VERSION__) && (__STDCXX_VERSION__ >= 201001L))

#define _TTHREAD_CPP11_

#endif

#if defined(_TTHREAD_CPP11_) || defined(__GXX_EXPERIMENTAL_CXX0X__) || defined(__GXX_EXPERIMENTAL_CPP0X__)

#define _TTHREAD_CPP11_PARTIAL_

#endif

#ifdef _TTHREAD_CPP11_PARTIAL_

#define _TTHREAD_DISABLE_ASSIGNMENT(name) \

name(const name&) = delete; \

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

#else

#define _TTHREAD_DISABLE_ASSIGNMENT(name) \

name(const name&); \

name& operator=(const name&);

#endif

#if !defined(_TTHREAD_CPP11_) && !defined(thread_local)

#if defined(__GNUC__) || defined(__INTEL_COMPILER) || defined(__SUNPRO_CC) || defined(__IBMCPP__)

#define thread_local __thread

#else

#define thread_local __declspec(thread)

#endif

#endif

namespace tthread {

class mutex {

public:

/// Constructor.

mutex()

#if defined(_TTHREAD_WIN32_)

: mAlreadyLocked(false)

#endif

{

#if defined(_TTHREAD_WIN32_)

InitializeCriticalSection(&mHandle);

#else

pthread_mutex_init(&mHandle, NULL);

#endif

}

/// Destructor.

~mutex()

{

#if defined(_TTHREAD_WIN32_)

DeleteCriticalSection(&mHandle);

#else

pthread_mutex_destroy(&mHandle);

#endif

}

/// Lock the mutex.

/// The method will block the calling thread until a lock on the mutex can

/// be obtained. The mutex remains locked until @c unlock() is called.

/// @see lock_guard

inline void lock()

}

/// Try to lock the mutex.

/// The method will try to lock the mutex. If it fails, the function will

/// return immediately (non-blocking).

/// @return @c true if the lock was acquired, or @c false if the lock could

/// not be acquired.

inline bool try_lock()

}

/// Unlock the mutex.

/// If any threads are waiting for the lock on this mutex, one of them will

/// be unblocked.

inline void unlock()

}

_TTHREAD_DISABLE_ASSIGNMENT(mutex)

private:

#if defined(_TTHREAD_WIN32_)

CRITICAL_SECTION mHandle;

bool mAlreadyLocked;

#else

pthread_mutex_t mHandle;

#endif

friend class condition_variable;

};

class recursive_mutex {

};

template <class T>

class lock_guard {

};

class condition_variable {

};

class thread {

{}

/// Thread starting constructor.

/// Construct a @c thread object with a new thread of execution.

/// @param[in] aFunction A function pointer to a function of type:

/// <tt>void fun(void * arg)</tt>

/// @param[in] aArg Argument to the thread function.

/// @note This constructor is not fully compatible with the standard C++

/// thread class. It is more similar to the pthread_create() (POSIX) and

/// CreateThread() (Windows) functions.

thread(void (*aFunction)(void *), void * aArg);

/// Destructor.

/// @note If the thread is joinable upon destruction, @c std::terminate()

/// will be called, which terminates the process. It is always wise to do

/// @c join() before deleting a thread object.

~thread();

/// Wait for the thread to finish (join execution flows).

/// After calling @c join(), the thread object is no longer associated with

/// a thread of execution (i.e. it is not joinable, and you may not join

/// with it nor detach from it).

void join();

/// Check if the thread is joinable.

/// A thread object is joinable if it has an associated thread of execution.

bool joinable() const;

/// Detach from the thread.

/// After calling @c detach(), the thread object is no longer assicated with

/// a thread of execution (i.e. it is not joinable). The thread continues

/// execution without the calling thread blocking, and when the thread

/// ends execution, any owned resources are released.

void detach();

/// Return the thread ID of a thread object.

id get_id() const;

/// Get the native handle for this thread.

/// @note Under Windows, this is a @c HANDLE, and under POSIX systems, this

/// is a @c pthread_t.

inline native_handle_type native_handle()

{

return mHandle;

}

/// Determine the number of threads which can possibly execute concurrently.

/// This function is useful for determining the optimal number of threads to

/// use for a task.

/// @return The number of hardware thread contexts in the system.

/// @note If this value is not defined, the function returns zero (0).

static unsigned hardware_concurrency();

_TTHREAD_DISABLE_ASSIGNMENT(thread)

private:

native_handle_type mHandle; ///< Thread handle.

mutable mutex mDataMutex; ///< Serializer for access to the thread private data.

bool mNotAThread; ///< True if this object is not a thread of execution.

#if defined(_TTHREAD_WIN32_)

unsigned int mWin32ThreadID; ///< Unique thread ID (filled out by _beginthreadex).

#endif

// This is the internal thread wrapper function.

#if defined(_TTHREAD_WIN32_)

static unsigned WINAPI wrapper_function(void * aArg);

#else

static void * wrapper_function(void * aArg);

#endif

};

class thread::id {

public:

/// Default constructor.

/// The default constructed ID is that of thread without a thread of

/// execution.

id() : mId(0) {};

id(unsigned long int aId) : mId(aId) {};

id(const id& aId) : mId(aId.mId) {};

inline id & operator=(const id &aId)

{

mId = aId.mId;

return *this;

}

inline friend bool operator==(const id &aId1, const id &aId2)

{

return (aId1.mId == aId2.mId);

}

inline friend bool operator!=(const id &aId1, const id &aId2)

{

return (aId1.mId != aId2.mId);

}

inline friend bool operator<=(const id &aId1, const id &aId2)

{

return (aId1.mId <= aId2.mId);

}

inline friend bool operator<(const id &aId1, const id &aId2)

{

return (aId1.mId < aId2.mId);

}

inline friend bool operator>=(const id &aId1, const id &aId2)

{

return (aId1.mId >= aId2.mId);

}

inline friend bool operator>(const id &aId1, const id &aId2)

{

return (aId1.mId > aId2.mId);

}

inline friend std::ostream& operator <<(std::ostream &os, const id &obj)

{

os << obj.mId;

return os;

}

private:

unsigned long int mId;

};

typedef long long __intmax_t;

template <__intmax_t N, __intmax_t D = 1> class ratio {

public:

static double _as_double() { return double(N) / double(D); }

};

namespace chrono {

/// Duration template class. This class provides enough functionality to

/// implement @c this_thread::sleep_for().

template <class _Rep, class _Period = ratio<1> > class duration {

};

// Standard duration types.

typedef duration<__intmax_t, ratio<1, 1000000000> > nanoseconds; ///< Duration with the unit nanoseconds.

typedef duration<__intmax_t, ratio<1, 1000000> > microseconds; ///< Duration with the unit microseconds.

typedef duration<__intmax_t, ratio<1, 1000> > milliseconds; ///< Duration with the unit milliseconds.

typedef duration<__intmax_t> seconds; ///< Duration with the unit seconds.

typedef duration<__intmax_t, ratio<60> > minutes; ///< Duration with the unit minutes.

typedef duration<__intmax_t, ratio<3600> > hours; ///< Duration with the unit hours.

}

namespace this_thread {

/// Return the thread ID of the calling thread.

thread::id get_id();

/// Yield execution to another thread.

/// Offers the operating system the opportunity to schedule another thread

/// that is ready to run on the current processor.

inline void yield()

}

/// Blocks the calling thread for a period of time.

/// @param[in] aTime Minimum time to put the thread to sleep.

/// Example usage:

/// @code

/// // Sleep for 100 milliseconds

/// this_thread::sleep_for(chrono::milliseconds(100));

/// @endcode

/// @note Supported duration types are: nanoseconds, microseconds,

/// milliseconds, seconds, minutes and hours.

template <class _Rep, class _Period> void sleep_for(const chrono::duration<_Rep, _Period>& aTime)

}

}

}

#undef _TTHREAD_DISABLE_ASSIGNMENT

#include <exception>

#if defined(_TTHREAD_POSIX_)

#include <unistd.h>

#include <map>

#elif defined(_TTHREAD_WIN32_)

#include <process.h>

#endif

namespace tthread {

#if defined(_TTHREAD_WIN32_)

#define _CONDITION_EVENT_ONE 0

#define _CONDITION_EVENT_ALL 1

#endif

#if defined(_TTHREAD_WIN32_)

inline condition_variable::condition_variable() : mWaitersCount(0)

}

#endif

#if defined(_TTHREAD_WIN32_)

inline condition_variable::~condition_variable()

{

CloseHandle(mEvents[_CONDITION_EVENT_ONE]);

CloseHandle(mEvents[_CONDITION_EVENT_ALL]);

DeleteCriticalSection(&mWaitersCountLock);

}

#endif

#if defined(_TTHREAD_WIN32_)

inline void condition_variable::_wait()

}

#endif

#if defined(_TTHREAD_WIN32_)

inline void condition_variable::notify_one()

}

#endif

#if defined(_TTHREAD_WIN32_)

inline void condition_variable::notify_all()

}

#endif

#if defined(_TTHREAD_POSIX_)

inline static thread::id _pthread_t_to_ID(const pthread_t &aHandle)

}

#endif // _TTHREAD_POSIX_

struct _thread_start_info {

};

#if defined(_TTHREAD_WIN32_)

inline unsigned WINAPI thread::wrapper_function(void * aArg)

#elif defined(_TTHREAD_POSIX_)

inline void * thread::wrapper_function(void * aArg)

#endif

{

// Get thread startup information

_thread_start_info * ti = (_thread_start_info *) aArg;

try

{

// Call the actual client thread function

ti->mFunction(ti->mArg);

}

catch(...)

{

// Uncaught exceptions will terminate the application (default behavior

// according to C++11)

std::terminate();

}

// The thread is no longer executing

lock_guard<mutex> guard(ti->mThread->mDataMutex);

ti->mThread->mNotAThread = true;

// The thread is responsible for freeing the startup information

delete ti;

return 0;

}

inline thread::thread(void (*aFunction)(void *), void * aArg)

}

inline thread::~thread()

{

if(joinable())

std::terminate();

}

inline void thread::join()

}

inline bool thread::joinable() const

}

inline void thread::detach()

}

inline thread::id thread::get_id() const

}

inline unsigned thread::hardware_concurrency()

}

inline thread::id this_thread::get_id()

}

}

#endif // _TINYTHREAD_H_