Switch.h

// -*- C++ -*-
//
// Switch.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_Switch_H
#define ThePEG_Switch_H
// This is the declaration of the Switch, SwitchBase and SwitchOption classes.
 
#include "ThePEG/Config/ThePEG.h"
#include "Switch.fh"
#include "Switch.xh"
#include "InterfaceBase.h"
 
namespace ThePEG {
 
class SwitchOption: public Named {
 
public:
 
  template<typename EnumT> 
  SwitchOption(SwitchBase & theSwitch, string newName,
               string newDescription, EnumT newValue);
 
  SwitchOption() : theValue(-999) {}
 
  const string & description() const { return theDescription; }
 
  long value() const { return theValue; }
 
  operator long () const;
 
protected:
 
private:
 
  string theDescription;
 
  long theValue;
 
};
 
class SwitchBase: public InterfaceBase {
 
public:
 
  typedef map<long, SwitchOption> OptionMap;
  typedef map<string, SwitchOption> StringMap;
 
  friend class SwitchOption;
 
public:
 
  SwitchBase(string newName, string newDescription,
             string newClassName, const type_info & newTypeInfo,
             bool depSafe, bool readonly)
    : InterfaceBase(newName, newDescription, newClassName, 
                    newTypeInfo, depSafe, readonly) {}
 
  virtual string exec(InterfacedBase & ib, string action,
                    string arguments) const;
 
  virtual string fullDescription(const InterfacedBase & ib) const;
 
  virtual string type() const;
 
  virtual void set(InterfacedBase & ib, long val)
    const = 0;
 
  virtual long get(const InterfacedBase & ib)
    const = 0;
 
  virtual long def(const InterfacedBase & ib)
    const = 0;
 
  void setDef(InterfacedBase & i) const {
    set(i, def(i));
  }
 
  bool check(long newValue) const { return member(theOptions, newValue); }
 
  const OptionMap & options() const { return theOptions; }
 
  virtual string doxygenType() const;
 
  string opttag(long opt) const;
 
protected:
 
  void registerOption(const SwitchOption & o) {
    theOptions[o.value()] = o;
    theOptionNames[o.name()] = o;
  }
 
private:
 
  OptionMap theOptions;
 
  StringMap theOptionNames;
 
};
 
template <typename T, typename Int>
class Switch: public SwitchBase {
 
public:
 
  typedef void (T::*SetFn)(Int);
  typedef Int (T::*GetFn)() const;
 
  typedef Int T::* Member;
 
public:
 
  Switch(string newName, string newDescription,
         Member newMember, Int newDef, bool depSafe = false,
         bool readonly = false, SetFn newSetFn = 0, GetFn newGetFn = 0,
         GetFn newDefFn = 0)
    : SwitchBase(newName, newDescription, ClassTraits<T>::className(),
                 typeid(T), depSafe, readonly),
      theMember(newMember), theDef(newDef), theSetFn(newSetFn),
      theGetFn(newGetFn), theDefFn(newDefFn) {}
  
  virtual void set(InterfacedBase & ib, long val) const
   ;
 
  virtual long get(const InterfacedBase & ib) const;
 
  virtual long def(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;
 
  Int theDef;
 
  SetFn theSetFn;
 
  GetFn theGetFn;  
 
  GetFn theDefFn;  
 
};
 
}
 
#ifndef ThePEG_TEMPLATES_IN_CC_FILE
#include "Switch.tcc"
#endif
 
#endif /* ThePEG_Switch_H */