#ifndef __WAITVARIABLE_H__
#define __WAITVARIABLE_H__

#include "util/boostthread.h"

#ifdef _WIN32_WCE
// for some strange reason 'clock' is not in wince.
namespace std {
#define CLOCKS_PER_SEC 1000
    inline clock_t clock()
    {
        return GetTickCount();
    }
}
#endif
#include <boost/timer.hpp>

//#include <set>

// this implements a variable, which can be set in one thread,
// and waited for a specific value in another thread.
template<typename T>
class waitvariable {
private:
    boost::condition _cond;
    boost::mutex _mtx;
    T _value;
    bool _changed;

public:    
    waitvariable(T initial) : _value(initial), _changed(false) { }
    // wait until the waitvar is equal to the specified value
    bool wait_equal(T value, double timeout=-1)
    {
        boost::mutex::scoped_lock lock(_mtx);
        boost::timer t0;
        while (value!=_value && (timeout<0 || t0.elapsed()<timeout))
            _cond.wait(lock);
        return value==_value;
    }
    // wait until the waitvar is not equal to the specified value
    T wait_not_equal(T value, double timeout=-1)
    {
        boost::mutex::scoped_lock lock(_mtx);
        boost::timer t0;
        while (value==_value && (timeout<0 || t0.elapsed()<timeout))
            _cond.wait(lock);
        return _value;
    }
#if 0
    // wait until the waitvar is in the specified set
    T wait_inset(std::set<T> s, double timeout=-1)
    {
        boost::mutex::scoped_lock lock(_mtx);
        boost::timer t0;
        while (s.find(_value)==s.end() && (timeout<0 || t0.elapsed()<timeout))
            _cond.wait(lock);
        return _value;
    }
    // wait until the waitvar is not in the specified set
    T wait_notinset(std::set<T> s, double timeout=-1)
    {
        boost::mutex::scoped_lock lock(_mtx);
        boost::timer t0;
        while (s.find(_value)!=s.end() && (timeout<0 || t0.elapsed()<timeout))
            _cond.wait(lock);
        return _value;
    }
#endif

    // wait until the waitvar is no longer equal to the specified value
    T wait_change(T value, double timeout=-1)
    {
        boost::mutex::scoped_lock lock(_mtx);
        boost::timer t0;
        while (value==_value && (timeout<0 || t0.elapsed()<timeout))
            _cond.wait(lock);
        return _value;
    }

    // wait until the waitvar was set
    T wait_update(double timeout=-1)
    {
        boost::mutex::scoped_lock lock(_mtx);
        boost::timer t0;
        while (!_changed && (timeout<0 || t0.elapsed()<timeout))
            _cond.wait(lock);
        _changed= false;
        return _value;
    }
    template<typename P>
    T wait_until(P pred, double timeout=-1)
    {
        boost::mutex::scoped_lock lock(_mtx);
        boost::timer t0;
        while (!pred(_value) && (timeout<0 || t0.elapsed()<timeout))
            _cond.wait(lock);
        _changed= false;
        return _value;
    }

    // sets the waitvar, and notifies other threads.
    void set(T value)
    {
        boost::mutex::scoped_lock lock(_mtx);
        _value= value;
        _changed= true;
        lock.unlock();
        _cond.notify_one();
    }
    T get() const { return _value; }
};
#endif