CWin32ReadWriteLock Class Reference

#include <Win32ReadWriteLock.h>

Inheritance diagram for CWin32ReadWriteLock:

[legend]

Collaboration diagram for CWin32ReadWriteLock:

[legend]

List of all members.

Public Member Functions
virtual BOOL	LockRead (unsigned long ulMSTimeout=INFINITE)
virtual void	UnlockRead ()
virtual BOOL	LockWrite ()
virtual void	UnlockWrite ()
virtual BOOL	Escalate (unsigned long ulMSTimeout, unsigned long ulIterations)
virtual void	StopEscalation ()
	CWin32ReadWriteLock (int iMaximumReaders)
virtual	~CWin32ReadWriteLock ()
Protected Member Functions
int	GetMaximumReaders () const

---

Detailed Description

Definition at line 50 of file Win32ReadWriteLock.h.

---

Constructor & Destructor Documentation

KOMODIA_NAMESPACE_START CWin32ReadWriteLock::CWin32ReadWriteLock

(

int

iMaximumReaders

)

Definition at line 51 of file Win32ReadWriteLock.cpp.

                                                            : CGenericReadWriteLock(iMaximumReaders),
                                                                m_pSemaphore(NULL),
                                                                m_pMutex(NULL),
                                                                m_bWriter(FALSE),
                                                                m_bEscalation(FALSE),
                                                                m_iReaders(0)
{
    //Allocate the mutex and the semaphores
    m_pMutex=COSManager::CreateMutex();
    m_pSemaphore=COSManager::CreateSemaphore(iMaximumReaders,iMaximumReaders);
}

CWin32ReadWriteLock::~CWin32ReadWriteLock

(

)

[virtual]

Definition at line 63 of file Win32ReadWriteLock.cpp.

{
    //Delete the mutexs and semaphores
    delete m_pMutex;
    delete m_pSemaphore;
}

---

Member Function Documentation

BOOL CWin32ReadWriteLock::Escalate	(	unsigned long	ulMSTimeout,
		unsigned long	ulIterations
	)			[virtual]

Implements CGenericReadWriteLock.

Definition at line 168 of file Win32ReadWriteLock.cpp.

{
    //Try to lock for write
    if (LockWrite())
        return TRUE;

    //Try to escalate 
    CMutexAutoRelease aRelease(m_pMutex,TRUE);

    //Change the escalation status
    m_bEscalation=TRUE;

    //Exit from the mutex
    aRelease.Release();

    //And wait to see if we can continue
    for (unsigned long ulCounter=0;ulCounter<ulIterations;++ulCounter)
    {
        //Can we write
        if (LockWrite())
            return TRUE;

        //Wait
        Sleep(ulMSTimeout);
    }

    //Failed to escalate
    return FALSE;
}

int CGenericReadWriteLock::GetMaximumReaders

(

)

const [protected, inherited]

Definition at line 55 of file GenericReadWriteLock.cpp.

{
    return m_iMaximumReaders;
}

BOOL CWin32ReadWriteLock::LockRead

(

unsigned long

ulMSTimeout = INFINITE

)

[virtual]

Implements CGenericReadWriteLock.

Definition at line 70 of file Win32ReadWriteLock.cpp.

{
    //First lock the mutex and check the read flag
    CMutexAutoRelease aRelease(m_pMutex,TRUE);

    //Check the flag
    if (m_bEscalation || m_bWriter)
        //Can't lock
        return FALSE;

    //Check if we will be locked ?
    if (m_iReaders==GetMaximumReaders())
    {
        //Release the lock and try to get it
        aRelease.Release();

        //Lock the semaphore
        if (m_pSemaphore->Aquire(ulMSTimeout))
            return FALSE;
        else
        {
            //Relock it
            aRelease.Aquire();

            //Check if there are writers ?
            if (m_bEscalation || m_bWriter)
            {
                //So soon ?
                //Release what we got
                m_pSemaphore->Release();

                //Exit
                return FALSE;
            }
            else
                //Increase the count
                ++m_iReaders;
        }
    }
    else if (m_pSemaphore->Aquire(ulMSTimeout))
        return FALSE;
    else
        //Increase the semaphore and our count
        ++m_iReaders;

    //Done
    return TRUE;
}

BOOL CWin32ReadWriteLock::LockWrite

(

)

[virtual]

Implements CGenericReadWriteLock.

Definition at line 135 of file Win32ReadWriteLock.cpp.

{
    //First lock the mutex and check the read flag
    CMutexAutoRelease aRelease(m_pMutex,TRUE);

    //Check the flag
    if (m_iReaders || m_bWriter)
        //Can't lock
        return FALSE;

    //Indicate we are writing
    m_bWriter=TRUE;

    //Done
    return TRUE;
}

void CWin32ReadWriteLock::StopEscalation

(

)

[virtual]

Implements CGenericReadWriteLock.

Definition at line 199 of file Win32ReadWriteLock.cpp.

{
    //First lock the mutex and check the read flag
    CMutexAutoRelease aRelease(m_pMutex,TRUE);

    //Remove escalation flag
    m_bEscalation=FALSE;
}

void CWin32ReadWriteLock::UnlockRead

(

)

[virtual]

Implements CGenericReadWriteLock.

Definition at line 119 of file Win32ReadWriteLock.cpp.

{
    //First lock the mutex and check the read flag
    CMutexAutoRelease aRelease(m_pMutex,TRUE);

    //Do we have readers
    if (m_iReaders)
    {
        //Release the semaphore
        m_pSemaphore->Release();

        //Decrease the count
        --m_iReaders;
    }
}

void CWin32ReadWriteLock::UnlockWrite

(

)

[virtual]

Implements CGenericReadWriteLock.

Definition at line 152 of file Win32ReadWriteLock.cpp.

{
    //First lock the mutex and check the read flag
    CMutexAutoRelease aRelease(m_pMutex,TRUE);

    //Do we have readers
    if (m_bWriter)
    {
        //Not writing
        m_bWriter=FALSE;

        //Remove escalation flag
        m_bEscalation=FALSE;
    }
}

---

The documentation for this class was generated from the following files:

• Win32ReadWriteLock.h
• Win32ReadWriteLock.cpp