ParMap.h

// -*- C++ -*-
//
// ParMap.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_ParMap_H
#define ThePEG_ParMap_H
// This is the declaration of the ParMap, ParMapTBase and
// ParMapBase classes.
 
#include "ThePEG/Config/ThePEG.h"
#include "InterfaceBase.h"
#include "ParMap.fh"
#include <limits>
 
namespace ThePEG {
 
namespace {
  template <typename T>
  inline void putUnitImpl2(ostream & os, T v, T u, DimensionT) {
    os << v/u;
  }
  
  template <typename T>
  inline void putUnitImpl2(ostream & os, T v, T u, StandardT) {
    if ( u > T() )
      os << v/u;
    else
      os << v;
  }
}
 
class ParMapBase: public InterfaceBase {
 
public:
 
  typedef map<long,string> StringMap;
 
public:
 
  ParMapBase(string newName, string newDescription,
                string newClassName,
                const type_info & newTypeInfo, int newSize,
                bool depSafe, bool readonly, int limits) 
    : InterfaceBase(newName, newDescription, newClassName, 
                    newTypeInfo, depSafe,
                    readonly), limit(limits), theSize(newSize) {
    hasDefault = false;
  }
 
  virtual ~ParMapBase() {}
 
  virtual string exec(InterfacedBase &, string action,
                      string arguments) const;
 
  virtual string fullDescription(const InterfacedBase & ib) const;
 
  virtual void set(InterfacedBase & ib, string val, int i)
    const = 0;
 
  virtual void insert(InterfacedBase & ib, string val, int i)
    const = 0;
 
  virtual void erase(InterfacedBase & ib, int i)
    const = 0;
 
  virtual void clear(InterfacedBase & ib)
    const = 0;
 
  virtual StringMap get(const InterfacedBase & ib) const
    = 0;
 
  virtual string minimum(const InterfacedBase & ib, int i) const
    = 0;
 
  virtual string maximum(const InterfacedBase & ib, int i) const
    = 0;
 
  virtual string def(const InterfacedBase & ib, int i) const
    = 0;
 
  virtual string def() const = 0;
 
  virtual void setDef(InterfacedBase & ib, int i) 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; }
 
  int size() const { return theSize; }
 
  void setSize(int sz) { theSize = sz; }
 
  void setVariableSize() { theSize = 0; }
 
private:
 
  int limit;
 
  int theSize;
 
};
 
template <typename Type>
class ParMapTBase: public ParMapBase {
 
public:
 
  typedef map<long,Type> TypeMap;
 
public:
 
  ParMapTBase(string newName, string newDescription,
                 string newClassName, const type_info & newTypeInfo,
                 Type newUnit, int newSize, bool depSafe,
                 bool readonly, int limits)
    : ParMapBase(newName, newDescription, newClassName, 
                    newTypeInfo, newSize,
                    depSafe, readonly, limits), theUnit(newUnit) {}
 
 
  virtual ~ParMapTBase() {}
 
  virtual string type() const;
 
  virtual string doxygenType() const;
 
  virtual string fullDescription(const InterfacedBase & ib) const;
 
  virtual void set(InterfacedBase & ib, string val, int i) const
   ;
 
  virtual void tset(InterfacedBase & ib, Type val, int i)
    const = 0;
 
  virtual void insert(InterfacedBase & ib, string val, int i) const
   ;
 
private:
  void setImpl(InterfacedBase & ib, string val, int i, StandardT)
    const;
 
  void setImpl(InterfacedBase & ib, string val, int i, DimensionT) 
    const;
 
  void insertImpl(InterfacedBase & ib, string val, int i, StandardT)
    const;
 
  void insertImpl(InterfacedBase & ib, string val, int i, DimensionT) 
    const;
 
public:
  
  virtual void tinsert(InterfacedBase & ib, Type val, int i)
    const = 0;
 
  virtual StringMap get(const InterfacedBase & ib) const
   ;
 
