mutex.h

Go to the documentation of this file.

// OSB library ********************************************* -*- C++ -*-
/*
  AUTHOR(S): Stephan Broennimann (vb)

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.43 $

  License
   OSB rating and billing library for communication networks
   Copyright (C) 2004, 2005, 2006  OSB systems

   This file may be distributed and/or modify under the terms of the
   GNU General Public License (GPL) as published by the Free Software
   Foundation which is provided in the file LICENSE.GPL included in the
   packaging of this file.

   The file 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 General Public License
   for more details.

   Holders of a OSB Commercial License may use this file under the terms
   and conditions of this commercial license.
 */
#ifndef _MUTEX_H_
#define _MUTEX_H_

// *********************************************************************
// included header files
// + standard includes
#include <deque>
#include <memory>
#include <pthread.h>

// + local headers
#include "osberror.h"
#include "guard.h"

// *********************************************************************
// namespace extensions
namespace OSB_LIB {

// *********************************************************************
// class definitions

    // *****************************************************************
    // class Mutex
    class Mutex {
    public:
        Mutex(const pthread_mutexattr_t* attr = 0);
        ~Mutex();

        int lock();

        int trylock();

        int unlock();

    private:
        Mutex(const Mutex&);
        Mutex& operator=(const Mutex&);

        pthread_mutex_t mutex_;
    };

    // *****************************************************************
    // class MutexUnlock
    class MutexUnlock : public Guard::Cleanup {
    public:
        explicit MutexUnlock(Mutex* pMutex = 0);

        virtual int cleanup();
    private:
        Mutex* pMutex_;
    };

    // *****************************************************************
    // class RwMutex
    class RwMutex {
    public:
        enum Priority {
            prioRead,
            prioWrite,
            prioQueue
        };

        explicit RwMutex(
                  Priority             priority = prioRead,
            const pthread_mutexattr_t* attr = 0
        );

        ~RwMutex();

        int readLock();

        int tryReadLock();

        int writeLock();

        int tryWriteLock();

        int readUnlock();

        int writeUnlock();

    private:
        RwMutex(const RwMutex&);
        RwMutex& operator=(const RwMutex&);

        enum LockType { ltRead, ltWrite };
        typedef std::deque<LockType> LockQueue;

        pthread_mutex_t mutex_;
        pthread_cond_t  condRead_;
        pthread_cond_t  condWrite_;
        int             curReaders_;    
        int             curWriters_;    

        Priority priority_;
        LockQueue lockQueue_;

        void addWait(LockType lt);
        void rmWait(LockType lt);
        bool canReadLock();
        bool canWriteLock();
        void sendCondition();
    };

    // *****************************************************************
    // class RwGuard
    class RwGuard {
    private:
        struct RwGuardRef {
            RwGuard& s;
            RwGuardRef(RwGuard& r) : s(r) {};
        };
    public:
        typedef int (RwMutex::*Unlock)();

        RwGuard(
            bool     locked = true,
            RwMutex* pMutex = 0,
            Unlock   unlock = 0
        );

        ~RwGuard();

        RwGuard(RwGuard& rhs);

        RwGuard& operator=(RwGuard rhs);

        RwGuard(RwGuardRef r);
        operator RwGuardRef();

        void unlock();

        bool locked() const { return locked_; }

        bool release();
    private:
        bool     locked_;               
        RwMutex* pMutex_;               
        Unlock   unlock_;               
    };

    template<typename T> class ReadGuard;

