param.h

Go to the documentation of this file.

 
#ifndef PARAM_H
#define PARAM_H
 
#include <iostream>
#include <fstream>
#include <string>
#include <string.h>
#include <assert.h>
#include <map>
#include <deque>
#include <list>
#include <vector>
#include "handler.h"
#include "tmatrix.h"
#include "types.h"
#include "output.h"
 
using namespace std;
class SimComponent;
class ParamUpdaterBase;
class Param
  {
    string          _name;
    string          _arg;
    string          _input_arg;
    param_t         _type;
    bool            _isSet;
    bool            _isBounded;
    bool            _isRequired;
    double          _bounds[2];
    unsigned int    _setAtGeneration;
    SimComponent*   _myOwner;
    ParamUpdaterBase* _myUpdater;
    
    vector< string > _externalFile;
    bool   _hasExternalFile;
    
    map< unsigned int, string > _temporalArgs;
    bool _isTemporal;
    
    vector< string > _multiArgs;
    bool _hasMultipleArgs;
 
    bool _hasPreservedMacro;
 
  public:
    Param  (string& Name, param_t Type, bool mandatory, bool bounded, double low_bnd, double up_bnd, 
            SimComponent* owner, ParamUpdaterBase* updater);
    
    Param (const Param& P);
    
    virtual ~Param ();
    
    void    reset   ();
    
    //accessors:
    void            setName             (string value)          {_name = value;}
    void            setArg              (string value)          {_arg = value; _input_arg = value;}
    void            setType             (param_t value)         {_type = value;}
    void            setIsSet            (bool value)            {_isSet = value;}
    void            setIsBounded        (bool value)            {_isBounded = value;}
    void            setIsRequired        (bool value)            {_isRequired = value;}
    void            setBounds   (double low_bnd,double up_bnd)  {_bounds[0]=low_bnd; _bounds[1]=up_bnd;}
    void            setOwner            (SimComponent *owner)   {_myOwner = owner;}
    void            setUpdater          (ParamUpdaterBase* updater) {_myUpdater = updater;}
    
    void            setAtGeneration     (unsigned int generation) {_setAtGeneration = generation;}
    
    
    string          getName             ()                      {return _name;}
    string          getArg              ()                      {return _arg;}
    string          getInputArg         ()                      {return _input_arg;}
    param_t         getType             ()                      {return _type;}
    bool            isSet               ()                      {return _isSet;}
    bool            isBounded           ()                      {return _isBounded;}
    bool            isRequired          ()                      {return _isRequired;}
    bool            isTemporal          ()                      {return _isTemporal;}
    bool            hasMultipleArgs     ()                      {return _hasMultipleArgs;}
    bool            hasPreservedMacro   ()                      {return _hasPreservedMacro;}
    void            clearPreservedMacro ()                      {_hasPreservedMacro = false;}
    bool            hasExternalFile     ()                      {return _hasExternalFile;}
    double          getBound            (unsigned int i)        {return _bounds[i];}
    SimComponent*   getOwner            ()                      {return _myOwner;}
    ParamUpdaterBase* getUpdater        ()                      {return _myUpdater;}
    
    deque< unsigned int >  getUpdatingDates ();  
    
    deque< string > getTemporalArgs();
    
    vector< string > getMultiArgs();
    
    vector< string > getExternalFiles() {return _externalFile;}
 
    bool            set                  (string arg, string& errmsg);
    
    bool            update               (unsigned int generation);
    
    double          getValue            ();
    
    bool            isMatrix            () 
    {  return (_type == MAT || (_arg.size() != 0 ? _arg[0] == '{' : false) ); }
    
    void            getMatrix           (TMatrix* mat);
    
    void            getVariableMatrix   (vector< vector <double> >* mat);
   
    void            parse_matrix         (TMatrix* mat);
    void            parse_variable_matrix         (vector< vector <double> >* mat);
    bool            parseArgument        (string& arg);
    bool           parseTemporalArgument (const string& arg);
    bool           parseAgeSpecArgument  (const string& arg);
    bool           parseSubParamArgument (const string& arg);
    string         checkArgumentForExpansion (string arg);
    string         getArgumentFromFile   (string file);
    
    void            show_up              ();
    
  };
 
 
