ThePEG  1.8.0
HandlerGroup.h
1 // -*- C++ -*-
2 //
3 // HandlerGroup.h is a part of ThePEG - Toolkit for HEP Event Generation
4 // Copyright (C) 1999-2011 Leif Lonnblad
5 //
6 // ThePEG is licenced under version 2 of the GPL, see COPYING for details.
7 // Please respect the MCnet academic guidelines, see GUIDELINES for details.
8 //
9 #ifndef ThePEG_HandlerGroup_H
10 #define ThePEG_HandlerGroup_H
11 // This is the declaration of the HandlerGroup class.
12 
13 #include "ThePEG/Config/ThePEG.h"
14 // #include "HandlerGroup.fh"
15 // #include "HandlerGroup.xh"
16 
17 namespace ThePEG {
18 
45 
46 public:
47 
49  typedef pair<StepHdlPtr, HintPtr> StepWithHint;
50 
52  typedef vector<StepHdlPtr> StepVector;
53 
55  typedef vector<StepWithHint> StepHintVector;
56 
58  typedef deque<HintPtr> HintVector;
59 
60 public:
61 
66 
70  virtual ~HandlerGroupBase();
71 
75  bool empty() const { return isEmpty; }
76 
82  void init(const HandlerGroupBase & ext) {
83  clear();
84  refillDefaults(ext);
85  }
86 
91 
98  void addPreHandler(tStepHdlPtr sh, tHintPtr hint,
99  const HandlerGroupBase & ext);
100 
107  void addPostHandler(tStepHdlPtr sh, tHintPtr hint,
108  const HandlerGroupBase &);
109 
115  void addHint(tHintPtr hint, const HandlerGroupBase & ext);
116 
121 
125  const StepVector & preHandlers() const { return theDefaultPreHandlers; }
126 
130  virtual tStepHdlPtr defaultHandler() const = 0;
131 
136 
140  const StepVector & postHandlers() const { return theDefaultPostHandlers; }
141 
145  virtual tStepHdlPtr handler() const = 0;
146 
150  virtual void setHandler() = 0;
151 
156  virtual bool setHandler(tStepHdlPtr, const HandlerGroupBase & ext) = 0;
157 
162  virtual void refillDefaultHandler(tStepHdlPtr) = 0;
163 
168  void refillDefaults(const HandlerGroupBase &);
169 
173  virtual void clear();
174 
178  virtual string handlerClass() const = 0;
179 
183  void interfaceSetPrehandler(StepHdlPtr p, int i);
184 
188  void interfaceInsertPrehandler(StepHdlPtr p, int i);
189 
193  void interfaceErasePrehandler(int i);
194 
198  vector<StepHdlPtr> interfaceGetPrehandlers() const;
199 
203  void interfaceSetPosthandler(StepHdlPtr p, int i);
204 
208  void interfaceInsertPosthandler(StepHdlPtr p, int i);
209 
213  void interfaceErasePosthandler(int i);
214 
218  vector<StepHdlPtr> interfaceGetPosthandlers() const;
219 
223  virtual void write(PersistentOStream &) const;
224 
228  virtual void read(PersistentIStream &);
229 
230 protected:
231 
236 
240  bool isEmpty;
241 
242 private:
243 
248  void checkInsert(StepHintVector & current, const StepVector & def);
249 
250 protected:
251 
256 
261 
266 
271 
276 
277 private:
278 
283 
284 };
285 
320 template <typename HDLR>
322 
323 public:
324 
326  typedef typename Ptr<HDLR>::pointer HdlPtr;
327 
330 
331 public:
332 
336  virtual ~HandlerGroup();
337 
342  virtual bool setHandler(tStepHdlPtr, const HandlerGroupBase & ext);
343 
347  virtual void setHandler() { theHandler = HdlPtr(); }
348 
352  virtual tStepHdlPtr handler() const {
354  }
355 
359  virtual tStepHdlPtr defaultHandler() const {
361  }
362 
367  virtual void refillDefaultHandler(tStepHdlPtr);
368 
372  virtual void clear();
373 
377  virtual string handlerClass() const;
378 
383 
387  HdlPtr interfaceGetHandler() const;
388 
392  virtual void write(PersistentOStream & os) const {
393  os << theDefaultHandler << theHandler;
395  }
396 
400  virtual void read(PersistentIStream & is) {
401  is >> theDefaultHandler >> theHandler;
403  }
404 
405 private:
406 
407 
412 
417 
418 private:
419 
424 
425 };
426 
428 namespace Group {
429 
433 enum Handler {
439 };
440 
442 enum Level {
446 };
447 }
448 
450 template <typename HDLR>
452  const HandlerGroup<HDLR> & hg) {
453  hg.write(os);
454  return os;
455 }
456 
458 template <typename HDLR>
460  HandlerGroup<HDLR> & hg) {
461  hg.read(is);
462  return is;
463 }
464 
465 }
466 
468 #define ThePEG_DECLARE_PREPOST_GROUP(HandlerClass,prepost) \
469  \
470 void interfaceSet##prepost##HandlerClass(StepHdlPtr, int); \
471  \
472 void interfaceInsert##prepost##HandlerClass(StepHdlPtr, int); \
473  \
474 void interfaceErase##prepost##HandlerClass(int); \
475  \
476 vector<StepHdlPtr> interfaceGet##prepost##HandlerClass() const
477 
479 #define ThePEG_DECLARE_GROUPINTERFACE(HandlerClass,ptr) \
480 ThePEG_DECLARE_PREPOST_GROUP(HandlerClass,Pre); \
481  \
482 void interfaceSet##HandlerClass(ptr); \
483  \
484 ptr interfaceGet##HandlerClass() const; \
485 ThePEG_DECLARE_PREPOST_GROUP(HandlerClass,Post)
486 
488 #define ThePEG_IMPLEMENT_PREPOST_GROUP(ThisClass,HandlerClass,member,pp) \
489 void ThisClass::interfaceSet##pp##HandlerClass(StepHdlPtr p , int i) { \
490  member.interfaceSet##pp##handler(p,i); \
491 } \
492 void ThisClass::interfaceInsert##pp##HandlerClass(StepHdlPtr p, int i) { \
493  member.interfaceInsert##pp##handler(p,i); \
494 } \
495 void ThisClass::interfaceErase##pp##HandlerClass(int i) { \
496  member.interfaceErase##pp##handler(i); \
497 } \
498 vector<StepHdlPtr> ThisClass::interfaceGet##pp##HandlerClass() const { \
499  return member.interfaceGet##pp##handlers(); \
500 }
501 
503 #define ThePEG_IMPLEMENT_GROUPINTERFACE(ThisClass,HandlerClass,member,ptr) \
504 ThePEG_IMPLEMENT_PREPOST_GROUP(ThisClass,HandlerClass,member,Pre) \
505 void ThisClass::interfaceSet##HandlerClass(ptr p) { \
506  member.interfaceSetHandler(p); \
507 } \
508 ptr ThisClass::interfaceGet##HandlerClass() const { \
509  return member.interfaceGetHandler(); \
510 } \
511 ThePEG_IMPLEMENT_PREPOST_GROUP(ThisClass,HandlerClass,member,Post) \
512 
513 
514 #define ThePEG_DECLARE_PREPOST_OBJECTS(ThisClass,HandlerClass,pp,ba) \
515 static RefVector<ThisClass,StepHandler> interface##pp##HandlerClass \
516 (#pp #HandlerClass "s", \
517  "A list of handlers to be called " #ba " the " #HandlerClass ". " \
518  "If handler objects are specified in a EventHandler and " \
519  "the SubProcessHandler chosen in a given collision also specifies some, " \
520  "the latter will caled first.", \
521  0, 0, false, false, true, false, \
522  &ThisClass::interfaceSet##pp##HandlerClass, \
523  &ThisClass::interfaceInsert##pp##HandlerClass, \
524  &ThisClass::interfaceErase##pp##HandlerClass, \
525  &ThisClass::interfaceGet##pp##HandlerClass)
526 
528 #define ThePEG_DECLARE_GROUPINTERFACE_OBJECTS(ThisClass,HandlerClass) \
529 ThePEG_DECLARE_PREPOST_OBJECTS(ThisClass,HandlerClass,Pre, before); \
530 static Reference<ThisClass,HandlerClass> interface ## HandlerClass \
531 (#HandlerClass, \
532  "The " #HandlerClass " object used in this " #ThisClass ". " \
533  "If a " #HandlerClass " object is specified in a EventHandler and " \
534  "the SubProcessHandler chosen in a given collision also specifies one," \
535  "the latter will be used.", \
536  0, false, false, true, true, \
537  &ThisClass::interfaceSet ## HandlerClass, \
538  &ThisClass::interfaceGet ## HandlerClass); \
539 ThePEG_DECLARE_PREPOST_OBJECTS(ThisClass,HandlerClass,Post, after)
540 
541 #ifndef ThePEG_TEMPLATES_IN_CC_FILE
542 #include "HandlerGroup.tcc"
543 #endif
544 
545 #endif /* ThePEG_HandlerGroup_H */