SyncObjects.h

Go to the documentation of this file.

/*  SyncObjects.h - synchronisation object wrappers
    Copyright (C) 2001-2004 Mark Weaver
    Written by Mark Weaver <mark@npsl.co.uk>

    Part of the Open-Win32 library.
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 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
    Library General Public License for more details.

    You should have received a copy of the GNU Library 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 OW32_SyncObjects_h
#define OW32_SyncObjects_h

#include <OW32/XHANDLE.h>

namespace OW32
{

class OW32_LIB_EXPORT CSyncObject
{
private:
    CSyncObject(const CSyncObject& );
    CSyncObject& operator=(const CSyncObject& );

protected:
    CSyncObject() {}
    virtual ~CSyncObject() = 0 {}

public:
    virtual BOOL Lock(DWORD dwTimeout = INFINITE) = 0;
    virtual void Unlock() = 0;
};

class OW32_LIB_EXPORT CSingleLock
{
private:
    CSyncObject& m_SyncObject;
    BOOL m_bLocked;

    CSingleLock(const CSingleLock& );
    CSingleLock operator=(const CSingleLock& );

public:
    CSingleLock(CSyncObject& Object) :
        m_SyncObject(Object)
    {
        m_bLocked = m_SyncObject.Lock();
    }

    ~CSingleLock()
    {
        if (m_bLocked)
            m_SyncObject.Unlock();
    }

    BOOL IsLocked() { return m_bLocked; }

    void Lock()
    {
        if (!m_bLocked) {
            m_bLocked = m_SyncObject.Lock();
        }
    }

    void Unlock()
    {
        if (m_bLocked) {
            m_SyncObject.Unlock();
            m_bLocked = FALSE;
        }
    }
};

class OW32_LIB_EXPORT CCriticalSection : 
    public CSyncObject
{
private:
    CRITICAL_SECTION m_cs;

    CCriticalSection(const CCriticalSection& );
    CCriticalSection& operator=(const CCriticalSection& );

public:
    CCriticalSection()
    {
        InitializeCriticalSection(&m_cs);
    }

    ~CCriticalSection()
    {
        DeleteCriticalSection(&m_cs);
    }

    BOOL Lock(DWORD dwTimeout=INFINITE)
    {
        dwTimeout; // unreferenced variable warning
        EnterCriticalSection(&m_cs);
        return TRUE;
    }

    void Unlock()
    {
        LeaveCriticalSection(&m_cs);
    }
};

class OW32_LIB_EXPORT CEvent : 
    public CSyncObject
{
private:
    XHANDLE m_hEvent;

    CEvent(const CEvent& );
    CEvent& operator= (const CEvent& );

public:
    CEvent(BOOL bManualReset = FALSE, BOOL bInitialState = FALSE, 
           LPCTSTR lpszName = NULL, LPSECURITY_ATTRIBUTES lpSecAttr = NULL)
    {
        m_hEvent = CreateEvent(lpSecAttr, bManualReset, bInitialState, lpszName);
    }

    CEvent(HANDLE hEvent) :
        m_hEvent(hEvent)
    {
    }

    CEvent& operator=(HANDLE hEvent)
    {
        m_hEvent = hEvent;
        return *this;
    }

    virtual BOOL Lock(DWORD dwTimeout=INFINITE)
    {
        return WaitForSingleObject(m_hEvent, dwTimeout)==WAIT_OBJECT_0;
    }
    void Unlock() {} // nothing to do

    BOOL Set() { return ::SetEvent(m_hEvent); }
    BOOL Reset() { return ::ResetEvent(m_hEvent); }
    BOOL Pulse() { return ::PulseEvent(m_hEvent); }

    operator HANDLE() const { return m_hEvent; }
};

class OW32_LIB_EXPORT CSemaphore : 
    public CSyncObject
{
    XHANDLE m_hSemaphore;

    CSemaphore(const CSemaphore& );
    CSemaphore& operator= (const CSemaphore& );

public:
    CSemaphore(LONG lMaximumCount, LONG lInitialCount = 0, 
               LPCTSTR lpszName = NULL, LPSECURITY_ATTRIBUTES lpSecAttr = NULL)
    {
        m_hSemaphore = CreateSemaphore(lpSecAttr, lInitialCount, lMaximumCount, lpszName);
    }

    CSemaphore(HANDLE hSemaphore) :
        m_hSemaphore(hSemaphore)
    {
    }

    CSemaphore& operator=(HANDLE hSemaphore)
    {
        m_hSemaphore = hSemaphore;
        return *this;
    }

    virtual BOOL Lock(DWORD dwTimeout = INFINITE)
    {
        return WaitForSingleObject(m_hSemaphore, dwTimeout)==WAIT_OBJECT_0;
    }

    void Unlock() {}

    BOOL Release(LONG lReleaseCount, LPLONG lPreviousCount=NULL) 
    { 
        return ReleaseSemaphore(m_hSemaphore, lReleaseCount, lPreviousCount);
    }

    operator HANDLE() const { return m_hSemaphore; }
};

class OW32_LIB_EXPORT CMutex : 
    public CSyncObject
{
    XHANDLE m_hMutex;

    CMutex(const CMutex& );
    CMutex& operator= (const CMutex& );

public:
    CMutex(BOOL bInitialOwner = FALSE, LPCTSTR lpszName = NULL,
           LPSECURITY_ATTRIBUTES lpSecAttr = NULL)
    {
        m_hMutex = CreateMutex(lpSecAttr, bInitialOwner, lpszName);
    }

    CMutex(HANDLE hMutex) :
        m_hMutex(hMutex)
    {
    }

    CMutex& operator=(HANDLE hMutex)
    {
        m_hMutex = hMutex;
        return *this;
    }

    virtual BOOL Lock(DWORD dwTimeout = INFINITE)
    {
        return WaitForSingleObject(m_hMutex, dwTimeout)==WAIT_OBJECT_0;
    }

    void Unlock() 
    {
        ReleaseMutex(m_hMutex);
    }

    operator HANDLE() const { return m_hMutex; }
};

#if _WIN32_WINNT >= 0x400

class OW32_LIB_EXPORT CWaitableTimer : 
    public CSyncObject
{
    XHANDLE m_hTimer;

    CWaitableTimer(const CWaitableTimer& );
    CWaitableTimer& operator= (const CWaitableTimer& );

public:
    CWaitableTimer(BOOL bManualReset = FALSE, LPCTSTR lpszName = NULL,
                   LPSECURITY_ATTRIBUTES lpSecAttr = NULL)
    {
        m_hTimer = CreateWaitableTimer(lpSecAttr, bManualReset, lpszName);
    }

    BOOL Set(const LARGE_INTEGER* pDueTime, long Period = 0, 
             PTIMERAPCROUTINE pfnCompletionRoutine = NULL, LPVOID lpArgToCompletionRoutine = NULL,
             BOOL fResume = FALSE)
    {
        return ::SetWaitableTimer(m_hTimer, pDueTime, Period, pfnCompletionRoutine,
                                  lpArgToCompletionRoutine, fResume);
    }

    BOOL Set(__int64 DueTime, long Period = 0, 
             PTIMERAPCROUTINE pfnCompletionRoutine = NULL, LPVOID lpArgToCompletionRoutine = NULL,
             BOOL fResume = FALSE)
    {
        LARGE_INTEGER li;
        li.QuadPart = DueTime;
        return ::SetWaitableTimer(m_hTimer, &li, Period, pfnCompletionRoutine,
                                  lpArgToCompletionRoutine, fResume);
    }

    BOOL Cancel()
    {
        return ::CancelWaitableTimer(m_hTimer);
    }

    virtual BOOL Lock(DWORD dwTimeout = INFINITE)
    {
        return WaitForSingleObject(m_hTimer, dwTimeout)==WAIT_OBJECT_0;
    }

    void Unlock() {}

    operator HANDLE() { return m_hTimer; }
};

#endif

} // namespace OW32

#endif // OW32_SyncObjects_h

---