HandlerGroup.h

// -*- C++ -*-
//
// HandlerGroup.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_HandlerGroup_H
#define ThePEG_HandlerGroup_H
// This is the declaration of the HandlerGroup class.
 
#include "ThePEG/Config/ThePEG.h"
// #include "HandlerGroup.fh"
// #include "HandlerGroup.xh"
 
namespace ThePEG {
 
class HandlerGroupBase {
 
public:
 
  typedef pair<StepHdlPtr, HintPtr> StepWithHint;
 
  typedef vector<StepHdlPtr> StepVector;
 
  typedef vector<StepWithHint> StepHintVector;
 
  typedef deque<HintPtr> HintVector;
 
public:
 
  HandlerGroupBase();
 
  virtual ~HandlerGroupBase();
 
  bool empty() const { return isEmpty; }
 
  void init(const HandlerGroupBase & ext) {
    clear();
    refillDefaults(ext);
  }
 
  StepWithHint next();
 
  void addPreHandler(tStepHdlPtr sh, tHintPtr hint,
                     const HandlerGroupBase & ext);
 
  void addPostHandler(tStepHdlPtr sh, tHintPtr hint,
                      const HandlerGroupBase &);
 
  void addHint(tHintPtr hint, const HandlerGroupBase & ext);
 
  StepVector & preHandlers() { return theDefaultPreHandlers; }
 
  const StepVector & preHandlers() const { return theDefaultPreHandlers; }
 
  virtual tStepHdlPtr defaultHandler() const = 0;
 
  StepVector & postHandlers() { return theDefaultPostHandlers; }
 
  const StepVector & postHandlers() const { return theDefaultPostHandlers; }
 
  virtual tStepHdlPtr handler() const = 0;
 
  virtual void setHandler() = 0;
 
  virtual bool setHandler(tStepHdlPtr, const HandlerGroupBase & ext) = 0;
 
  virtual void refillDefaultHandler(tStepHdlPtr) = 0;
 
  void refillDefaults(const HandlerGroupBase &);
 
  virtual void clear();
 
  virtual string handlerClass() const = 0;
 
  void interfaceSetPrehandler(StepHdlPtr p, int i);
 
  void interfaceInsertPrehandler(StepHdlPtr p, int i);
 
  void interfaceErasePrehandler(int i);
 
  vector<StepHdlPtr> interfaceGetPrehandlers() const;
 
  void interfaceSetPosthandler(StepHdlPtr p, int i);
 
  void interfaceInsertPosthandler(StepHdlPtr p, int i);
 
  void interfaceErasePosthandler(int i);
 
  vector<StepHdlPtr> interfaceGetPosthandlers() const;
 
  virtual void write(PersistentOStream &) const;
 
  virtual void read(PersistentIStream &);
 
protected:
 
  HandlerGroupBase(const HandlerGroupBase &);
 
  bool isEmpty;
 
private:
 
  void checkInsert(StepHintVector & current, const StepVector & def);
 
protected:
 
  StepVector theDefaultPreHandlers;
 
  StepVector theDefaultPostHandlers;
 
  StepHintVector thePreHandlers;
 
  HintVector theHints;
 
  StepHintVector thePostHandlers;
 
private:
 
  HandlerGroupBase & operator=(const HandlerGroupBase &) = delete;
  
};
 
template <typename HDLR>
class HandlerGroup: public HandlerGroupBase {
 
public:
 
  typedef typename Ptr<HDLR>::pointer HdlPtr;
 
  typedef typename Ptr<HDLR>::transient_pointer tHdlPtr;
 
public:
 
  virtual ~HandlerGroup();
 
  virtual bool setHandler(tStepHdlPtr, const HandlerGroupBase & ext);
 
  virtual void setHandler() { theHandler = HdlPtr(); }
 
  virtual tStepHdlPtr handler() const {
    return dynamic_ptr_cast<tStepHdlPtr>(theHandler);
  }
 
  virtual tStepHdlPtr defaultHandler() const {
    return dynamic_ptr_cast<tStepHdlPtr>(theDefaultHandler);
  }
 
  virtual void refillDefaultHandler(tStepHdlPtr);
 
  virtual void clear();
 
  virtual string handlerClass() const;
 
  void interfaceSetHandler(HdlPtr);
 
  HdlPtr interfaceGetHandler() const;
 
  virtual void write(PersistentOStream & os) const {
    os << theDefaultHandler << theHandler;
    HandlerGroupBase::write(os);
  }
 
  virtual void read(PersistentIStream & is) {
    is >> theDefaultHandler >> theHandler;
    HandlerGroupBase::read(is);
  }
 
private:
 
 
  HdlPtr theDefaultHandler;
 
  HdlPtr theHandler;
 
private:
 
