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