PthreadMutex.h

#ifndef CARMA_UTIL_PTHREAD_MUTEX_H
#define CARMA_UTIL_PTHREAD_MUTEX_H

#include <pthread.h>
#include <cerrno>

#include "carma/util/posixErrors.h"


namespace carma {
namespace util {


class PthreadMutexAttr;
class PthreadMutex;


void lockMutex( ::pthread_mutex_t & );
void lockMutex( PthreadMutex & );

bool tryLockMutex( ::pthread_mutex_t & );
bool tryLockMutex( PthreadMutex & );

void unlockMutex( ::pthread_mutex_t & );
void unlockMutex( PthreadMutex & );

int unlockMutexNoThrow( ::pthread_mutex_t & );
int unlockMutexNoThrow( PthreadMutex & );



class PthreadMutex {
    public:


        explicit PthreadMutex( );



        explicit PthreadMutex( int type );



        explicit PthreadMutex( const PthreadMutexAttr & attr );



        explicit PthreadMutex( const ::pthread_mutexattr_t & attr );



        virtual ~PthreadMutex( );



        void Lock( );



        bool TryLock( );



        void Unlock( );


        int UnlockNoThrow( );



        const ::pthread_mutex_t & InternalPthreadMutex( ) const;



        ::pthread_mutex_t & InternalPthreadMutex( );


    private:
        // no copying
        PthreadMutex( const PthreadMutex & rhs );
        PthreadMutex & operator=( const PthreadMutex & rhs );

        ::pthread_mutex_t mutex_;
};


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


inline void
carma::util::lockMutex( ::pthread_mutex_t & m )
{
    failIfPosixError( ::pthread_mutex_lock( &m ),
                      "::pthread_mutex_lock error" );
}


inline bool
carma::util::tryLockMutex( ::pthread_mutex_t & m )
{
    bool result = false;

    const int posixRetVal = ::pthread_mutex_trylock( &m );

    switch ( posixRetVal ) {
        case 0:
            result = true;
            break;

        case EBUSY:
            result = false;
            break;

        default:
            throwPosixError( posixRetVal, "::pthread_mutex_lock error" );
    }

    return result;
}


inline void
carma::util::unlockMutex( ::pthread_mutex_t & m )
{
    failIfPosixError( ::pthread_mutex_unlock( &m ),
                      "::pthread_mutex_unlock error" );
}


inline int
carma::util::unlockMutexNoThrow( ::pthread_mutex_t & m )
{
    return ::pthread_mutex_unlock( &m );
}


inline void
carma::util::PthreadMutex::Lock( )
{
    lockMutex( mutex_ );
}


inline bool
carma::util::PthreadMutex::TryLock( )
{
    return tryLockMutex( mutex_ );
}


inline void
carma::util::PthreadMutex::Unlock( )
{
    unlockMutex( mutex_ );
}


inline int
carma::util::PthreadMutex::UnlockNoThrow( )
{
    return unlockMutexNoThrow( mutex_ );
}


inline const ::pthread_mutex_t &
carma::util::PthreadMutex::InternalPthreadMutex( ) const
{
    return mutex_;
}


inline ::pthread_mutex_t &
carma::util::PthreadMutex::InternalPthreadMutex( )
{
    return mutex_;
}


inline void
carma::util::lockMutex( PthreadMutex & m )
{
    m.Lock();
}


inline bool
carma::util::tryLockMutex( PthreadMutex & m )
{
    return m.TryLock();
}


inline void
carma::util::unlockMutex( PthreadMutex & m )
{
    m.Unlock();
}


inline int
carma::util::unlockMutexNoThrow( PthreadMutex & m )
{
    return m.UnlockNoThrow();
}


#endif