Parameter.h

// -*- C++ -*-
//
// Parameter.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2019 Leif Lonnblad
//
// ThePEG is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef ThePEG_Parameter_H
#define ThePEG_Parameter_H
// This is the declaration of the Parameter, ParameterTBase and
// ParameterBase classes.
 
 
#include "ThePEG/Config/ThePEG.h"
#include "ThePEG/Utilities/Throw.h"
#include "InterfaceBase.h"
#include "Parameter.xh"
#include "Parameter.fh"
#include "ThePEG/Utilities/StringUtils.h"
#include <limits>
 
namespace ThePEG {
 
namespace {
  template <typename T>
  inline void putUnitImpl(ostream & os, T v, T u, DimensionT) {
    os << v/u;
  }
  
  template <typename T>
  inline void putUnitImpl(ostream & os, T v, T u, StandardT) {
    if ( u > T() )
      os << v/u;
    else
      os << v;
  }
 
  template <typename T>
  inline void putUnitImpl(ostream & os, T v, T, EnumT) {
    os << v;
  }
}
 
 
namespace {
 
template<typename T, typename U>
U umult(const T & t, const U & u) {
  return t*u;
}
 
template <typename U>
bool umult(bool b, U) {
  return b;
}
}
 
class ParameterBase: public InterfaceBase {
 
public:
 
  ParameterBase(string newName, string newDescription,
                string newClassName,
                const type_info & newTypeInfo, bool depSafe,
                bool readonly, int limits)
    : InterfaceBase(newName, newDescription, 
                    newClassName, newTypeInfo, depSafe,
                    readonly), limit(limits) {}
 
  virtual ~ParameterBase();
 
  virtual string exec(InterfacedBase & ib, string action,
                      string arguments) const;
 
  virtual string fullDescription(const InterfacedBase & ib) const;
 
  virtual void set(InterfacedBase & ib, string) const
    = 0;
 
  virtual string minimum(const InterfacedBase & ib) const
    = 0;
 
  virtual string maximum(const InterfacedBase & ib) const
    = 0;
 
  virtual string get(const InterfacedBase & ib) const
    = 0;
 
  virtual string def(const InterfacedBase & ib) const
    = 0;
 
  virtual void setDef(InterfacedBase & ib) const
    = 0;
 
  bool limited() const { return limit != Interface::nolimits; }
 
  bool upperLimit() const { 
    return limit == Interface::limited || limit == Interface::upperlim;
  }
 
  bool lowerLimit() const {
    return limit == Interface::limited || limit == Interface::lowerlim;
  }
 
  void setLimited() { limit = Interface::limited; }
 
  void setUnlimited() { limit = Interface::nolimits; }
 
private:
 
  int limit;
 
};
 
template <typename Type>
class ParameterTBase: public ParameterBase {
 
public:
 
  ParameterTBase(string newName, string newDescription,
                 string newClassName,
                 const type_info & newTypeInfo, Type newUnit,
                 bool depSafe, bool readonly, int limits) 
    : ParameterBase(newName, newDescription, 
                    newClassName, newTypeInfo, depSafe,
                    readonly, limits), theUnit(newUnit) {}
 
  virtual ~ParameterTBase() {}
 
  virtual string type() const;
 
private:
 
  void setImpl (InterfacedBase & i, 
                       string newValue, StandardT) 
    const;
 
  void setImpl (InterfacedBase & i, 
                       string newValue, DimensionT) 
    const;
 
  void setImpl (InterfacedBase & i, 
                       string newValue, EnumT) 
    const;
 
public:
 
  virtual void set(InterfacedBase & ib, string newValue)
    const;
 
  virtual void tset(InterfacedBase & ib, Type) const
    = 0;
 
  virtual string get(const InterfacedBase & ib) const
   ;
 
  virtual Type tget(const InterfacedBase & ib) const
    = 0;
 
  virtual string minimum(const InterfacedBase & ib) const
   ;
 
  virtual Type tminimum(const InterfacedBase & ib) const
    = 0;
 
  virtual string maximum(const InterfacedBase & ib) const
   ;
 
  virtual Type tmaximum(const InterfacedBase & ib) const
    = 0;
 
  virtual string def(const InterfacedBase & ib) const
   ;
 
  virtual Type tdef(const InterfacedBase &ib) const
    = 0;
 
