parameter.h

Go to the documentation of this file.

#ifndef PARAMETER_H
#define PARAMETER_H
#include <map>
#include <string>
#include "task.h"
//---------------------------------------------------------------------------------------------------------------------
class Parameter;
typedef PtrWrapper<Parameter> WParameter;
typedef std::map<std::string,WParameter> PARAMETERMAP;

class Parameter {
 public:
  Parameter () {};
  virtual ~Parameter () {};
  

  virtual std::string Rebuild (std::istream& in) = 0;
  friend bool operator< (const Parameter& left, const Parameter& right) {return true; };
};

template<class TYPE>
class ParameterValue : public Parameter {
 private:
  TYPE* pValue;
  TYPE Default;
 public:
  ParameterValue (TYPE* _pValue, TYPE _Default) : pValue(_pValue) {SetDefault(_Default);};
  virtual ~ParameterValue () {};
  void SetDefault (TYPE _Default) { 
    Default = _Default;
    *pValue = Default; 
  };
  virtual std::string Rebuild (std::istream& in);
};
template<class TYPE>
std::string ParameterValue<TYPE>::Rebuild (std::istream& in) {
  in >> *pValue;
  std::string strToken;
  in >> strToken;
  return strToken;
}

template<class TYPE>
class ParameterTask_BASE : public Parameter {
 protected:
  Task* pParent;
 public:
  ParameterTask_BASE (Task* _pParent) : pParent(_pParent) {}
  virtual ~ParameterTask_BASE () {}
  
  virtual std::string Rebuild (std::istream& in);
  virtual TYPE* New ()=0;
};

template<class TYPE>
 std::string ParameterTask_BASE<TYPE>::Rebuild (std::istream& in) {
 // Insert in the list of sub task of parent tasks
 TYPE *pTask = New();
 pParent->AttachTask(pTask);
 // Rebuild task from file
 std::string strToken;
 in >> strToken;
 if ((strToken != "{") || in.eof()) return strToken;
 return pTask->Rebuild(in);
}

template<class TYPE>
class ParameterTask : public ParameterTask_BASE<TYPE> {
 public:
  ParameterTask (Task* _pParent) : ParameterTask_BASE<TYPE>(_pParent) {}
  virtual ~ParameterTask () {}
  virtual TYPE* New () { return new TYPE(); }
};

template<class TYPE, class OBJECT>
class DiagnosticTask : public ParameterTask_BASE<TYPE> {
 private:
  OBJECT* pDiagObj;
 public:
  DiagnosticTask (Task* _pParent, OBJECT * _pDiagObj) : 
  ParameterTask_BASE<TYPE>(_pParent), pDiagObj(_pDiagObj) {};
  virtual ~DiagnosticTask () {};
  
  virtual TYPE* New () {return new TYPE(pDiagObj);};
};
#endif // PARAMETER_H