cSysEvent.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cSysEvent_H
#define _INC_cSysEvent_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../GrayLibBase.h"
#include "GrayCore/include/cThreadLock.h"
#include "GrayCore/include/cOSHandle.h"
 
#ifdef __linux__
// from sample http://www.llnl.gov/computing/tutorials/pthreads/#Routines
#include <pthread.h>    // mutex
#include <errno.h>
struct _SECURITY_ATTRIBUTES;
#endif // __linux__
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cSysEvent);
 
        class GRAYLIB_LINK cSysEvent
        {
 
        private:
#ifdef _WIN32
                cOSHandle m_h;
#else   // __linux__
                static const ::pthread_mutex_t k_mutexInit;
                static const ::pthread_cond_t k_condInit;
                ::pthread_mutex_t m_mutex;      
                ::pthread_cond_t m_cond;                
                bool m_bManualReset;            
                bool m_bSignaled;                       
#endif
 
        public:
                cSysEvent() noexcept
                {
#ifdef __linux__
                        m_mutex = k_mutexInit;
                        m_cond = k_condInit;
                        m_bManualReset = false;
                        m_bSignaled = false;
#endif
                }
                ~cSysEvent()
                {
#ifdef __linux__
                        if (isValidEvent())
                        {
                                ::pthread_cond_destroy(&m_cond);
                                ::pthread_mutex_destroy(&m_mutex);
                        }
#endif
                }
 
#ifdef _WIN32
                HANDLE get_EventHandle() const noexcept
                {
                        return m_h;
                }
#elif defined(__linux__)
                ::pthread_cond_t get_CondHandle() const noexcept
                {
                        return m_cond;
                }
#else
#error NOOS
#endif
 
                bool isValidEvent() const noexcept
                {
#ifdef _WIN32
                        return m_h.isValidHandle();
#else // __linux__
                        return true; // use m_cond ??? or ( m_mutex.__size[0] != 0 )
#endif
                }
 
                bool CreateEventX(_SECURITY_ATTRIBUTES* lpEventAttributes = nullptr,
                        bool bManualReset = false,      // true = requires use of the ResetEvent function set the state to nonsignaled. eles auto cleared.
                        bool bInitialState = false,     // false = wait.
                        const FILECHAR_t* lpName = nullptr)
                {
                        // Cant use the name "CreateEvent" since it is #defined.
 
                        ASSERT(!isValidEvent());
#ifdef _WIN32
                        m_h.AttachHandle(_FNF(::CreateEvent)(lpEventAttributes, bManualReset, bInitialState, lpName));
#else // __linux__
                        m_mutex = k_mutexInit;  // NOT recursive!
                        if (::pthread_cond_init(&m_cond, nullptr) != 0)
                        {
                                return false;
                        }
                        m_bManualReset = bManualReset;  // must track this manually.
                        m_bSignaled = bInitialState;
#endif
                        return isValidEvent();
                }
 
#if 0
                bool OpenEvent(const FILECHAR_t* lpName)
                {
                        m_h.AttachHandle(_FNF(::OpenEvent)(sdf, false, lpName));
                        return isValidEvent() ;
                }
#endif
 
                bool SetEvent()
                {
                        ASSERT(isValidEvent());
#ifdef _WIN32
                        return(::SetEvent(m_h) != false);
#else // __linux__
                        ::pthread_mutex_lock(&m_mutex);
                        m_bSignaled = m_bManualReset;   // only needed to be set if m_bManualReset
                        int iRet = ::pthread_cond_broadcast(&m_cond);   // like pthread_cond_signal()
                        ::pthread_mutex_unlock(&m_mutex);
                        return iRet == 0 ;
#endif
                }
                bool ResetEvent()
                {
                        ASSERT(isValidEvent());
#ifdef _WIN32
                        return(::ResetEvent(m_h) != false);
#else   // __linux__
                        m_bSignaled = false;
                        return true;
#endif
                }
                bool PulseEvent()
                {
                        ASSERT(isValidEvent());
#ifdef _WIN32
                        return ::PulseEvent(m_h) != false ;
#else   // __linux__
                        bool bManualResetOld = m_bManualReset;
                        m_bManualReset = false;
                        SetEvent();
                        m_bManualReset = bManualResetOld;
                        return true;
#endif
                }
 
                HRESULT WaitForSingleObject(TIMESYSD_t dwMilliseconds);
 
                UNITTEST2_PREDEF(cSysEvent);
        };
} 
#endif // _INC_cSysEvent_H