sprint/thread/rwmutex.h

Go to the documentation of this file.

/******************************************************************************
*   SPRINT::mutex
*
*   Copyright (C) 2003-2007  Paolo Medici <www.pmx.it>
*
*  This library is free software; you can redistribute it and/or
*  modify it under the terms of the GNU Lesser General Public
*  License as published by the Free Software Foundation; either
*  version 2.1 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
*  Lesser General Public License for more details.
*
*  You should have received a copy of the GNU Lesser General Public
*  License along with this library; if not, write to the Free Software
*  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*
*******************************************************************************/

#ifndef _RWMUTEX_H
#define _RWMUTEX_H

// @todo: not final version. rewrite it
         
#include <sprint/mutex.h>

namespace sprint {

class ReadWriteMutex {
        sprint::mutex reader, writer, mutex;
        int readercount;
        public:
                ReadWriteMutex() : readercount(0)
                        {
                        }
                ~ReadWriteMutex()
                        {
                        }
                        
                void acquireReadLock()
                {
                 // check point per verificare che un writer sia in coda
                 reader.lock();
                 
                 // lock for readercount
                 mutex.lock();
                 if(++readercount==1)
                        writer.lock();  // blocca l'ingresso di scrittori
                 mutex.unlock();
                 
                 reader.unlock();
                }
                
                void releaseReadLock()
                {

                 // lock for readercount
                 mutex.lock();
           if(--readercount==0)
                        writer.unlock();
                 mutex.unlock();
                }

                void acquireWriteLock()
                {
                 reader.lock(); // blocca l'ingresso di ulteriori lettori
                 writer.lock(); // attende che eventuali lettori abbiano terminato
                }
                
                void releaseWriteLock()
                {
                 writer.unlock();
                 reader.unlock();
                }

};

class ScopedReadLock
    {
    public:
        ScopedReadLock(ReadWriteMutex& rwLock) :
            m_rwLock(rwLock)
        {
            m_rwLock.acquireReadLock();
        }

        ~ScopedReadLock()
        {
            m_rwLock.releaseReadLock();
        }

    private:
        ReadWriteMutex& m_rwLock;
    };

class ScopedWriteLock
    {
    public:
        ScopedWriteLock(ReadWriteMutex& rwLock) :
            m_rwLock(rwLock)
        {
            m_rwLock.acquireWriteLock();
        }

        ~ScopedWriteLock()
        {
            m_rwLock.releaseWriteLock();
        }

    private:
        ReadWriteMutex& m_rwLock;
    };

}

#endif