---

parameter.h

Go to the documentation of this file.

#ifndef ___PARAMETER_H___
#define ___PARAMETER_H___


#include <stdio.h>
#include <string>
using std::string;

#include "msg.h"
#include "tristate.h"
#include "stringutils.h"
#include "polymorph.h"


/*    Parameter datatypes    */
#define PARAM_USTRING         0
#define PARAM_3BOOL           1
#define PARAM_INT             2
#define PARAM_DOUBLE          3
#define PARAM_BOOL            4


// Can this be eliminated?
typedef int cmdstat; 

#define SETFN_ARGS2  const string& name, Typeless& param, const Typeless& newvalue
typedef cmdstat (*ParamSetFn2)( SETFN_ARGS2 );


class SetFnWrapper2 {
public:
  SetFnWrapper2() { }
  virtual ~SetFnWrapper2() { }
  virtual cmdstat operator() ( SETFN_ARGS2 )=0; 
};


#define SETFN_DECLARE2(fnname)                             \
cmdstat fnname( SETFN_ARGS2 );                              \
struct setfnobj2_ ## fnname : public SetFnWrapper2 {         \
  cmdstat operator() ( SETFN_ARGS2 )  {                       \
    return fnname(name,param,newvalue);                        \
  }                                                             \
}


#define SETFNOBJ_DECLARE2(Owner,fnname)                   \
cmdstat fnname ( SETFN_ARGS2 );                            \
class setfnobj2_ ## fnname : public SetFnWrapper2 {         \
  Owner* owner;                                              \
public:                                                       \
  setfnobj2_ ## fnname (Owner* owner_i) : owner(owner_i) { };  \
  cmdstat operator() ( SETFN_ARGS2 )  {                         \
    return owner->fnname(name,param,newvalue);                   \
  }                                                               \
};                                                                 \
friend class setfnobj2_ ## fnname



template <class T=int>
class ParameterDefinition {

public:
  typedef ParameterDefinition<T> self;

  ParameterDefinition(const Typeless& externallocation, const char *name_i="", 
                        bool is_constant_i=false)
  : val_ptr(externallocation.clone(),true),
    name_str(name_i), constant(is_constant_i),
    been_set(false), doc(0),
    low_bound(new Polymorph<int>(0),true), enforce_lower(false),
    upp_bound(new Polymorph<int>(0),true), enforce_upper(false),
    setfn2(0) {  }

  ParameterDefinition()
  : val_ptr(new Polymorph<int>(0),true),
    name_str(""), constant(false),
    been_set(false), doc(0),
    low_bound(new Polymorph<int>(0),true), enforce_lower(false),
    upp_bound(new Polymorph<int>(0),true), enforce_upper(false),
    setfn2(0) {  }
  
  int  check2() const {  return check2(datavalue());  }
  int  check2(const Typeless& val) const;

  string usage_string(const string prefix="")  const;
  string doc_string(const string prefix="")    const
    {  return usage_string(prefix) + (doc? "\n\n" + documentation() : "") + "\n";  }

  template <class BT>
  self& add_lower_bound(const BT& bound)
    {  low_bound=PolymorphPtr(new Polymorph<BT>(bound),true); enforce_lower = true; return *this;  }
  
  template <class BT>
  self& add_upper_bound(const BT& bound)
    {  upp_bound=PolymorphPtr(new Polymorph<BT>(bound),true); enforce_upper = true; return *this;  }
    
  
  self& add_doc(const char* docstring)     {  doc=docstring;      return *this;  }

  self& add_default_expr(const string& expr) {  default_expr=expr;  return *this;  }

  self& add_setfn(SetFnWrapper2* fnobj)    {  setfn2 = fnobj;     return *this;  }

  const char * get_default_expr() const   {  return default_expr!="" ? default_expr.c_str() : 0;  }

  string stringrep(const Typeless& value, const string& flags="", bool pretty=false) const {
    return (pretty?
            value.prettyprint( String::StreamFormat(flags)) :
            value.stringrep(   String::StreamFormat(flags)));
  }
  
  string stringrep(const string& flags="", bool pretty=false) const
    {  return stringrep(datavalue(),flags,pretty);  }

  void mark_set() {  been_set=true;  }
  bool has_been_set() const {  return been_set;  }

  bool set(const StringParser& parser, const string& s,
           bool mark=true, bool verbose=changes_verbose,
           const string& prefix="");
  void update_default_value(const StringParser& sp) {
    if (!has_been_set() && get_default_expr())
      set(sp,get_default_expr(),false);
  }
  
  bool definition_matches(const self& o) const
    {  return (name()==o.name() && is_constant()==o.is_constant() &&
               datavalue().typestring()==o.datavalue().typestring());  }

