ThePEG
1.8.0
Main Page
Related Pages
Modules
Namespaces
Classes
Files
File List
File Members
Handlers
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
44
class
HandlerGroupBase
{
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
65
HandlerGroupBase
();
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
90
StepWithHint
next
();
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
120
StepVector
&
preHandlers
() {
return
theDefaultPreHandlers
; }
121
125
const
StepVector
&
preHandlers
()
const
{
return
theDefaultPreHandlers
; }
126
130
virtual
tStepHdlPtr
defaultHandler
()
const
= 0;
131
135
StepVector
&
postHandlers
() {
return
theDefaultPostHandlers
; }
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
235
HandlerGroupBase
(
const
HandlerGroupBase
&);
236
240
bool
isEmpty
;
241
242
private
:
243
248
void
checkInsert
(
StepHintVector
& current,
const
StepVector
& def);
249
250
protected
:
251
255
StepVector
theDefaultPreHandlers
;
256
260
StepVector
theDefaultPostHandlers
;
261
265
StepHintVector
thePreHandlers
;
266
270
HintVector
theHints
;
271
275
StepHintVector
thePostHandlers
;
276
277
private
:
278
282
HandlerGroupBase
&
operator=
(
const
HandlerGroupBase
&);
283
284
};
285
320
template
<
typename
HDLR>
321
class
HandlerGroup
:
public
HandlerGroupBase
{
322
323
public
:
324
326
typedef
typename
Ptr<HDLR>::pointer
HdlPtr
;
327
329
typedef
typename
Ptr<HDLR>::transient_pointer
tHdlPtr
;
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
{
353
return
dynamic_ptr_cast
<
tStepHdlPtr
>(
theHandler
);
354
}
355
359
virtual
tStepHdlPtr
defaultHandler
()
const
{
360
return
dynamic_ptr_cast
<
tStepHdlPtr
>(
theDefaultHandler
);
361
}
362
367
virtual
void
refillDefaultHandler
(
tStepHdlPtr
);
368
372
virtual
void
clear
();
373
377
virtual
string
handlerClass
()
const
;
378
382
void
interfaceSetHandler
(
HdlPtr
);
383
387
HdlPtr
interfaceGetHandler
()
const
;
388
392
virtual
void
write
(
PersistentOStream
& os)
const
{
393
os <<
theDefaultHandler
<<
theHandler
;
394
HandlerGroupBase::write
(os);
395
}
396
400
virtual
void
read
(
PersistentIStream
& is) {
401
is >>
theDefaultHandler
>>
theHandler
;
402
HandlerGroupBase::read
(is);
403
}
404
405
private
:
406
407
411
HdlPtr
theDefaultHandler
;
412
416
HdlPtr
theHandler
;
417
418
private
:
419
423
HandlerGroup<HDLR>
&
operator=
(
const
HandlerGroup<HDLR>
&);
424
425
};
426
428
namespace
Group {
429
433
enum
Handler
{
434
subproc
,
435
cascade
,
436
multi
,
437
hadron
,
438
decay
439
};
440
442
enum
Level
{
443
before
,
444
main
,
445
after
446
};
447
}
448
450
template
<
typename
HDLR>
451
inline
PersistentOStream
&
operator<<
(
PersistentOStream
& os,
452
const
HandlerGroup<HDLR>
& hg) {
453
hg.
write
(os);
454
return
os;
455
}
456
458
template
<
typename
HDLR>
459
inline
PersistentIStream
&
operator>>
(
PersistentIStream
& is,
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 */
Generated on Mon Jul 2 2012 16:06:46 for ThePEG by
1.8.1.1