ScopedLockManager.h

#ifndef CARMA_UTIL_SCOPED_LOCK_MANAGER_H
#define CARMA_UTIL_SCOPED_LOCK_MANAGER_H


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


namespace carma {
namespace util {



template< typename M >
class ScopedLockManager {
    public:
        explicit ScopedLockManager( M & m );

        /* virtual */ ~ScopedLockManager( );

        void lock( );

        bool tryLock( );

        void unlock( );

    private:
        // no copying
        ScopedLockManager( const ScopedLockManager & );
        ScopedLockManager & operator=( const ScopedLockManager & );
        
        M &  m_;
        bool isLocked_;
};


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


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

template< typename M >
inline
carma::util::ScopedLockManager< M >::ScopedLockManager( M & m ) :
m_( m ),
isLocked_( false )
{
}


template< typename M >
inline
carma::util::ScopedLockManager< M >::~ScopedLockManager( )
try {
    if ( isLocked_ )
        logIfPosixError( unlockMutexNoThrow( m_ ) );
} catch ( ... ) {
    // just stifle any exceptions
    
    return;
}


template< typename M >
inline void
carma::util::ScopedLockManager< M >::lock( )
{
    CARMA_CHECK( isLocked_ == false );

    lockMutex( m_ );

    isLocked_ = true;
}


template< typename M >
inline bool
carma::util::ScopedLockManager< M >::tryLock( )
{
    CARMA_CHECK( isLocked_ == false );

    const bool result = tryLockMutex( m_ );

    if ( result )
        isLocked_ = true;

    return result;
}


template< typename M >
inline void
carma::util::ScopedLockManager< M >::unlock( )
{
    CARMA_CHECK( isLocked_ );

    unlockMutex( m_ );

    isLocked_ = false;
}


#endif