thread.h

/*****************************************************/
/* lean Concurrent              (c) Tobias Zirr 2011 */
/*****************************************************/

#ifndef LEAN_CONCURRENT_THREAD
#define LEAN_CONCURRENT_THREAD

#include "../lean.h"
#include "../tags/noncopyable.h"
#include <process.h>
#include <windows.h>
#include <lean/logging/win_errors.h>

namespace lean
{
namespace concurrent
{

class thread : public noncopyable
{
private:
    HANDLE m_handle;

    template <class Callable>
    static unsigned int _stdcall run_thread(void *args)
    {
        unsigned int result = 0;

        Callable *callable = static_cast<Callable*>(args);
        LEAN_ASSERT_NOT_NULL(callable);

        try
        {
            try
            {
                (*callable)();
            }
            catch (const std::exception &exc)
            {
                LEAN_LOG_ERROR_CTX("Unhandled exception during execution of thread", exc.what());
                result = static_cast<unsigned int>(-1);
            }
            catch (...)
            {
                LEAN_LOG_ERROR_MSG("Unhandled exception during execution of thread");
                result = static_cast<unsigned int>(-1);
            }

            delete callable;
        }
        catch (...)
        {
            result = static_cast<unsigned int>(-2);
        }

        return result;
    }

    template <class Callable>
    static HANDLE run_thread(Callable *callable)
    {
        LEAN_ASSERT_NOT_NULL(callable);

        HANDLE handle = reinterpret_cast<HANDLE>(
                ::_beginthreadex(nullptr, 0, &run_thread<Callable>, callable, 0, nullptr)
            );

        if (handle == NULL)
        {
            delete callable;
            LEAN_THROW_WIN_ERROR_MSG("_beginthreadex() failed");
        }

        return handle;
    }

public:
    thread()
        : m_handle(NULL) { }
    template <class Callable>
    thread(const Callable &callable)
        : m_handle( run_thread( new Callable(callable) ) ) { }
#ifndef LEAN0X_NO_RVALUE_REFERENCES

    template <class Callable>
    thread(Callable &&callable)
        : m_handle( run_thread( new Callable(std::move(callable)) ) ) { }
    thread(thread &&right)
        : m_handle(right.m_handle)
    {
        right.m_handle = NULL;
    }
#endif

    ~thread()
    {
        if (m_handle != NULL)
            ::CloseHandle(m_handle);
    }

#ifndef LEAN0X_NO_RVALUE_REFERENCES

    thread& operator =(thread &&right)
    {
        if (m_handle != right.m_handle)
        {
            detach();
            m_handle = right.m_handle;
            right.m_handle = NULL;
        }
        return *this;
    }
#endif

    void detach()
    {
        if (m_handle != NULL)
        {
            ::CloseHandle(m_handle);
            m_handle = NULL;
        }
    }

    LEAN_INLINE bool joinable() const
    {
        return (m_handle != NULL);
    }
    void join()
    {
        if (m_handle != NULL)
            if (::WaitForSingleObject(m_handle, INFINITE) == WAIT_FAILED)
                LEAN_THROW_WIN_ERROR_MSG("WaitForSingleObject()");
    }

    LEAN_INLINE HANDLE native_handle() const
    {
        return m_handle;
    }
};

} // namespace

using concurrent::thread;

} // namespace

#endif