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 */