ibrcommon/ibrcommon/thread/Conditional.h

Go to the documentation of this file.

#ifndef IBRCOMMON_CONDITIONAL_H_
#define IBRCOMMON_CONDITIONAL_H_

#include <stdlib.h>
#include <errno.h>
#include <pthread.h>
#include "ibrcommon/thread/Mutex.h"

namespace ibrcommon
{
        class Conditional : public Mutex
        {
                public:
                        Conditional();
                        virtual ~Conditional();

                        void signal(bool broadcast = false);
                        void wait();

                        /*
                         * Wait until signal() is called or the timeout exceeds.
                         * @param timeout A timeout in milliseconds.
                         * @return True, if signal() is called. False, if the timeout is exceeded.
                         */
                        bool wait(size_t timeout);

                        bool wait(struct timespec *ts);

                protected:
                        static void gettimeout(size_t timeout, struct timespec *hires);

                private:
                        class attribute
                        {
                        public:
                                pthread_condattr_t attr;
                                attribute();
                        };

                        pthread_cond_t cond;

                        static attribute attr;
        };

        template<class T, T block>
        class StatefulConditional : public Conditional
        {
        public:
                StatefulConditional(T state) : _state(state) {};
                virtual ~StatefulConditional() {};

                void setState(T state)
                {
                        if (ifState(block)) return;
                        _state = state;
                        this->signal(true);
                }

                bool waitState(T state)
                {
                        while (!ifState(state))
                        {
                                if (ifState(block)) return false;
                                wait();
                        }

                        return true;
                }

                T getState()
                {
                        return _state;
                }

                bool ifState(T state)
                {
                        return (state == _state);
                }

        private:
                T _state;
        };
}

#endif /*CONDITIONAL_H_*/

---