UThread.h

Go to the documentation of this file.

//    Copyright (C) 2006-2015 Dylan Blair
//
//    email: dblair@alumni.cs.utexas.edu
//
//    This library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, 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
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with this library; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

#ifndef UCRITICAL_SECTION_H
#define UCRITICAL_SECTION_H

#ifdef _WIN32
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#include <windows.h>
#else
#include <pthread.h>
#include <semaphore.h>
#endif

#include <assert.h>

namespace OpenSkyNet {
    namespace Utils {
        class LockableCS {
        public:
#ifdef _WIN32

            inline LockableCS() throw() { InitializeCriticalSection(&_cS); }
            inline ~LockableCS() throw() { DeleteCriticalSection(&_cS); }

            inline void lock() throw() { EnterCriticalSection(&_cS); }
            inline void unlock() throw() { LeaveCriticalSection(&_cS); }
#else

            inline LockableCS() throw() {
                pthread_mutexattr_t mutexAttr;
                pthread_mutexattr_settype(&mutexAttr,PTHREAD_MUTEX_RECURSIVE_NP);
                pthread_mutex_init(&_cS,&mutexAttr);
                pthread_mutexattr_destroy(&mutexAttr);
            }
            inline ~LockableCS() throw() { pthread_mutex_destroy(&_cS); }

            inline void lock() throw() { pthread_mutex_lock(&_cS); }
            inline void unlock() throw() { pthread_mutex_unlock(&_cS); }
#endif
        private:
#ifdef _WIN32
            CRITICAL_SECTION _cS;
#else
            pthread_mutex_t _cS;
#endif
        };

        class SyncEvent {
        public:
#ifdef _WIN32
            inline SyncEvent() throw() { _event = CreateEvent(NULL,FALSE,FALSE,NULL); }
            inline ~SyncEvent() throw() { CloseHandle(_event); }

            inline void set() throw() { SetEvent(_event); }
            inline void wait() throw() { WaitForSingleObject(_event,INFINITE); }
#else

            inline SyncEvent() throw() {
                int error = sem_init(&_event,0,0);
                assert(!error);
            }
            inline ~SyncEvent() throw() {
                int error = sem_destroy(&_event);
                assert(!error);
            }

            inline void set() throw() {
                int val = 0;
                int error = sem_getvalue(&_event,&val);
                assert(!error);
                if (!val) {
                    error = sem_post(&_event);
                    assert(!error);
                }
            }
            inline void wait() throw() {
                int error = sem_wait(&_event);
                assert(!error);
            }
#endif
        private:
#ifdef _WIN32
            HANDLE _event;
#else
            sem_t _event;
#endif
        };

        class Thread {
        public:
#ifdef _WIN32
            Thread() : _hThread(0) {}

            void create(LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter) {
                DWORD dwThreadId;
                _hThread = CreateThread(
                    NULL,              // default security attributes
                    0,                 // use default stack size
                    lpStartAddress,    // thread function
                    lpParameter,       // argument to thread function
                    0,                 // use default creation flags
                    &dwThreadId);      // returns the thread identifier
            }

            void wait() {
                if (_hThread)
                    WaitForSingleObject(_hThread, INFINITE);
            }

            void close() {
                if (_hThread)
                    if (CloseHandle(_hThread))
                        _hThread = 0;
            }
#else
            Thread() : _thread(0) {}

            void create(void* (*start_address)(void*), void* arg) {
                // initialize the thread attribute
                pthread_attr_init(&_threadAttr);
                // set the stack size of the thread
                pthread_attr_setstacksize(&_threadAttr, 1048576);
                // create the thread
                pthread_create(&_thread, &_threadAttr, start_address, arg);
            }

            void wait() {
                if (_thread)
                    pthread_join(_thread, NULL);
            }

            void close() {
                if (_thread)
                    if (!pthread_attr_destroy(&_threadAttr))
                        _thread = 0;
            }
#endif
        private:
#ifdef _WIN32
            HANDLE _hThread;
#else
            pthread_t _thread;
            pthread_attr_t _threadAttr;
#endif
        };
    }
}

#endif //UCRITICAL_SECTION_H