  HandlerGroup<HDLR> & operator=(const HandlerGroup<HDLR> &) = delete;
  
};
 
namespace Group {
 
enum Handler {
  subproc, 
  cascade, 
  multi,   
  hadron,  
  decay    
};
 
enum Level {
  before, 
  main,   
  after   
};
}
 
template <typename HDLR>
inline PersistentOStream & operator<<(PersistentOStream & os,
                                      const HandlerGroup<HDLR> & hg) {
  hg.write(os);
  return os;
}
 
template <typename HDLR>
inline PersistentIStream & operator>>(PersistentIStream & is,
                                      HandlerGroup<HDLR> & hg) {
  hg.read(is);
  return is;
}
 
}
 
#define ThePEG_DECLARE_PREPOST_GROUP(HandlerClass,prepost)                    \
                                    \
void interfaceSet##prepost##HandlerClass(StepHdlPtr, int);                    \
                                    \
void interfaceInsert##prepost##HandlerClass(StepHdlPtr, int);                 \
                                    \
void interfaceErase##prepost##HandlerClass(int);                              \
                                    \
vector<StepHdlPtr> interfaceGet##prepost##HandlerClass() const
 
#define ThePEG_DECLARE_GROUPINTERFACE(HandlerClass,ptr)                       \
ThePEG_DECLARE_PREPOST_GROUP(HandlerClass,Pre);                               \
                                    \
void interfaceSet##HandlerClass(ptr);                                         \
                                    \
ptr interfaceGet##HandlerClass() const;                                       \
ThePEG_DECLARE_PREPOST_GROUP(HandlerClass,Post)
 
#define ThePEG_IMPLEMENT_PREPOST_GROUP(ThisClass,HandlerClass,member,pp)      \
void ThisClass::interfaceSet##pp##HandlerClass(StepHdlPtr p , int i) {     \
  member.interfaceSet##pp##handler(p,i);                                     \
}                                                                              \
void ThisClass::interfaceInsert##pp##HandlerClass(StepHdlPtr p, int i) {   \
  member.interfaceInsert##pp##handler(p,i);                                  \
}                                                                              \
void ThisClass::interfaceErase##pp##HandlerClass(int i) {                  \
  member.interfaceErase##pp##handler(i);                                     \
}                                                                              \
vector<StepHdlPtr> ThisClass::interfaceGet##pp##HandlerClass() const {     \
  return member.interfaceGet##pp##handlers();                                  \
}
 
#define ThePEG_IMPLEMENT_GROUPINTERFACE(ThisClass,HandlerClass,member,ptr)     \
ThePEG_IMPLEMENT_PREPOST_GROUP(ThisClass,HandlerClass,member,Pre)              \
void ThisClass::interfaceSet##HandlerClass(ptr p) {                            \
  member.interfaceSetHandler(p);                                               \
}                                                                              \
ptr ThisClass::interfaceGet##HandlerClass() const {                            \
  return member.interfaceGetHandler();                                         \
}                                                                              \
ThePEG_IMPLEMENT_PREPOST_GROUP(ThisClass,HandlerClass,member,Post)             \
 
#define ThePEG_DECLARE_PREPOST_OBJECTS(ThisClass,HandlerClass,pp,ba)           \
static RefVector<ThisClass,StepHandler> interface##pp##HandlerClass            \
(#pp #HandlerClass "s",                                                        \
 "A list of handlers to be called " #ba " the " #HandlerClass ". "             \
 "If handler objects are specified in a EventHandler and "                     \
 "the SubProcessHandler chosen in a given collision also specifies some, "     \
 "the latter will caled first.",                                               \
 0, 0, false, false, true, false,                                              \
 &ThisClass::interfaceSet##pp##HandlerClass,                                   \
 &ThisClass::interfaceInsert##pp##HandlerClass,                                \
 &ThisClass::interfaceErase##pp##HandlerClass,                                 \
 &ThisClass::interfaceGet##pp##HandlerClass)
 
#define ThePEG_DECLARE_GROUPINTERFACE_OBJECTS(ThisClass,HandlerClass)          \
ThePEG_DECLARE_PREPOST_OBJECTS(ThisClass,HandlerClass,Pre, before);            \
static Reference<ThisClass,HandlerClass> interface ## HandlerClass             \
(#HandlerClass,                                                                \
 "The " #HandlerClass " object used in this " #ThisClass ". "                  \
 "If a " #HandlerClass " object is specified in a EventHandler and "           \
 "the SubProcessHandler chosen in a given collision also specifies one,"       \
 "the latter will be used.",                                                   \
 0, false, false, true, true,                                                  \
 &ThisClass::interfaceSet ## HandlerClass,                                     \
 &ThisClass::interfaceGet ## HandlerClass);                                    \
ThePEG_DECLARE_PREPOST_OBJECTS(ThisClass,HandlerClass,Post, after)
 
#ifndef ThePEG_TEMPLATES_IN_CC_FILE
#include "HandlerGroup.tcc"
#endif
 
#endif /* ThePEG_HandlerGroup_H */