ScopedPthreadMutexLockManager.h

#ifndef CARMA_UTIL_SCOPED_PTHREAD_MUTEX_LOCK_MANAGER_H
#define CARMA_UTIL_SCOPED_PTHREAD_MUTEX_LOCK_MANAGER_H


#include "carma/util/checking.h"
#include "carma/util/PthreadMutex.h"
#include "carma/util/posixErrors.h"


namespace carma {
namespace util {



class ScopedPthreadMutexLockManager {
    public:
        explicit ScopedPthreadMutexLockManager( PthreadMutex & mutex );

        /* virtual */ ~ScopedPthreadMutexLockManager( );

        void LockMutex( );

        bool TryLockMutex( );

        void UnlockMutex( );

    private:
        // no copying
        ScopedPthreadMutexLockManager( const ScopedPthreadMutexLockManager & );
        ScopedPthreadMutexLockManager & operator=( const ScopedPthreadMutexLockManager & );
        
        PthreadMutex & mutex_;
        bool           mutexIsLocked_;
};


}  // namespace carma::util
}  // namespace carma


// ******* Below here is simply implementation *******

inline
carma::util::ScopedPthreadMutexLockManager::ScopedPthreadMutexLockManager( PthreadMutex & mutex ) :
mutex_( mutex ),
mutexIsLocked_( false )
{
}


inline
carma::util::ScopedPthreadMutexLockManager::~ScopedPthreadMutexLockManager( )
try {
    if ( mutexIsLocked_ )
        logIfPosixError( mutex_.UnlockNoThrow( ) );
} catch ( ... ) {
    // just stifle any exceptions
    
    return;
}


inline void
carma::util::ScopedPthreadMutexLockManager::LockMutex( )
{
    CARMA_CHECK( mutexIsLocked_ == false );

    mutex_.Lock( );

    mutexIsLocked_ = true;
}


inline bool
carma::util::ScopedPthreadMutexLockManager::TryLockMutex( )
{
    CARMA_CHECK( mutexIsLocked_ == false );

    bool result = mutex_.TryLock( );

    if ( result )
        mutexIsLocked_ = true;

    return result;
}


inline void
carma::util::ScopedPthreadMutexLockManager::UnlockMutex( )
{
    CARMA_CHECK( mutexIsLocked_ );

    mutex_.Unlock( );

    mutexIsLocked_ = false;
}


#endif