cSemaphore.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cSemaphore_H
#define _INC_cSemaphore_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../GrayLibBase.h"
#include "GrayCore/include/cTimeSys.h"
#include "GrayCore/include/FileName.h"
#ifdef _WIN32
#include "GrayCore/include/cOSHandle.h"
#elif defined(__linux__)
#include <semaphore.h>
#else
#error NOOS
#endif
 
namespace GrayLib
{
        class GRAYLIB_LINK cSemaphore
        {
        public:
#ifdef _WIN32
                cOSHandle m_sem;        // OpenSemaphore
#else
                sem_t m_sem;    
                sem_t* m_pSem;  
#endif
        public:
                cSemaphore(int iUnlockedCount, int iMaxCount, const FILECHAR_t* pszName = nullptr)
                {
#ifdef _WIN32
                        m_sem.AttachHandle(_FNF(::CreateSemaphore)(nullptr, iUnlockedCount, iMaxCount, pszName));
#else
                        if (pszName != nullptr)
                        {
                                m_pSem = ::sem_open(pszName, 0);        // flags
                        }
                        else
                        {
                                ::sem_init(&m_sem, iUnlockedCount, iMaxCount);
                                m_pSem = &m_sem;
                        }
#endif
                }
#ifdef _WIN32
                cSemaphore()
                {
                }
#endif
#if defined(_WIN32) && ! defined(UNDER_CE)
                cSemaphore(DWORD dwDesiredAccess, bool bInheritHandle, const FILECHAR_t* pszName)
                {
                        OpenSemaphore(dwDesiredAccess, bInheritHandle, pszName);
                }
#endif
 
                ~cSemaphore()
                {
#ifdef __linux__
                        ::sem_close(m_pSem);    // sem_destroy()
#endif
                }
                bool isValidSemaphore() const
                {
#ifdef _WIN32
                        return m_sem.isValidHandle();
#else
                        return m_pSem != nullptr;
#endif
                }
#if defined(_WIN32) && ! defined(UNDER_CE)
                void OpenSemaphore(DWORD dwDesiredAccess, bool bInheritHandle, const FILECHAR_t* pszName)
                {
                        m_sem.AttachHandle(_FNF(::OpenSemaphore)(dwDesiredAccess, bInheritHandle, pszName));
                }
#endif
                bool LockWait(TIMESYSD_t tWait = cTimeSys::k_INF)
                {
#ifdef _WIN32
                        DWORD dwRet = ::WaitForSingleObject(m_sem, tWait);
                        HRESULT hRes = HResult::FromWaitRet(dwRet);
                        return SUCCEEDED(hRes);
#else
                        cTimeSpec tWaitSpec(tWait);
                        int iRet = ::sem_timedwait(m_pSem, &tWaitSpec); // errno = ETIMEDOUT
                        return (iRet == 0);
#endif
                }
                bool Unlock(LONG nReleaseCount = 1, LONG* plPreviousCount = nullptr)
                {
#ifdef _WIN32
                        return ::ReleaseSemaphore(m_sem, nReleaseCount, plPreviousCount);
#else
                        ::sem_post(m_pSem);
                        return false;
#endif
                }
        };
 
        class GRAYLIB_LINK cSemaphoreLock // : public cLockerT<>
        {
        private:
                cSemaphore& m_Sem;
                bool m_bLocked;         
 
        public:
                cSemaphoreLock(cSemaphore& Sem)
                : m_Sem(Sem)
                , m_bLocked(false)
                {
                }
                cSemaphoreLock(cSemaphore& Sem, TIMESYSD_t tWait)
                : m_Sem(Sem)
                , m_bLocked(false)
                {
                        LockWait(tWait);
                }
                ~cSemaphoreLock()
                {
                        if (m_bLocked)
                        {
                                m_Sem.Unlock(1);
                        }
                }
                bool isLocked() const
                {
                        return m_bLocked;
                }
                bool LockWait(TIMESYSD_t tWait = cTimeSys::k_INF)
                {
                        if (m_bLocked)
                                return true;
                        m_bLocked = m_Sem.LockWait(tWait);
                        return m_bLocked;
                }
        };
};
#endif