    template<typename T> class ReadGuard<T*> {
    private:
        template<typename S> friend class ReadGuard;
        struct ReadGuardRef {
            ReadGuard& s;
            ReadGuardRef(ReadGuard& r) : s(r) {}
        };
    public:
        ReadGuard(
            const T* ptr     = 0,
            bool     locked  = true,
            RwMutex* pMutex  = 0
        ) : status_(), ptr_(ptr),
            guard_(locked, pMutex, &RwMutex::readUnlock) {}

        explicit ReadGuard(
            int stat
        ) : status_(stat), ptr_(), guard_(false) {}

        ReadGuard(
            ReadGuard& rhs
        ) : status_(rhs.status_),
            ptr_(rhs.ptr_),
            guard_(rhs.guard_)
        {
            // empty
        }

        ReadGuard& operator=(ReadGuard rhs)
        {
             status_ = rhs.status_;
             ptr_    = rhs.ptr_;
             guard_  = rhs.guard_;
             return *this;
        }



        template<typename S> ReadGuard(
            ReadGuard<S*> rhs
        ) : status_(rhs.status_),
            ptr_(rhs.ptr_),
            guard_(rhs.guard_)
        {
            // empty
        }

        template<typename S> ReadGuard& operator=(
            ReadGuard<S*> rhs
        )
        {
             status_ = rhs.status_;
             ptr_    = rhs.ptr_;
             guard_  = rhs.guard_;
             return *this;
        }


        ReadGuard(
            ReadGuardRef r
        ) : status_(r.s.status_),
            ptr_(r.s.ptr_),
            guard_(r.s.guard_)
        {
            // empty
        }

        operator ReadGuardRef()
        {
            ReadGuardRef rc(*this);
            return rc;
        }

        const T* get() const
        {
            if (!locked()) return 0;
            return ptr_;
        }


        bool locked() const { return guard_.locked(); }

        void unlock() { guard_.unlock(); }

        bool release() { return guard_.release(); }

        int status_;

    private:
        const T* ptr_;
        RwGuard  guard_;
    };                                  // class ReadGuard<T*>

    template<typename T> class WriteGuard;

    template<typename T> class WriteGuard<T*> {
    private:
        template<typename S> friend class WriteGuard;
        struct WriteGuardRef {
            WriteGuard& s;
            WriteGuardRef(WriteGuard& r) : s(r) {}
        };
    public:
        WriteGuard(
            T*       ptr    = 0,
            bool     locked = true,
            RwMutex* pMutex = 0
        ) : status_(), ptr_(ptr),
            guard_(locked, pMutex, &RwMutex::writeUnlock) {}

        explicit WriteGuard(
            int stat
        ) : status_(stat), ptr_(), guard_(false) {}

        WriteGuard(
            WriteGuard& rhs
        ) : status_(rhs.status_),
            ptr_(rhs.ptr_),
            guard_(rhs.guard_)
        {
            // empty
        }

        WriteGuard& operator=(WriteGuard rhs)
        {
            status_ = rhs.status_;
            ptr_    = rhs.ptr_;
            guard_  = rhs.guard_;
            return *this;
        }



        template<typename S> WriteGuard(
            WriteGuard<S*> rhs
        ) : status_(rhs.status_),
            ptr_(rhs.ptr_),
            guard_(rhs.guard_)
        {
            // empty
        }

        template<typename S> WriteGuard& operator=(
            WriteGuard<S*> rhs
        )
        {
             status_ = rhs.status_;
             ptr_    = rhs.ptr_;
             guard_  = rhs.guard_;
             return *this;
        }


        WriteGuard(
            WriteGuardRef r
        ) : status_(r.s.status_),
            ptr_(r.s.ptr_),
            guard_(r.s.guard_)
        {
            // empty
        }

        operator WriteGuardRef() { WriteGuardRef rc(*this); return rc; }

        T* get()
        {
            if (!locked()) return 0;
            return ptr_;
        }


        bool locked() const { return guard_.locked(); }

        void unlock() { guard_.unlock(); }

        bool release() { return guard_.release(); }

        int status_;

    private:
        T* ptr_;
        RwGuard  guard_;
    };

