---

threadsPAL.hpp

Go to the documentation of this file.

#ifndef __THREADS_WIN32_PAL_HPP__
#define __THREADS_WIN32_PAL_HPP__

#include <limits.h>
//#include <winbase.h>
#include <windows.h>
#include <assert.h>


namespace lfc
{
namespace win32PAL
{


namespace threads
{

const int MAX_ERROR_CODE = 1;

enum ErrorCodes
{
    errOk,
    errGeneric,
};

extern const char *messagesTable[MAX_ERROR_CODE + 1];


DWORD WINAPI __threadProc(void *);

struct __StartThreadInfo
{
    void (*proc)(void *);
    void *pData;
};


typedef ::HANDLE ThreadHandle;
const ThreadHandle NULL_THREAD_HANDLE = NULL;

typedef ::HANDLE MutexHandle;
const MutexHandle NULL_MUTEX_HANDLE = NULL;

typedef ::HANDLE SemHandle;
const SemHandle NULL_SEM_HANDLE = NULL;

typedef DWORD TLSKey;


const int
    priorityMin     = THREAD_PRIORITY_LOWEST,
    priorityNormal  = THREAD_PRIORITY_NORMAL,
    priorityMax     = THREAD_PRIORITY_HIGHEST;



inline int init()
{
    return errOk;
}



inline int cleanup()
{
    return errOk;
}



inline int createThread(ThreadHandle &handle, void (*proc)(void *), void *pData)
{
    DWORD threadId;

    __StartThreadInfo *pInfo = new __StartThreadInfo;
    pInfo->proc = proc;
    pInfo->pData = pData;

    ThreadHandle h = ::CreateThread(NULL, 0, &__threadProc, pInfo, 0,
        &threadId);
    if(h != NULL)
    {
        handle = h;
        return errOk;
    }
    else
        return errGeneric;
}



inline int closeThread(ThreadHandle &handle)
{
    return ::CloseHandle(handle) ? errOk : errGeneric;
}



inline int getCurrentThread(ThreadHandle &handle)
{
    ThreadHandle pseudoHandle = ::GetCurrentThread();
    ThreadHandle h;

    if(::DuplicateHandle(::GetCurrentProcess(), pseudoHandle,
        ::GetCurrentProcess(), &h, 0, false, DUPLICATE_SAME_ACCESS))
    {
        handle = h;
        return errOk;
    }
    else
        return errGeneric;
}



inline int destroyThread(const ThreadHandle &handle)
{
    return ::TerminateThread(handle, 0) ? errOk : errGeneric;
}



inline int joinThread(const ThreadHandle &handle)
{
    if(::WaitForSingleObject(handle, INFINITE) != WAIT_FAILED)
        return errOk;
    else
        return errGeneric;
}



inline int setThreadPriority(const ThreadHandle &handle, int priority)
{
    return ::SetThreadPriority(handle, priority) ? errOk : errGeneric;
}



inline int yield()
{
    ::Sleep(0);
    return errOk;
}



inline int sleep(long miliseconds)
{
    ::Sleep(miliseconds);
    return errOk;
}



inline int allocTLS(TLSKey &key)
{
    TLSKey k = ::TlsAlloc();
    if(k != 0xFFFFFFFF)
    {
        key = k;
        return errOk;
    }
    else
        return errGeneric;
}



inline int freeTLS(TLSKey key)
{
    return ::TlsFree(key) ? errOk : errGeneric;
}



inline int setTLS(TLSKey key, void *value)
{
    return ::TlsSetValue(key, value) ? errOk : errGeneric;
}



inline int getTLS(TLSKey key, void *&value)
{
    void *v = ::TlsGetValue(key);
    if(::GetLastError() == NO_ERROR)
    {
        value = v;
        return errOk;
    }
    else
        return errGeneric;
}



inline int createMutex(MutexHandle &handle)
{
    MutexHandle h = ::CreateMutex(NULL, false, NULL);
    if(h != NULL)
    {
        handle = h;
        return errOk;
    }
    else
        return errGeneric;
}



inline int closeMutex(MutexHandle &handle)
{
    return ::CloseHandle(handle) ? errOk : errGeneric;
}



inline int lockMutex(MutexHandle &handle)
{
    if( ::WaitForSingleObject(handle, INFINITE) != WAIT_FAILED)
        return errOk;
    else
        return errGeneric;
}


inline int tryLockMutex(MutexHandle &handle, bool &bLocked)
{
    DWORD retCode = ::WaitForSingleObject(handle, 0);

    if(retCode != WAIT_FAILED)
    {
        bLocked = (retCode != WAIT_TIMEOUT);
        return errOk;
    }
    else
        return errGeneric;
}


inline int unlockMutex(MutexHandle &handle)
{
    return ::ReleaseMutex(handle) ? errOk : errGeneric;
}



inline int createSemaphore(SemHandle &handle, long count)
{
    SemHandle h = ::CreateSemaphore(NULL, count, LONG_MAX, NULL);
    if(h != NULL)
    {
        handle = h;
        return errOk;
    }
    else
        return errGeneric;
}



inline int closeSemaphore(SemHandle &handle)
{
    return ::CloseHandle(handle) ? errOk : errGeneric;
}



inline int waitSemaphore(SemHandle &handle)
{
    DWORD retCode = ::WaitForSingleObject(handle, INFINITE);

    if(retCode != WAIT_FAILED)
        return errOk;
    else
        return errGeneric;
}


inline int tryWaitSemaphore(SemHandle &handle, bool &bLocked)
{
    DWORD retCode = ::WaitForSingleObject(handle, 0 );

    if(retCode != WAIT_FAILED)
    {
        bLocked = (retCode != WAIT_TIMEOUT);
        return errOk;
    }
    else
        return errGeneric;
}


inline int postSemaphore(SemHandle &handle)
{
    return ::ReleaseSemaphore(handle, 1, NULL) ? errOk : errGeneric;
}



inline const char *message(int index)
{
    assert(index >= 0 && index <= MAX_ERROR_CODE);
    return messagesTable[index];
}


} // namespace win32PAL::threads
} // namespace win32PAL

namespace pal = win32PAL;

} // namespace lfc


#endif  // __THREADS_WIN32_PAL_HPP__

---