Control.h

Go to the documentation of this file.

#include "defines.h"
#ifdef CONTROL
#ifndef CONTROL_H
#define CONTROL_H

#include <map>
#include <list>
#include <string>

//struct ltstr { bool operator()(const char* s1, const char* s2) const { return strcmp(s1, s2) < 0;}};

struct SDL_mutex;
namespace annie
{
typedef std::string ValueKey;
//typedef const char *ValueKey;
class PublicValues; //FW
class Value;    //FW
class Value {
public:
    enum { VISIBLE=1, DEFAULT=VISIBLE};
    unsigned flags; //<! we'd like to concentrate most of the flags used in listeners so that Listener doesn't have to hold per'value data and also that the flags are portable between listeners
    typedef real val_t;
    static const double DISPLAY_THRESHOLD;  //< value won't be re-displayer more often then this (seconds)

    void set(val_t to);
    val_t get() const { return _current; }
    val_t getLast() const { return _last; }
    Value &operator= (val_t val)    { set(val); return *this; }
    val_t operator()() const    { return get(); }
    operator val_t () const { return get(); }

    bool isVisible() const { return flags & VISIBLE; }
    Value(const std::string &name);

    struct Time {
        Time();
        double diffReal(const Time &t) { Time tmp = (*this) - t; return tmp.toSec(); }
        Time operator-(const Time &t) const;
        Time &operator-=(const Time &t) { (*this) = (*this) - t; return (*this); }

        double toSec() const;
        
        void current();

        timeval _realCalendar;
      protected:
        Time(const timeval &realCalendar) : _realCalendar(realCalendar) {}
    };
    std::string name() const    { return _name; }
    
    bool enoughTimePassed() const;

    double timeFromLastChange() const   {
        Time current;
        current -= _time;
        return current.toSec();
    }
    
private:
    real _current,  //< current value
    _last;      //< previous value
    Time _time, _lastTime;  //<time when current/last were set
    mutable Time    _lastTimeDisplayed;
    const std::string _name;
};

class PublicReal;
struct ValueUpdateListener;
class PublicValues
{
    friend class PublicReal;
public:
    PublicValues();
    ~PublicValues();
    void change(const ValueKey &name, real newVal);

    void inc(const ValueKey &name);

    void setFlags(const ValueKey &name, unsigned flags);

    //const Value &operator[](const std::string &name) const throw(Exception) { return (*this)[name]; }
    PublicReal operator[](const std::string &name) throw(Exception);

    PublicReal get(const std::string &name);

    PublicReal init(const std::string &name, real init=0.);
    
    void addListener(ValueUpdateListener *l);

    void removeListener(ValueUpdateListener *l);

    void addListener(ValueUpdateListener &l) { addListener(&l); }
    void removeListener(ValueUpdateListener &l) { removeListener(&l); }

    void triggerAll() const;
private:
    void hookValue(const Value &v);
    void unHookValue(const Value &v)    { /*TODO*/}

    //direct change - the Value must be present in this PublicValues
    void change(Value &v, real newVal);

    void _updated(const Value &v) const;

    Value &_exist(const ValueKey &name);

    typedef std::map<std::string, Value> Values;
    Values _values;
    typedef std::list<ValueUpdateListener *> Listeners;
    Listeners _listeners;
#ifdef THREADS_ENABLED
    SDL_mutex *valuesLock;
#endif
};

PublicValues &getDefaultControl();
#define defaultControl  getDefaultControl()

struct ValueUpdateListener  {
    ValueUpdateListener(PublicValues &ctrl=defaultControl);
    virtual void valueChanged(const Value &val) = 0;

    PublicValues &getPublicValues() const;

    virtual ~ValueUpdateListener();
  protected:
    PublicValues &control;
};



//TODO: templatize parameter && enable other-than-real vars?
class PublicReal    {
public:
    friend class PublicValues;
    //TODO: also enable 'anon' (unnamed), so we can replace all reals eventually
    operator real() const { return get(); }
#ifdef FP_ENABLED
    int toInt() const { return  get().toInt(); }
    double toDouble() const { return    get().toDouble(); }
#endif
    //operator const real() const   {   return get(); }
    real operator=(real r) { set(r); return r; }
    real operator++ ()  {   set(get() + 1.); return get();  }
    real operator++(int)    { real r = get(); set(r + 1); return r; }
    
    real operator-(real r) const { return get() - r; }
    real operator+(real r) const { return get() + r; }
    real operator*(real r) const { return get() * r; }
    
    real operator*=(real r) { set(get() * r); return get(); }
    real operator+=(real r) { set(get() + r); return get(); }
    real operator-=(real r) { set(get() - r); return get(); }

    double timeFromLastChange() const { return _val.timeFromLastChange(); }

#ifdef CONTROL
    //we rely on never-lasting Values in control, which is not good. But we can count it on Value --> OK ..
    Value &_val;
    PublicValues &_control;
#else
    //ordinary real (+maybe name, if even..)
#endif
    ~PublicReal()   { _control.unHookValue(_val); }
    PublicReal(const PublicReal &p);
  private:
    void set(real r) { _control.change(_val, r); }
    real get() const { return _val.get(); }
    PublicReal(Value &v, PublicValues &c) : _val(v), _control(c) { _control.hookValue(_val); }
    PublicReal &operator=(const PublicReal &p); //never implemented
};

typedef PublicReal Creal;

}; //namespace annie
#endif // define _EXCEPTION_H
#endif // CONTROL

---