/cygdrive/d/src/svn/vrut/trunk/core/src/rwlock.h

Go to the documentation of this file.

/*
 * $Id: rwlock.h 409 2008-10-20 19:01:03Z kybav1 $
 *
 * Description  : One line description of file.
 * Author       : Vaclav Kyba <mail/Jabber: vaseo1@gmail.com>  <ICQ: 98576293>
 * 
 * Purpose      :
 *     Long description of what the file is for.
 */


#ifndef __RW_LOCK__H__
#define __RW_LOCK__H__

#include <wx/thread.h>
#include <list>
#include "flexilog.h"

namespace VRUT
{
       class ReadWriteMutex
       {
       public:
              static const unsigned MAX_READERS = 32;

              ReadWriteMutex() : semaphore(MAX_READERS, MAX_READERS)
              {
                     writer.recursiveLocks = 0;
                     writer.threadID = 0;
              }
                       
       private:
              struct LockOwner
              {
                     wxThreadIdType threadID;
                     unsigned recursiveLocks;
              };
              typedef std::list<LockOwner> LockOwnerList;

              mutable wxMutex mutex;
              wxMutex semMutex;
              mutable wxSemaphore semaphore;
              mutable LockOwnerList readers;
              LockOwner writer;

              LockOwnerList::iterator getCurrentReader() const
              {
                     wxThreadIdType threadID = wxThread::GetCurrentId();
                     for (LockOwnerList::iterator it = readers.begin(); it != readers.end(); it++)
                            if (it->threadID == threadID)
                                   return it;
                     return readers.end();
              }
       
       public:
              bool IsOk() const
              {
                     return mutex.IsOk() && semMutex.IsOk();
              }

              void ReadLock() const
              {
                     mutex.Lock();
                     wxThreadIdType threadID = wxThread::GetCurrentId();
                     LockOwnerList::iterator ourReader = getCurrentReader();
                     if (ourReader != readers.end())
                            ourReader->recursiveLocks++;
                     else
                     {
                            LockOwner lo = { threadID, 1 };
                            readers.push_back(lo);
                            if (writer.recursiveLocks == 0 || writer.threadID != threadID)
                            {
                                   mutex.Unlock();
                                   semaphore.Wait();
                                   return;
                            }
                     }
                     mutex.Unlock();
              }
              
              void ReadUnlock() const
              {
                     wxMutexLocker lock(mutex);
                     LockOwnerList::iterator ourReader = getCurrentReader();
                     if (ourReader != readers.end())
                     {
                            if (--ourReader->recursiveLocks == 0)
                            {
                                   readers.erase(ourReader);
                                   semaphore.Post();
                            }
                     }
                     else
                            LOGERROR(wxT("<ReadWriteMutex>Read unlock called with no matching previous read lock"));
              }
              
              void WriteLock()
              {
                     mutex.Lock();
                     
                     wxThreadIdType threadID = wxThread::GetCurrentId();
                     if (writer.recursiveLocks && writer.threadID == threadID)
                            writer.recursiveLocks++;
                     else
                     {
                            mutex.Unlock();
                            wxMutexLocker semLock(semMutex);
                            for (unsigned i = 0; i < MAX_READERS; i++)
                                   semaphore.Wait();
                            mutex.Lock();
                            wxASSERT_MSG(writer.threadID == 0, wxT("<ReadWriteMutex>Write lock was not unlocked properly"));
                            writer.threadID = threadID;
                            writer.recursiveLocks = 1;
                     }
                     mutex.Unlock();
              }
              
              void WriteUnlock()
              {
                     wxMutexLocker lock(mutex);
                     wxThreadIdType threadID = wxThread::GetCurrentId();
                     wxASSERT_MSG(writer.threadID == threadID, wxT("<ReadWriteMutex>Unlocking write lock locked by different thread"));
                     if (--writer.recursiveLocks == 0)
                     {
                            for (unsigned i = 0; i < MAX_READERS; i++)
                                   semaphore.Post();
                            writer.threadID = 0;
                     }
              }
       };


       class ReadLocker
       {
       public:
              ReadLocker(const ReadWriteMutex & rwLock) : m_rwLock(rwLock)
              {
                     m_rwLock.ReadLock();
              }

              ~ReadLocker()
              {
                     m_rwLock.ReadUnlock();
              }
       
       private:
              const ReadWriteMutex & m_rwLock;
       };
       

       class WriteLocker
       {
       public:
              WriteLocker(ReadWriteMutex& rwLock) : m_rwLock(rwLock)
              {
                     m_rwLock.WriteLock();
              }
              
              ~WriteLocker()
              {
                     m_rwLock.WriteUnlock();
              }
       
       private:
              ReadWriteMutex& m_rwLock;
       };
};

#endif

---