  virtual void setDef(InterfacedBase & ib) const {
    tset(ib, tdef(ib));
  }
 
  Type unit() const { return theUnit; }
 
  void unit(Type u) { theUnit = u; }
 
  virtual string doxygenType() const;
 
protected:
 
  void putUnit(ostream & os, Type val) const {
    putUnitImpl(os, val, unit(), typename TypeTraits<Type>::DimType());
  }
 
private:
 
  Type theUnit;
 
  void checkUnitConsistency(string suffix) const;
 
};
 
template <typename T, typename Type>
class Parameter: public ParameterTBase<Type> {
 
public:
 
  typedef void (T::*SetFn)(Type);
  typedef Type (T::*GetFn)() const;
 
  typedef Type T::* Member;
 
public:
 
  Parameter(string newName, string newDescription,
                   Member newMember, Type newDef, Type newMin,
                   Type newMax, bool depSafe = false, bool readonly = false,
                   bool limits = true, SetFn newSetFn = 0,
                   GetFn newGetFn = 0, GetFn newMinFn = 0,
                   GetFn newMaxFn = 0, GetFn newDefFn = 0)
  : ParameterTBase<Type>(newName, newDescription, ClassTraits<T>::className(),
                         typeid(T), Type(), depSafe, readonly, limits),
    theMember(newMember), theDef(newDef), theMin(newMin), theMax(newMax),
    theSetFn(newSetFn), theGetFn(newGetFn), theDefFn(newDefFn),
    theMinFn(newMinFn), theMaxFn(newMaxFn) {}
 
  Parameter(string newName, string newDescription,
                   Member newMember, Type newUnit, Type newDef, Type newMin,
                   Type newMax, bool depSafe = false, bool readonly = false,
                   bool limits = true, SetFn newSetFn = 0,
                   GetFn newGetFn = 0, GetFn newMinFn = 0,
                   GetFn newMaxFn = 0, GetFn newDefFn = 0)
  : ParameterTBase<Type>(newName, newDescription, ClassTraits<T>::className(),
                         typeid(T), newUnit, depSafe, readonly, limits),
    theMember(newMember), theDef(newDef), theMin(newMin), theMax(newMax),
    theSetFn(newSetFn), theGetFn(newGetFn), theDefFn(newDefFn),
    theMinFn(newMinFn), theMaxFn(newMaxFn) {}
 
  Parameter(string newName, string newDescription,
                   Member newMember, Type newDef, Type newMin,
                   Type newMax, bool depSafe = false, bool readonly = false,
                   int limits = Interface::limited, SetFn newSetFn = 0,
                   GetFn newGetFn = 0, GetFn newMinFn = 0,
                   GetFn newMaxFn = 0, GetFn newDefFn = 0)
  : ParameterTBase<Type>(newName, newDescription, ClassTraits<T>::className(),
                         typeid(T), Type(), depSafe, readonly, limits),
    theMember(newMember), theDef(newDef), theMin(newMin), theMax(newMax),
    theSetFn(newSetFn), theGetFn(newGetFn), theDefFn(newDefFn),
    theMinFn(newMinFn), theMaxFn(newMaxFn) {}
 
  Parameter(string newName, string newDescription,
                   Member newMember, Type newUnit, Type newDef, Type newMin,
                   Type newMax, bool depSafe = false, bool readonly = false,
                   int limits = Interface::limited, SetFn newSetFn = 0,
                   GetFn newGetFn = 0, GetFn newMinFn = 0,
                   GetFn newMaxFn = 0, GetFn newDefFn = 0)
  : ParameterTBase<Type>(newName, newDescription, ClassTraits<T>::className(),
                         typeid(T), newUnit, depSafe, readonly, limits),
    theMember(newMember), theDef(newDef), theMin(newMin), theMax(newMax),
    theSetFn(newSetFn), theGetFn(newGetFn), theDefFn(newDefFn),
    theMinFn(newMinFn), theMaxFn(newMaxFn) {}
 
  virtual ~Parameter() {}
 
  virtual void tset(InterfacedBase & ib, Type val)
    const;
 
  virtual Type tget(const InterfacedBase & ib) const;
 
  virtual Type tminimum(const InterfacedBase & ib) const
   ;
 
  virtual Type tmaximum(const InterfacedBase & ib) const
   ;
 