class ParamSet
  {
    string                  _name;
    bool                    _isSet;
    bool                    _isRequired;
    map<string, Param*>     _params;
    SimComponent*           _myOwner;
    
  public:
    
    ParamSet                             ( ) : _isSet(0), _isRequired(0), _myOwner(0) { }
    ParamSet                             (const ParamSet& PS);
    ~ParamSet                            ( );
    void            reset                ( );
    
    void            clear                ( ) {_params.clear();}
    bool            check_consistency    ( );
    void            show_up              ( );
    void            print                (ofstream& FILE, bool commentOut = false);
    int             size                 ( )                     {return _params.size();}
    map<string, Param*>& getAllParams    ( )                     {return _params;}
 
    void            add_param            (Param* param)         {_params[param->getName()] = param;}
    void            add_param            (string Name, param_t Type, bool mandatory, bool isBounded,
                                          double low_bnd, double up_bnd)
    {add_param(Name, Type, mandatory, isBounded, low_bnd, up_bnd, 0);}
    
    void            add_param            (string Name, param_t Type, bool mandatory, bool isBounded,
                                          double low_bnd, double up_bnd, ParamUpdaterBase* updater);
    bool            set_param            (string Name, string Arg);
    Param*          find_param            (string name);
    Param*          get_param            (string name);
 
    bool            has_param            (string name);
 
    bool            update_param         (string Name, unsigned int generation);
    void            setName              (string value)          {_name = value;}
    void            setIsRequired        (bool value)            {_isRequired = value;}
    void            setOwner             (SimComponent* owner)   {_myOwner = owner;}
    bool            isSet                ()                      {return _isSet;}
    string          getName              ()                      {return _name;}
    bool            isRequired           ()                      {return _isRequired;}
    bool            isSet                (string name)           {return (get_param(name))->isSet();}
    bool            isMatrix             (string name)           {return (get_param(name))->isMatrix();}
    bool            isTemporal           (string name)           {return (get_param(name))->isTemporal();}
    string          getArg               (string name)           {return (get_param(name))->getArg();}
    double          getValue             (string name)           {return (get_param(name))->getValue();}
    void            getMatrix   (string name, TMatrix* mat)      {return (get_param(name))->getMatrix(mat);}
    list<ParamUpdaterBase*> getUpdaters();
    ParamSet&       operator= (const ParamSet& PS);
  };
 
 
//class ParamUpdaterBase
//
class ParamUpdaterBase : public Handler {
  
protected:
  list< Param* > _params;
  
public:
  
  typedef list< Param* >::iterator PIT;
  
public:
  
  ParamUpdaterBase() { }
  
  ParamUpdaterBase (const ParamUpdaterBase& PU)
  {
    _params.assign(PU._params.begin(), PU._params.end());
  }
  
  virtual ~ParamUpdaterBase() {}
  
  virtual void init   () = 0;
  virtual void update () {}
  virtual bool update (unsigned int generation) = 0;
  
  virtual SimComponent* getComponent () = 0;
  virtual void addParam        (Param* param)       {_params.push_back( param );}
  virtual void reset           ( )                  {_params.clear();}
  list< Param* > getParams     ( )                  {return _params;}
  
};
 
 
//class ParamUpdater
//
template <class SC> class ParamUpdater : public virtual ParamUpdaterBase {
  
  bool (SC::*_myUpdaterFunction) (void);
  SC* _myComponent;
  
public:
  
  ParamUpdater(bool (SC::*updateFuncPtr) (void) ): _myComponent(0)
  {
    _myUpdaterFunction = updateFuncPtr;
  }
  
  ParamUpdater (const ParamUpdater< SC >& PU)
  {
    _params.assign(PU._params.begin(), PU._params.end());
    _myUpdaterFunction = PU._myUpdaterFunction;
    _myComponent = PU._myComponent;
  }
  
  virtual ~ParamUpdater ()
  {
    for(PIT pit = _params.begin(); pit != _params.end(); pit++)
      if((*pit)->getUpdater() == this) (*pit)->setUpdater(0);
  }
  
  virtual void init ()
  {
    _myComponent = dynamic_cast<SC*> ( (*_params.begin())->getOwner() );
    
    for(PIT pit = ++_params.begin(); pit != _params.end(); pit++)
      assert(_myComponent == (*pit)->getOwner());
  }
  virtual bool update (unsigned int generation)
  {        
    return ((( dynamic_cast<SC*> (_myComponent))->*_myUpdaterFunction) ());
  }
  void setFuncPtr   ( bool (SC::*updateFuncPtr) (void))
  {
    _myUpdaterFunction = updateFuncPtr;
  }
  virtual SC* getComponent () {return _myComponent;}
};
 
#endif