  virtual TypeMap tget(const InterfacedBase & ib) const
    = 0;
 
  virtual string minimum(const InterfacedBase & ib, int i) const
   ;
 
  virtual Type tminimum(const InterfacedBase & ib, int i) const
    = 0;
 
  virtual string maximum(const InterfacedBase & ib, int i) const
   ;
 
  virtual Type tmaximum(const InterfacedBase & ib, int i) const
    = 0;
 
  virtual string def(const InterfacedBase & ib, int i) const
   ;
 
  virtual Type tdef(const InterfacedBase & ib, int i) const
    = 0;
 
  virtual string def() const;
 
  virtual Type tdef() const = 0;
 
  virtual void setDef(InterfacedBase & ib, int i) const
   ;
 
  Type unit() const { return theUnit; }
 
  void unit(Type u) { theUnit = u; }
 
protected:
 
  void putUnit(ostream & os, Type val) const { 
    putUnitImpl2(os, val, unit(), typename TypeTraits<Type>::DimType());
  }
 
private:
 
  Type theUnit;
 
};
 
template <typename T, typename Type>
class ParMap: public ParMapTBase<Type> {
 
public:
 
  typedef void (T::*SetFn)(Type, int);
 
  typedef void (T::*InsFn)(Type, int);
 
  typedef void (T::*DelFn)(int);
 
  typedef map<long,Type> TypeMap;
 
  typedef TypeMap (T::*GetFn)() const;
 
  typedef map<long,string> StringMap;
 
  typedef StringMap (T::*StringGetFn)() const;
 
  typedef Type (T::*DefFn)(int) const;
 
  typedef TypeMap T::* Member;
 
public:
 
  ParMap(string newName, string newDescription,
                   Member newMember, int newSize, Type newDef, Type newMin,
                   Type newMax, bool depSafe = false, bool readonly = false,
                   bool limits = true, SetFn newSetFn = 0,
                   InsFn newInsFn = 0, DelFn newDelFn = 0, GetFn newGetFn = 0,
                   DefFn newDefFn = 0, DefFn newMinFn = 0, DefFn newMaxFn = 0,
                   StringGetFn newStringGetFn = 0)
    : ParMapTBase<Type>(newName, newDescription, ClassTraits<T>::className(),
                           typeid(T), Type(), newSize, depSafe, readonly,
                           limits),
      theMember(newMember), theDef(newDef), theMin(newMin), theMax(newMax),
      theSetFn(newSetFn), theInsFn(newInsFn), theDelFn(newDelFn),
      theGetFn(newGetFn), theDefFn(newDefFn), theMinFn(newMinFn),
      theMaxFn(newMaxFn), theStringGetFn(newStringGetFn) {}
 
 
  ParMap(string newName, string newDescription, Member newMember,
                   Type newUnit, int newSize, Type newDef, Type newMin,
                   Type newMax, bool depSafe = false, bool readonly = false,
                   bool limits = true, SetFn newSetFn = 0,
                   InsFn newInsFn = 0, DelFn newDelFn = 0, GetFn newGetFn = 0,
                   DefFn newDefFn = 0, DefFn newMinFn = 0, DefFn newMaxFn = 0,
                   StringGetFn newStringGetFn = 0)
    : ParMapTBase<Type>(newName, newDescription, ClassTraits<T>::className(),
                           typeid(T), newUnit, newSize, depSafe, readonly,
                           limits),
      theMember(newMember), theDef(newDef), theMin(newMin), theMax(newMax),
      theSetFn(newSetFn), theInsFn(newInsFn), theDelFn(newDelFn),
      theGetFn(newGetFn), theDefFn(newDefFn), theMinFn(newMinFn),
      theMaxFn(newMaxFn), theStringGetFn(newStringGetFn) {}
 