  virtual Type tdef(const InterfacedBase & ib) const
   ;
 
  void setSetFunction(SetFn sf) { theSetFn = sf; }
 
  void setGetFunction(GetFn gf) { theGetFn = gf; }
 
  void setDefaultFunction(GetFn df) { theDefFn = df; }
 
  void setMinFunction(GetFn mf) { theMinFn = mf; }
 
  void setMaxFunction(GetFn mf) { theMaxFn = mf; }
 
  virtual void doxygenDescription(ostream & stream) const;
 
private:
 
  Member theMember;
 
  Type theDef;
 
  Type theMin;
 
  Type theMax;
 
  SetFn theSetFn;
 
  GetFn theGetFn;
 
  GetFn theDefFn;
 
  GetFn theMinFn;
 
  GetFn theMaxFn;
 
};
 
template <>
class ParameterTBase<string>: public ParameterBase {
 
public:
 
  enum FileType {
    NoFile,    
    File,      
    Directory  
  };
 
public:
 
  ParameterTBase(string newName, string newDescription,
                 string newClassName,
                 const type_info & newTypeInfo,
                 bool depSafe, bool readonly)
    : ParameterBase(newName, newDescription, 
                    newClassName, newTypeInfo, depSafe,
                    readonly, false), isFileType(NoFile) {
    hasDefault = false;
  }
 
  virtual ~ParameterTBase() {}
 
  virtual string type() const {
    switch ( file() ) {
    case File: return "PF";
    case Directory: return "PD";
    default: return "Ps";
    }
  }
 
  void fileType() { file(File); }
 
  void directoryType() { file(Directory); }
 
  void file(FileType t) { isFileType = t; }
 
  FileType file() const { return isFileType; }
 
  virtual void set(InterfacedBase & ib, string newValue)
    const {
    tset(ib, StringUtils::stripws(newValue));
  }
 
  virtual void tset(InterfacedBase & ib, string) const
    = 0;
 
  virtual string get(const InterfacedBase & ib) const
    {
    return tget(ib);
  }
 
  virtual string tget(const InterfacedBase & ib) const
    = 0;
 
  virtual string minimum(const InterfacedBase &) const {
    return "";
  }
 
  virtual string maximum(const InterfacedBase &) const {
    return "";
  }
 
  virtual string def(const InterfacedBase & ib) const
    {
    return tdef(ib);
  }
 
  virtual string tdef(const InterfacedBase &ib) const
    = 0;
 
  virtual void setDef(InterfacedBase & i) const {
    tset(i, tdef(i));
  }
 
  virtual string doxygenType() const { return "Character string parameter"; }
 
private:
 
  FileType isFileType;
 
};
 
template <typename T>
class Parameter<T,string>: public ParameterTBase<string> {
 
public:
 
  typedef void (T::*SetFn)(string);
  typedef string (T::*GetFn)() const;
 
  typedef string T::* Member;
 
public:
 
  Parameter(string newName, string newDescription,
                   Member newMember, string newDef,
                   bool depSafe = false, bool readonly = false,
                   SetFn newSetFn = 0, GetFn newGetFn = 0, GetFn newDefFn = 0)
    : ParameterTBase<string>(newName, newDescription,
                             ClassTraits<T>::className(),
                         typeid(T), depSafe, readonly),
    theMember(newMember), theDef(newDef),
    theSetFn(newSetFn), theGetFn(newGetFn), theDefFn(newDefFn) {}
 
 
  virtual ~Parameter() {}
 
  virtual void tset(InterfacedBase & ib, string val)
    const;
 
  virtual string tget(const InterfacedBase & ib) const
   ;
 
  virtual string tdef(const InterfacedBase & ib) const
   ;
 
  void setSetFunction(SetFn sf) { theSetFn = sf; }
 
  void setGetFunction(GetFn gf) { theGetFn = gf; }
 
  void setDefaultFunction(GetFn df) { theDefFn = df; }
 
  virtual void doxygenDescription(ostream & stream) const;
 
private:
 
  Member theMember;
 
  string theDef;
 
  SetFn theSetFn;
 
  GetFn theGetFn;
 
  GetFn theDefFn;
 
};
 
}
 
#ifndef ThePEG_TEMPLATES_IN_CC_FILE
#include "Parameter.tcc"
#endif
 
#endif /* ThePEG_Parameter_H */