    // *****************************************************************
    // template class Shared
    template<typename T> class Shared {
    public:
        Shared() {}
        Shared(const T& t) : shared_(t) {}

        T& lock()
        {
            mutex_.lock();
            return shared_;
        }

        T& trylock() throw(OsbException)
        {
            if (0 != mutex_.trylock()) throw DefException(112);
            return shared_;
        }

        void unlock()
        {
            mutex_.unlock();
        }

    private:
        Shared(const Shared&);
        Shared<T>& operator=(const Shared&);

        Mutex mutex_;
        T     shared_;
    };                                  // class Shared<T>

    // *****************************************************************
    // template class Shared<T*>
    template<typename T> class Shared<T*> {
    public:
        explicit Shared(T* t = 0)
        {
            shared_ = t;
            ownsShared_ = false;
        }

        explicit Shared(std::auto_ptr<T> t)
        {
            shared_ = t.release();
            ownsShared_ = true;
        }

        ~Shared() { if (ownsShared_) delete shared_; }

        T* lock()
        {
            mutex_.lock();
            return shared_;
        }

        T* trylock()
        {
            T* rc = 0;
            if (0 == mutex_.trylock()) rc = shared_;
            return rc;
        }

        void unlock()
        {
            mutex_.unlock();
        }

    private:
        Shared(const Shared&);
        Shared& operator=(const Shared&);

        Mutex mutex_;
        bool ownsShared_;
        T* shared_;
    };

    // *****************************************************************
    // template class RwShared
    template<typename T> class RwShared {
    public:
        RwShared(
            RwMutex::Priority p = RwMutex::prioRead
        ) : mutex_(p) {}

        RwShared(
            const T&                t,
                  RwMutex::Priority p = RwMutex::prioRead
        ) : shared_(t), mutex_(p) {}

        const T& readLock()
        {
            mutex_.readLock();
            return shared_;
        }

        const T& tryReadLock() throw(OsbException)
        {
            if (!mutex_.tryReadLock()) throw DefException(112);
            return shared_;
        }

        T& writeLock()
        {
            mutex_.writeLock();
            return shared_;
        }

        T& tryWriteLock() throw(OsbException)
        {
            if (!mutex_.tryWriteLock()) throw DefException(112);
            return shared_;
        }

        void readUnlock()
        {
            mutex_.readUnlock();
        }

        void writeUnlock()
        {
            mutex_.writeUnlock();
        }

    private:
        RwShared(const RwShared&);
        RwShared& operator=(const RwShared&);

        T shared_;
        RwMutex mutex_;
    };

    // *****************************************************************
    // template class RwShared<T*>
    template<typename T> class RwShared<T*> {
    public:
        RwShared(
            RwMutex::Priority p = RwMutex::prioRead
        ) : mutex_(p)
        {
            pShared_ = new T;
            ownsShared_ = true;
        }

        RwShared(
            T*                t,
            RwMutex::Priority p = RwMutex::prioRead
        ) : mutex_(p)
        {
            pShared_ = t;
            ownsShared_ = false;
        }

        RwShared(
            std::auto_ptr<T> t,
            RwMutex::Priority p = RwMutex::prioRead
        ) : mutex_(p)
        {
            pShared_ = t.release();
            ownsShared_ = true;
        }

        ~RwShared()
        {
            if (ownsShared_) delete pShared_;
        }

        const T* readLock()
        {
            mutex_.readLock();
            return pShared_;
        }

        const T* tryReadLock()
        {
            const T* rc = 0;
            if (mutex_.tryReadLock()) rc = pShared_;
            return rc;
        }

        T* writeLock()
        {
            mutex_.writeLock();
            return pShared_;
        }

        T* tryWriteLock()
        {
            T* rc = 0;
            if (mutex_.tryWriteLock()) rc = pShared_;
            return rc;
        }

        void readUnlock()
        {
            mutex_.readUnlock();
        }

        void writeUnlock()
        {
            mutex_.writeUnlock();
        }

    private:
        RwShared(const RwShared&);
        RwShared& operator=(const RwShared&);

        T* pShared_;
        bool ownsShared_;
        RwMutex mutex_;
    };
}                                       // namespace OSB_LIB
#endif                                  // #ifndef _MUTEX_H_

---