PthreadCond.h

#ifndef CARMA_UTIL_PTHREAD_COND_H
#define CARMA_UTIL_PTHREAD_COND_H

#include <pthread.h>

#include "carma/util/PthreadMutex.h"

namespace carma {
namespace util {


void broadcastCond( ::pthread_cond_t & c );


void signalCond( ::pthread_cond_t & c );


void waitCond( ::pthread_cond_t &  c,
               ::pthread_mutex_t & m );

void waitCond( ::pthread_cond_t & c,
               PthreadMutex &     m );


bool timedWaitCond( ::pthread_cond_t &        c,
                    ::pthread_mutex_t &       m,
                    const struct ::timespec & abstime );

bool timedWaitCond( ::pthread_cond_t &        c,
                    PthreadMutex &            m,
                    const struct ::timespec & abstime );


class PthreadCondAttr;



class PthreadCond {
    public:
        explicit PthreadCond( );


        explicit PthreadCond( const PthreadCondAttr & attr );


        explicit PthreadCond( const ::pthread_condattr_t & attr );


        virtual ~PthreadCond( );


        void Broadcast( );


        void Signal( );


        void Wait( ::pthread_mutex_t & m );

        void Wait( PthreadMutex & m );


        bool TimedWait( ::pthread_mutex_t &       m,
                        const struct ::timespec & abstime );

        bool TimedWait( PthreadMutex &            m,
                        const struct ::timespec & abstime );


        const ::pthread_cond_t & InternalPthreadCond( ) const;


        ::pthread_cond_t & InternalPthreadCond( );


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

        ::pthread_cond_t cond_;
};


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


inline void
carma::util::PthreadCond::Wait( PthreadMutex & m )
{
    Wait( m.InternalPthreadMutex() );
}


inline bool
carma::util::PthreadCond::TimedWait( PthreadMutex &            m,
                                     const struct ::timespec & abstime )
{
    return TimedWait( m.InternalPthreadMutex(), abstime );
}


inline const ::pthread_cond_t &
carma::util::PthreadCond::InternalPthreadCond( ) const
{
    return cond_;
}


inline ::pthread_cond_t &
carma::util::PthreadCond::InternalPthreadCond( )
{
    return cond_;
}


inline void
carma::util::waitCond( ::pthread_cond_t & c,
                       PthreadMutex &     m )
{
    waitCond( c, m.InternalPthreadMutex() );
}


inline bool
carma::util::timedWaitCond( ::pthread_cond_t &        c,
                            PthreadMutex &            m,
                            const struct ::timespec & abstime )
{
    return timedWaitCond( c, m.InternalPthreadMutex(), abstime );
}


#endif