mutator.h

Go to the documentation of this file.

// -*- C++ -*-

#ifndef NMWR_GB_MUTATOR_H
#define NMWR_GB_MUTATOR_H


#include "mutator-base.h"

#include <iostream>
#include <string>

// simplest concrete Mutator
template<class T>
class TypedMutator : public Mutator {
protected:
  T& v;
public:
  TypedMutator(T& vv) : v(vv) {}
  virtual ~TypedMutator() {}
  T value() {return v;}
  virtual void read(std::istream& in)   { in >> v;}
  virtual void print(std::ostream& out) const 
    { out << v;}
  virtual void print(std::ostream& out, const std::string& prefix = "") const 
    { out << prefix << v;}
};

 
// notify controlee, if variable changes.
template<class T>
class NotifyOnChangeMutator : public TypedMutator<T> {
public:
  typedef  TypedMutator<T> base;
  NotifyOnChangeMutator(T& t, controlable& c)
    : base(t), controlee(c) {}
  virtual ~NotifyOnChangeMutator() {}
  virtual void read(std::istream& in) {
    T old(base::value());
    base::read(in);
    if( old != base::value()) controlee.notify();
  }
private:
  controlable& controlee;
};


/*
template<class T>
class DebugTypedMutator : public TypedMutator<T> {
  typedef TypedMutator<T> tm;
public: 
  DebugTypedMutator(T& t) : tm(t) {}
  virtual void read(std::istream& in) {
    std::cerr << "Mutator: old value: " << value();
    tm::read(in);
    std::cerr << "  new value: " << value();
   }
  virtual void print(std::ostream& out)
    { tm::print(out); out << " (@ " << (void*)&v << ")";}
};
*/

class SetTrueOnReadMutator : public TypedMutator<bool> {
  typedef TypedMutator<bool> tm;
 public:
  SetTrueOnReadMutator(bool& flag) : tm(flag) {}
  virtual ~SetTrueOnReadMutator() {}
  virtual void read(std::istream&) { v = true;}
  virtual void print(std::ostream& out) const { out << v;}
  virtual void print(std::ostream& out, const std::string& name) const 
    { if(v) out << name;} 
};


class SetFalseOnReadMutator : public TypedMutator<bool> {
  typedef TypedMutator<bool> tm;
 public:
  SetFalseOnReadMutator(bool& flag) : tm(flag) {}
  virtual ~SetFalseOnReadMutator() {}
  virtual void read(std::istream&) { v = false;}
  virtual void print(std::ostream& out) const { out << !v;}
  virtual void print(std::ostream& out, const std::string& name) const 
    { if(!v) out << name;} 
};



class FlipOnReadMutator : public TypedMutator<bool> {
  typedef TypedMutator<bool> tm;
 public:
  FlipOnReadMutator(bool& flag) : tm(flag) {}
  virtual ~FlipOnReadMutator() {}
  virtual void read(std::istream&) { v = !v;}
  virtual void print(std::ostream& out) const { out << v;}
  virtual void print(std::ostream& out, const std::string& name) const 
    {  out << name;} 
};

// examples: 
// Ctrl.add("show", new SetTrueOnRead(show));
//  will set show to true if read,
// Ctrl.add("toggle-binary", new SetTrueOnRead(bin_flag));
// will flip the value of bin_flag if "toggle-binary" is read.



template<class T, class Tsec>
class SetOnReadMutator : public TypedMutator<T> {
  typedef TypedMutator<T> tm;
protected:
  Tsec& v2;
  Tsec  deflt;
public:
  SetOnReadMutator(T& t, Tsec& t2, Tsec def) : tm(t), v2(t2), deflt(def) {}
  virtual ~SetOnReadMutator() {}
  virtual void read(std::istream& in) { tm::read(in); v2 = deflt;} 
};

// example: SetOnReadMutator<double,bool>(x,xread,true)
// will set xread to true if x is read.

template<class T>
class CommentedMutator : public TypedMutator<T> {
  typedef TypedMutator<T> tm;
  std::string comment;
public:
  CommentedMutator(T& t, const std::string& c) 
    //: tm(t), comment(c) {}
    : TypedMutator<T>(t), comment(c) {}
  virtual ~CommentedMutator() {}
  //  virtual void print(std::ostream& out) const { tm::print(out); out  << "  " << comment;} 
  virtual std::string description() const { return comment;}
};

// Mutator-generating Functions

// simplest: base to all other Mutators below
template<class T>
inline TypedMutator<T>* GetMutator(T& t) { return new TypedMutator<T>(t);}

template<class T>
inline CommentedMutator<T>* GetMutator(T& t, const std::string& comment) 
{ return new CommentedMutator<T>(t,comment);}
 
template<class T>
inline CommentedMutator<T>* GetMutator(T& t, const char* comment) 
{ return new CommentedMutator<T>(t,comment);}
 
// notify observ if t is read & changed
template<class T>
inline NotifyOnChangeMutator<T>* GetNotifyingMutator(T& t, controlable& observ) 
{ return new NotifyOnChangeMutator<T>(t,observ);}

// t = true if read
inline SetTrueOnReadMutator* GetTrueOnReadMutator(bool& t)
{ return new SetTrueOnReadMutator(t);}

// t = false if read
inline SetFalseOnReadMutator* GetFalseOnReadMutator(bool& t)
{ return new SetFalseOnReadMutator(t);}

// t = !t if read
inline FlipOnReadMutator* GetFlipOnReadMutator(bool& t)
{ return new FlipOnReadMutator(t);}

// obs = deflt if t is read
template<class T, class TObs>
inline SetOnReadMutator<T,TObs>* GetSetOnReadMutator(T& t, TObs& obs, TObs deflt)
{ return new SetOnReadMutator<T,TObs>(t,obs,deflt); }

// write a comment if printed
template<class T>
inline CommentedMutator<T>* GetCommentedMutator(T& t,
    const std::string& comment)
{ return  new  CommentedMutator<T>(t,comment); }

template<class T>
inline CommentedMutator<T>* GetCommentedMutator(T& t, const char* comment)
{ return  new  CommentedMutator<T>(t,std::string(comment)); }

#endif

---