PhxLocks.h

Go to the documentation of this file.

#ifndef PHX_LOCKS_H
#define PHX_LOCKS_H

#define HAVE_PTHREAD_RECURSUVE_LOCKS 0

#include <Phx/PhxConfig.h> // also includes pthread.h
#include <Phx/PhxTypes.h>

#if HAVE_PTHREAD_RECURSUVE_LOCKS

#else
#include <Phx/Util/PhxThread.h>
#endif

#include <errno.h>
#include <iostream>

namespace Phx {

class Lock {
public:
    Lock(bool recursive=false);

    ~Lock();

    void lock(void)
        const;

    void unlock(void) const;

    bool isRecursive() {
        return mRecursive;
    }

private:
    pthread_mutex_t mLock;
    bool mRecursive;

#if HAVE_PTHREAD_RECURSUVE_LOCKS

#else
    int mClaimedNumTimes;
    pthread_t mThreadID;
#endif
};

class ReadWriteLock {
public:
    ReadWriteLock();

    ~ReadWriteLock();

    void readLock(void) const;

    void writeLock(void) const;

    void unlock(void) const;

private:
#if HAVE_PTHREAD_RWLOCK_INIT || DOXYGEN

    pthread_rwlock_t mLock;
#else
    // This is for the replacement for the ReadWriteLock class in the
    // event that the platform PThread implementation does not include
    // the rwlock type.  POSIX does not define this type; it was added
    // by the X/Open group.  This implementation uses a standard mutex
    // at present.  This is less efficient, but safe.

    pthread_mutex_t mLock;
#endif
};

class LockHolder {
public:

    LockHolder(const Lock* lock)
        ;

    LockHolder(LockHolder* lockHolder);

    ~LockHolder();

    void unlock(void);

private:
    // no assignment or copy
    LockHolder& operator=(LockHolder& );
    LockHolder(LockHolder& );

    const Lock* mLock;
};

class ReadLockHolder {
public:
    ReadLockHolder(const ReadWriteLock* lock)
        ;

    ReadLockHolder(ReadLockHolder* lockHolder);

    ~ReadLockHolder();

    void unlock(void);

private:
    // no assignment
    ReadLockHolder& operator=(ReadLockHolder& );
    ReadLockHolder(ReadLockHolder&);

    const ReadWriteLock* mLock;
};

class WriteLockHolder {
public:
    WriteLockHolder(const ReadWriteLock* lock)
        ;

    WriteLockHolder(WriteLockHolder* lockHolder);

    ~WriteLockHolder();

    void unlock(void);

private:
    // no assignment
    WriteLockHolder& operator=(WriteLockHolder& );
    WriteLockHolder(WriteLockHolder&);

    const ReadWriteLock* mLock;
};


}
; // namespace Phx

#endif /* PHX_LOCKS_H */

---