cel_rwlock.h

Go to the documentation of this file.

//----------------------------------------------------------------------------
//
// (C) 2003-2006 Celartem Technology Inc. All rights reserved.
//----------------------------------------------------------------------------

#ifndef _cel_rwlock_h_
#define _cel_rwlock_h_

#include "cel_types.h"

namespace Celartem
{
    //------------------------------------------------------------------------
    class _rwlock_
    {
    public:
        static _rwlock_ *create();
        virtual ~_rwlock_() {}

        virtual void lockForRead() = 0;
        virtual void lockForWrite() = 0;
        virtual void unlock() = 0;
    };

    //------------------------------------------------------------------------
    class ReaderWriterLock
    {
    public:
        ReaderWriterLock()
            : m_rwlock(_rwlock_::create())
        {
        }

        ~ReaderWriterLock()
        {
            delete m_rwlock;
        }

        inline void lockForRead()
        {
            m_rwlock->lockForRead();
        }

        inline void lockForWrite()
        {
            m_rwlock->lockForWrite();
        }

        inline void unlock()
        {
            m_rwlock->unlock();
        }

    private:
        _rwlock_ *m_rwlock;
    };

    //------------------------------------------------------------------------
    class RWLock
    {
    public:
        RWLock() : m_lock(NULL) {}

        RWLock(ReaderWriterLock& rwlock, bool writeLock = false) : m_lock(NULL)
        {
            lock(rwlock, writeLock);
        }

        RWLock(RWLock& rl) : m_lock(NULL)
        {
            lock(*rl.m_lock, rl.m_writeLock);
        }

        RWLock& operator=(RWLock& rl)
        {
            lock(*rl.m_lock, rl.m_writeLock);
            return *this;
        }

        virtual ~RWLock()
        {
            unlock();
        }

        void lock(ReaderWriterLock& rwlock, bool writeLock = false)
        {
            unlock();
            m_lock = &rwlock;
            if(m_lock)
            {
                if(writeLock)
                    m_lock->lockForWrite();
                else
                    m_lock->lockForRead();
                m_writeLock = writeLock;
            }
        }

        void unlock()
        {
            if(m_lock)
            {
                m_lock->unlock();
                m_lock = NULL;
            }
        }

        void swap(RWLock& r)
        {
            ReaderWriterLock *tmp = m_lock;
            m_lock = r.m_lock;
            r.m_lock = tmp;
            bool t = m_writeLock;
            m_writeLock = r.m_writeLock;
            r.m_writeLock = t;
        }

    private:
        ReaderWriterLock *m_lock;
        bool m_writeLock;
    };

    //------------------------------------------------------------------------
    template<bool isWriter> class ReaderWriterLockLockerTempl
    {
    public:
        ReaderWriterLockLockerTempl() : m_lock(NULL) {}

        ReaderWriterLockLockerTempl(ReaderWriterLock& rwlock) : m_lock(NULL)
        {
            lock(rwlock);
        }

        ReaderWriterLockLockerTempl(ReaderWriterLockLockerTempl& rl) : m_lock(NULL)
        {
            lock(*rl.m_lock);
        }

        ReaderWriterLockLockerTempl& operator=(ReaderWriterLockLockerTempl& rl)
        {
            lock(*rl.m_lock);
            return *this;
        }

        virtual ~ReaderWriterLockLockerTempl()
        {
            unlock();
        }

        void lock(ReaderWriterLock& rwlock)
        {
            unlock();
            m_lock = &rwlock;
            if(m_lock)
            {
                if(isWriter)
                    m_lock->lockForWrite();
                else
                    m_lock->lockForRead();
            }
        }

        void unlock()
        {
            if(m_lock)
            {
                m_lock->unlock();
                m_lock = NULL;
            }
        }

        void swap(ReaderWriterLockLockerTempl& r)
        {
            ReaderWriterLock *tmp = m_lock;
            m_lock = r.m_lock;
            r.m_lock = tmp;
        }

    private:
        ReaderWriterLock *m_lock;
    };

    typedef ReaderWriterLockLockerTempl<true> WriterLock;

    typedef ReaderWriterLockLockerTempl<false> ReaderLock;

} // namespace Celartem

#endif // _cel_rwlock_h_

---

This document is automatically generated using doxygen 1.5.4 at Fri Jun 27 18:21:54 2008.