  ParMap(string newName, string newDescription,
                   Member newMember, int newSize, Type newDef, Type newMin,
                   Type newMax, bool depSafe = false, bool readonly = false,
                   int limits = Interface::limited, SetFn newSetFn = 0,
                   InsFn newInsFn = 0, DelFn newDelFn = 0, GetFn newGetFn = 0,
                   DefFn newDefFn = 0, DefFn newMinFn = 0, DefFn newMaxFn = 0,
                   StringGetFn newStringGetFn = 0)
    : ParMapTBase<Type>(newName, newDescription, ClassTraits<T>::className(),
                           typeid(T), Type(), newSize, depSafe, readonly,
                           limits),
      theMember(newMember), theDef(newDef), theMin(newMin), theMax(newMax),
      theSetFn(newSetFn), theInsFn(newInsFn), theDelFn(newDelFn),
      theGetFn(newGetFn), theDefFn(newDefFn), theMinFn(newMinFn),
      theMaxFn(newMaxFn), theStringGetFn(newStringGetFn) {}
 
  ParMap(string newName, string newDescription, Member newMember,
                   Type newUnit, int newSize, Type newDef, Type newMin,
                   Type newMax, bool depSafe = false, bool readonly = false,
                   int limits = Interface::limited, SetFn newSetFn = 0,
                   InsFn newInsFn = 0, DelFn newDelFn = 0, GetFn newGetFn = 0,
                   DefFn newDefFn = 0, DefFn newMinFn = 0, DefFn newMaxFn = 0,
                   StringGetFn newStringGetFn = 0)
    : ParMapTBase<Type>(newName, newDescription, ClassTraits<T>::className(),
                           typeid(T), newUnit, newSize, depSafe, readonly,
                           limits),
      theMember(newMember), theDef(newDef), theMin(newMin), theMax(newMax),
      theSetFn(newSetFn), theInsFn(newInsFn), theDelFn(newDelFn),
      theGetFn(newGetFn), theDefFn(newDefFn), theMinFn(newMinFn),
      theMaxFn(newMaxFn), theStringGetFn(newStringGetFn) {}
 
  virtual void tset(InterfacedBase & ib, Type val, int i) const
   ;
 
  virtual void tinsert(InterfacedBase & ib, Type val, int i) const
   ;
 
  virtual void erase(InterfacedBase & ib, int i)
    const;
 
  virtual void clear(InterfacedBase & ib)
    const;
 
  virtual StringMap get(const InterfacedBase & ib) const
   ;
 
  virtual TypeMap tget(const InterfacedBase & ib) const
   ;
 
  virtual Type tminimum(const InterfacedBase & ib, int i) const
   ;
 
  virtual Type tmaximum(const InterfacedBase & ib, int i) const
   ;
 
  virtual Type tdef(const InterfacedBase &, int) const
   ;
 
  virtual Type tdef() const;
 
  void setSetFunction(SetFn sf) { theSetFn = sf; }
 
  void setInsertFunction(InsFn ifn) { theInsFn = ifn; }
 
  void setGetFunction(GetFn gf) { theGetFn = gf; }
 
  void setEraseFunction(DelFn df) { theDelFn = df; }
 
  void setDefaultFunction(GetFn df) { theDefFn = df; }
 
  void setMinFunction(GetFn mf) { theMinFn = mf; }
 
  void setMaxFunction(GetFn mf) { theMaxFn = mf; }
 
  void setStringGetFunction(StringGetFn gf) { theStringGetFn = gf; }
 
  virtual void doxygenDescription(ostream & stream) const;
 
private:
 
  Member theMember;
 
  Type theDef;
 
  Type theMin;
 
  Type theMax;
 
  SetFn theSetFn;
 
  InsFn theInsFn;
 
  DelFn theDelFn;
 
  GetFn theGetFn;
 
  DefFn theDefFn;
 
  DefFn theMinFn;
 
  DefFn theMaxFn;
 
  StringGetFn theStringGetFn;
 
};
 
}
 
#ifndef ThePEG_TEMPLATES_IN_CC_FILE
#include "ParMap.tcc"
#endif
 
#endif /* ThePEG_ParMap_H */