  bool is_constant()      const {  return constant;  }
  bool is_valid()         const {  return (!name_str.empty() && val_ptr.valueptr()!=0);  }

  inline const Typeless& datavalue() const {  return *val_ptr;  }
  
  inline       Typeless& datavalue()       {  return *(val_ptr.valueptr());  }

  string print_to_str(const string prefix="") const {
    /* Protects string substitution commands so that they are not taken literally when executed */ 
    const string rep = String::replace_all(stringrep(datavalue(),"",true),string("$"),string("$$$$"));
    return ("set " + prefix + name() + "=" + rep);
  }
      
  const string&  name() const {  return name_str;  }

  bool operator<(const self& o) const {  return( name() < o.name());  }

  static void message(Msg::MessageLevel m, const string& s)
    {  if (mhp && *mhp) (**mhp)(m,s);  }
  
  static bool changes_verbose; 
  self* duplicate() const {
    self* o = new self(*this);
    o->val_ptr = PolymorphPtr((*val_ptr).duplicate());
    return o;
  };

private:
  static Msg::LevelHandler<>** mhp;

  typedef OwningPointer<Typeless,CopyUsingClone<Typeless> > PolymorphPtr;

  PolymorphPtr val_ptr;             
  string name_str;                  
  bool constant;                    
  string default_expr;              
  int been_set;                     
  const char *doc;                  
  PolymorphPtr low_bound;           
  int enforce_lower;                
  PolymorphPtr upp_bound;           
  int enforce_upper;                
  SetFnWrapper2* setfn2;            
  string documentation() const;
  string type_string()   const {  return datavalue().typestring();  }
  string value_string()  const {  return stringrep(datavalue(),"",true);  }
  string range_string()  const
    {  return string("[" + (enforce_lower? stringrep(*low_bound,"",true) : "*") +
                     "," + (enforce_upper? stringrep(*upp_bound,"",true) : "*") + "]");  }
};



/* Static variables */
template <class T>
Msg::LevelHandler<>** ParameterDefinition<T>::mhp=&(Msg::LevelHandler<>::default_instance());
template<class T>
bool ParameterDefinition<T>::changes_verbose=true;



template <class T>
bool ParameterDefinition<T>::set(const StringParser& parser, const string& s,
                                 bool mark, bool verbose, const string& prefix)
{
  if (!is_valid())
    return false;
  
  if (is_constant()) {
    message(Msg::Error,"Can't change value of symbolic constant "+prefix+name());
    return false;
  }

  Typeless&       existing = *(val_ptr.valueptr());
  const Typeless* newvalue = (*val_ptr).parse(parser,s);
  
  if (check2(*newvalue))
    return false;

  if (mark) mark_set();

  bool status=true;

  /* Uses string representation as the standard to decide whether a value has changed */
  const string originalrep = stringrep();
  if (setfn2) status = ((*setfn2)(name(),existing,    *newvalue)>=0);
  else                                   existing.set(*newvalue);

  if (verbose && !(stringrep() == originalrep))
    message(Msg::Notify,"Changed parameter " + prefix + name() + " to " + stringrep("",true) + "");

  return true;
}



template <class T>
int ParameterDefinition<T>::check2(const Typeless& value) const
{
  if (enforce_lower && value < *low_bound ) {
    message(Msg::Error,name()+" too small (" + value.stringrep() +
            " < " + (*low_bound).stringrep() + ")");
    return 1;
  }
  
  if (enforce_upper && value > *upp_bound) {
    message(Msg::Error,name()+" too large (" + value.stringrep() +
            " > " + (*upp_bound).stringrep() + ")");
    return 1;
  }

  return 0;
}



template <class T>
string ParameterDefinition<T>::usage_string(const string prefix)  const
{
  const int    colpos  = 40; /* Position of second column */
  const string column1 = prefix+name()+"="+value_string() 
    + (get_default_expr()? " [default: " + default_expr + "] " : string(" "));

  const string spaces(std::max(0,int((colpos-1)-column1.length())),' ');
  const string column2 = 
    "(" + type_string() +
    (constant? " constant" : 
     (enforce_lower || enforce_upper ? 
      " with range " + range_string() : "")) + ")";
  
  return column1 + spaces + column2;
}



template <class T>
string ParameterDefinition<T>::documentation() const
{
  string s = doc;
  unsigned pos;
  const string namemarker="%s";
  while ((pos=s.find(namemarker))<s.length())
    s.replace(pos,namemarker.length(),name());
  return s;
}



#endif /* ___PARAMETER_H___ */

---