/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield 
 *
 * This library is open source and may be redistributed and/or modified under  
 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or 
 * (at your option) any later version.  The full license is in LICENSE file
 * included with this distribution, and on the openscenegraph.org website.
 * 
 * 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 
 * OpenSceneGraph Public License for more details.
*/

#ifndef OSGDB_REENTRANTMUTEX
#define OSGDB_REENTRANTMUTEX

#include <OpenThreads/Thread>
#include <OpenThreads/Mutex>

#include <osgDB/Export>

namespace osgDB {

class OSGDB_EXPORT ReentrantMutex : public OpenThreads::Mutex
{
    public:

        ReentrantMutex();

        virtual ~ReentrantMutex();

        virtual int lock();

        virtual int unlock();

        virtual int trylock();

    private:

        ReentrantMutex(const ReentrantMutex&):OpenThreads::Mutex() {}

        ReentrantMutex& operator =(const ReentrantMutex&) { return *(this); }
        
        OpenThreads::Thread* _threadHoldingMutex;
        unsigned int         _lockCount;

};

class OSGDB_EXPORT ReadWriteMutex
{
    public:
    
        ReadWriteMutex();
        
        virtual ~ReadWriteMutex();
    
        virtual int readLock();

        virtual int readUnlock();

        virtual int writeLock();

        virtual int writeUnlock();
        
    protected:
    
        ReadWriteMutex(const ReadWriteMutex&) {}
        ReadWriteMutex& operator = (const ReadWriteMutex&) { return *(this); }
        
#if 1        
        ReentrantMutex  _readWriteMutex;        
        ReentrantMutex  _readCountMutex;
#else
        OpenThreads::Mutex  _readWriteMutex;        
        OpenThreads::Mutex  _readCountMutex;
#endif
        unsigned int    _readCount;
        
};

class ScopedReadLock
{
    public:
    
        ScopedReadLock(ReadWriteMutex& mutex):_mutex(mutex) { _mutex.readLock(); }
        ~ScopedReadLock() { _mutex.readUnlock(); }
        
    protected:  
        ReadWriteMutex& _mutex;
};


class ScopedWriteLock
{
    public:
    
        ScopedWriteLock(ReadWriteMutex& mutex):_mutex(mutex) { _mutex.writeLock(); }
        ~ScopedWriteLock() { _mutex.writeUnlock(); }
        
    protected:  
        ReadWriteMutex& _mutex;
};

}

#endif