HandlerGroup.h

// -*- C++ -*-
//
// HandlerGroup.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2007 Leif Lonnblad
//
// ThePEG is licenced under version 2 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 &);
  
};

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> &);
  
};

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

---