CMS 3D CMS Logo
ActivityRegistry.h
Go to the documentation of this file.
1 #ifndef FWCore_ServiceRegistry_ActivityRegistry_h
2 #define FWCore_ServiceRegistry_ActivityRegistry_h
3 // -*- C++ -*-
4 //
5 // Package: ServiceRegistry
6 // Class : ActivityRegistry
7 //
26 //
27 // Original Author: Chris Jones
28 // Created: Mon Sep 5 19:53:09 EDT 2005
29 //
30 
31 // system include files
32 #include <functional>
33 #include "FWCore/Utilities/interface/Signal.h"
34 #include "FWCore/Utilities/interface/StreamID.h"
35 #include "FWCore/ServiceRegistry/interface/TerminationOrigin.h"
36 
37 // user include files
38 
39 #define AR_WATCH_USING_METHOD_0(method) template<class TClass, class TMethod> void method (TClass* iObject, TMethod iMethod) { method (std::bind(std::mem_fn(iMethod), iObject)); }
40 #define AR_WATCH_USING_METHOD_1(method) template<class TClass, class TMethod> void method (TClass* iObject, TMethod iMethod) { method (std::bind(std::mem_fn(iMethod), iObject, std::placeholders::_1)); }
41 #define AR_WATCH_USING_METHOD_2(method) template<class TClass, class TMethod> void method (TClass* iObject, TMethod iMethod) { method (std::bind(std::mem_fn(iMethod), iObject, std::placeholders::_1, std::placeholders::_2)); }
42 #define AR_WATCH_USING_METHOD_3(method) template<class TClass, class TMethod> void method (TClass* iObject, TMethod iMethod) { method (std::bind(std::mem_fn(iMethod), iObject, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)); }
43 // forward declarations
44 namespace edm {
45  class EventID;
46  class LuminosityBlockID;
47  class RunID;
48  class Timestamp;
49  class ModuleDescription;
50  class Event;
51  class LuminosityBlock;
52  class Run;
53  class EventSetup;
54  class HLTPathStatus;
55  class GlobalContext;
56  class StreamContext;
57  class PathContext;
58  class ProcessContext;
59  class ModuleCallingContext;
60  class PathsAndConsumesOfModulesBase;
61  namespace service {
62  class SystemBounds;
63  }
64 
65  namespace signalslot {
66  void throwObsoleteSignalException();
67 
68  template<class T>
69  class ObsoleteSignal {
70  public:
71  typedef std::function<T> slot_type;
72 
73  ObsoleteSignal() = default;
74 
75  template<typename U>
76  void connect(U /* iFunc */) {
77  throwObsoleteSignalException();
78  }
79 
80  template<typename U>
81  void connect_front(U /* iFunc*/) {
82  throwObsoleteSignalException();
83  }
84 
85  };
86  }
87  class ActivityRegistry {
88  public:
89  ActivityRegistry() {}
90  ActivityRegistry(ActivityRegistry const&) = delete; // Disallow copying and moving
91  ActivityRegistry& operator=(ActivityRegistry const&) = delete; // Disallow copying and moving
92 
93  // ---------- signals ------------------------------------
94  typedef signalslot::Signal<void(service::SystemBounds const&)> Preallocate;
96  Preallocate preallocateSignal_;
97  void watchPreallocate(Preallocate::slot_type const& iSlot) {
98  preallocateSignal_.connect(iSlot);
99  }
100  AR_WATCH_USING_METHOD_1(watchPreallocate)
101 
102  typedef signalslot::Signal<void(PathsAndConsumesOfModulesBase const&, ProcessContext const&)> PreBeginJob;
104  PreBeginJob preBeginJobSignal_;
106  void watchPreBeginJob(PreBeginJob::slot_type const& iSlot) {
107  preBeginJobSignal_.connect(iSlot);
108  }
109  AR_WATCH_USING_METHOD_2(watchPreBeginJob)
110 
111  typedef signalslot::Signal<void()> PostBeginJob;
113  PostBeginJob postBeginJobSignal_;
115  void watchPostBeginJob(PostBeginJob::slot_type const& iSlot) {
116  postBeginJobSignal_.connect(iSlot);
117  }
118  AR_WATCH_USING_METHOD_0(watchPostBeginJob)
119 
120  typedef signalslot::Signal<void()> PreEndJob;
122  PreEndJob preEndJobSignal_;
123  void watchPreEndJob(PreEndJob::slot_type const& iSlot) {
124  preEndJobSignal_.connect_front(iSlot);
125  }
126  AR_WATCH_USING_METHOD_0(watchPreEndJob)
127 
128  typedef signalslot::Signal<void()> PostEndJob;
130  PostEndJob postEndJobSignal_;
131  void watchPostEndJob(PostEndJob::slot_type const& iSlot) {
132  postEndJobSignal_.connect_front(iSlot);
133  }
134  AR_WATCH_USING_METHOD_0(watchPostEndJob)
135 
136  typedef signalslot::Signal<void()> JobFailure;
139  JobFailure jobFailureSignal_;
141  void watchJobFailure(JobFailure::slot_type const& iSlot) {
142  jobFailureSignal_.connect_front(iSlot);
143  }
144  AR_WATCH_USING_METHOD_0(watchJobFailure)
145 
146 
147  typedef signalslot::Signal<void(StreamID)> PreSourceEvent;
148  PreSourceEvent preSourceSignal_;
149  void watchPreSourceEvent(PreSourceEvent::slot_type const& iSlot) {
150  preSourceSignal_.connect(iSlot);
151  }
152  AR_WATCH_USING_METHOD_1(watchPreSourceEvent)
153 
154 
155  typedef signalslot::Signal<void(StreamID)> PostSourceEvent;
156  PostSourceEvent postSourceSignal_;
157  void watchPostSourceEvent(PostSourceEvent::slot_type const& iSlot) {
158  postSourceSignal_.connect_front(iSlot);
159  }
160  AR_WATCH_USING_METHOD_1(watchPostSourceEvent)
161 
162 
163  typedef signalslot::Signal<void()> PreSourceLumi;
164  PreSourceLumi preSourceLumiSignal_;
165  void watchPreSourceLumi(PreSourceLumi::slot_type const& iSlot) {
166  preSourceLumiSignal_.connect(iSlot);
167  }
168  AR_WATCH_USING_METHOD_0(watchPreSourceLumi)
169 
170 
171  typedef signalslot::Signal<void()> PostSourceLumi;
172  PostSourceLumi postSourceLumiSignal_;
173  void watchPostSourceLumi(PostSourceLumi::slot_type const& iSlot) {
174  postSourceLumiSignal_.connect_front(iSlot);
175  }
176  AR_WATCH_USING_METHOD_0(watchPostSourceLumi)
177 
178 
179  typedef signalslot::Signal<void()> PreSourceRun;
180  PreSourceRun preSourceRunSignal_;
181  void watchPreSourceRun(PreSourceRun::slot_type const& iSlot) {
182  preSourceRunSignal_.connect(iSlot);
183  }
184  AR_WATCH_USING_METHOD_0(watchPreSourceRun)
185 
186 
187  typedef signalslot::Signal<void()> PostSourceRun;
188  PostSourceRun postSourceRunSignal_;
189  void watchPostSourceRun(PostSourceRun::slot_type const& iSlot) {
190  postSourceRunSignal_.connect_front(iSlot);
191  }
192  AR_WATCH_USING_METHOD_0(watchPostSourceRun)
193 
194 
195  typedef signalslot::Signal<void(std::string const&, bool)> PreOpenFile;
196  PreOpenFile preOpenFileSignal_;
197  void watchPreOpenFile(PreOpenFile::slot_type const& iSlot) {
198  preOpenFileSignal_.connect(iSlot);
199  }
200  AR_WATCH_USING_METHOD_2(watchPreOpenFile)
201 
202 
203  // Note this is only done for a primary file, not a secondary one.
204  typedef signalslot::Signal<void(std::string const&, bool)> PostOpenFile;
205  PostOpenFile postOpenFileSignal_;
206  void watchPostOpenFile(PostOpenFile::slot_type const& iSlot) {
207  postOpenFileSignal_.connect_front(iSlot);
208  }
209  AR_WATCH_USING_METHOD_2(watchPostOpenFile)
210 
211 
212  // First argument is the LFN of the file which is being closed.
213  // Second argument is false if fallback is used; true otherwise.
214  typedef signalslot::Signal<void(std::string const&, bool)> PreCloseFile;
215  PreCloseFile preCloseFileSignal_;
216  void watchPreCloseFile(PreCloseFile::slot_type const& iSlot) {
217  preCloseFileSignal_.connect(iSlot);
218  }
219  AR_WATCH_USING_METHOD_2(watchPreCloseFile)
220 
221 
222  typedef signalslot::Signal<void(std::string const&, bool)> PostCloseFile;
223  PostCloseFile postCloseFileSignal_;
224  void watchPostCloseFile(PostCloseFile::slot_type const& iSlot) {
225  postCloseFileSignal_.connect_front(iSlot);
226  }
227  AR_WATCH_USING_METHOD_2(watchPostCloseFile)
228 
229  typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PreModuleBeginStream;
230  PreModuleBeginStream preModuleBeginStreamSignal_;
231  void watchPreModuleBeginStream(PreModuleBeginStream::slot_type const& iSlot) {
232  preModuleBeginStreamSignal_.connect(iSlot);
233  }
234  AR_WATCH_USING_METHOD_2(watchPreModuleBeginStream)
235 
236  typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PostModuleBeginStream;
237  PostModuleBeginStream postModuleBeginStreamSignal_;
238  void watchPostModuleBeginStream(PostModuleBeginStream::slot_type const& iSlot) {
239  postModuleBeginStreamSignal_.connect_front(iSlot);
240  }
241  AR_WATCH_USING_METHOD_2(watchPostModuleBeginStream)
242 
243  typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PreModuleEndStream;
244  PreModuleEndStream preModuleEndStreamSignal_;
245  void watchPreModuleEndStream(PreModuleEndStream::slot_type const& iSlot) {
246  preModuleEndStreamSignal_.connect(iSlot);
247  }
248  AR_WATCH_USING_METHOD_2(watchPreModuleEndStream)
249 
250  typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PostModuleEndStream;
251  PostModuleEndStream postModuleEndStreamSignal_;
252  void watchPostModuleEndStream(PostModuleEndStream::slot_type const& iSlot) {
253  postModuleEndStreamSignal_.connect_front(iSlot);
254  }
255  AR_WATCH_USING_METHOD_2(watchPostModuleEndStream)
256 
257  typedef signalslot::Signal<void(GlobalContext const&)> PreGlobalBeginRun;
259  PreGlobalBeginRun preGlobalBeginRunSignal_;
260  void watchPreGlobalBeginRun(PreGlobalBeginRun::slot_type const& iSlot) {
261  preGlobalBeginRunSignal_.connect(iSlot);
262  }
263  AR_WATCH_USING_METHOD_1(watchPreGlobalBeginRun)
264 
265  typedef signalslot::Signal<void(GlobalContext const&)> PostGlobalBeginRun;
266  PostGlobalBeginRun postGlobalBeginRunSignal_;
267  void watchPostGlobalBeginRun(PostGlobalBeginRun::slot_type const& iSlot) {
268  postGlobalBeginRunSignal_.connect_front(iSlot);
269  }
270  AR_WATCH_USING_METHOD_1(watchPostGlobalBeginRun)
271 
272  typedef signalslot::Signal<void(GlobalContext const&)> PreGlobalEndRun;
273  PreGlobalEndRun preGlobalEndRunSignal_;
274  void watchPreGlobalEndRun(PreGlobalEndRun::slot_type const& iSlot) {
275  preGlobalEndRunSignal_.connect(iSlot);
276  }
277  AR_WATCH_USING_METHOD_1(watchPreGlobalEndRun)
278 
279  typedef signalslot::Signal<void(GlobalContext const&)> PostGlobalEndRun;
280  PostGlobalEndRun postGlobalEndRunSignal_;
281  void watchPostGlobalEndRun(PostGlobalEndRun::slot_type const& iSlot) {
282  postGlobalEndRunSignal_.connect_front(iSlot);
283  }
284  AR_WATCH_USING_METHOD_1(watchPostGlobalEndRun)
285 
286  typedef signalslot::Signal<void(StreamContext const&)> PreStreamBeginRun;
287  PreStreamBeginRun preStreamBeginRunSignal_;
288  void watchPreStreamBeginRun(PreStreamBeginRun::slot_type const& iSlot) {
289  preStreamBeginRunSignal_.connect(iSlot);
290  }
291  AR_WATCH_USING_METHOD_1(watchPreStreamBeginRun)
292 
293  typedef signalslot::Signal<void(StreamContext const&)> PostStreamBeginRun;
294  PostStreamBeginRun postStreamBeginRunSignal_;
295  void watchPostStreamBeginRun(PostStreamBeginRun::slot_type const& iSlot) {
296  postStreamBeginRunSignal_.connect_front(iSlot);
297  }
298  AR_WATCH_USING_METHOD_1(watchPostStreamBeginRun)
299 
300  typedef signalslot::Signal<void(StreamContext const&)> PreStreamEndRun;
301  PreStreamEndRun preStreamEndRunSignal_;
302  void watchPreStreamEndRun(PreStreamEndRun::slot_type const& iSlot) {
303  preStreamEndRunSignal_.connect(iSlot);
304  }
305  AR_WATCH_USING_METHOD_1(watchPreStreamEndRun)
306 
307  typedef signalslot::Signal<void(StreamContext const&)> PostStreamEndRun;
308  PostStreamEndRun postStreamEndRunSignal_;
309  void watchPostStreamEndRun(PostStreamEndRun::slot_type const& iSlot) {
310  postStreamEndRunSignal_.connect_front(iSlot);
311  }
312  AR_WATCH_USING_METHOD_1(watchPostStreamEndRun)
313 
314  typedef signalslot::Signal<void(GlobalContext const&)> PreGlobalBeginLumi;
315  PreGlobalBeginLumi preGlobalBeginLumiSignal_;
316  void watchPreGlobalBeginLumi(PreGlobalBeginLumi::slot_type const& iSlot) {
317  preGlobalBeginLumiSignal_.connect(iSlot);
318  }
319  AR_WATCH_USING_METHOD_1(watchPreGlobalBeginLumi)
320 
321  typedef signalslot::Signal<void(GlobalContext const&)> PostGlobalBeginLumi;
322  PostGlobalBeginLumi postGlobalBeginLumiSignal_;
323  void watchPostGlobalBeginLumi(PostGlobalBeginLumi::slot_type const& iSlot) {
324  postGlobalBeginLumiSignal_.connect_front(iSlot);
325  }
326  AR_WATCH_USING_METHOD_1(watchPostGlobalBeginLumi)
327 
328  typedef signalslot::Signal<void(GlobalContext const&)> PreGlobalEndLumi;
329  PreGlobalEndLumi preGlobalEndLumiSignal_;
330  void watchPreGlobalEndLumi(PreGlobalEndLumi::slot_type const& iSlot) {
331  preGlobalEndLumiSignal_.connect(iSlot);
332  }
333  AR_WATCH_USING_METHOD_1(watchPreGlobalEndLumi)
334 
335  typedef signalslot::Signal<void(GlobalContext const&)> PostGlobalEndLumi;
336  PostGlobalEndLumi postGlobalEndLumiSignal_;
337  void watchPostGlobalEndLumi(PostGlobalEndLumi::slot_type const& iSlot) {
338  postGlobalEndLumiSignal_.connect_front(iSlot);
339  }
340  AR_WATCH_USING_METHOD_1(watchPostGlobalEndLumi)
341 
342  typedef signalslot::Signal<void(StreamContext const&)> PreStreamBeginLumi;
343  PreStreamBeginLumi preStreamBeginLumiSignal_;
344  void watchPreStreamBeginLumi(PreStreamBeginLumi::slot_type const& iSlot) {
345  preStreamBeginLumiSignal_.connect(iSlot);
346  }
347  AR_WATCH_USING_METHOD_1(watchPreStreamBeginLumi)
348 
349  typedef signalslot::Signal<void(StreamContext const&)> PostStreamBeginLumi;
350  PostStreamBeginLumi postStreamBeginLumiSignal_;
351  void watchPostStreamBeginLumi(PostStreamBeginLumi::slot_type const& iSlot) {
352  postStreamBeginLumiSignal_.connect_front(iSlot);
353  }
354  AR_WATCH_USING_METHOD_1(watchPostStreamBeginLumi)
355 
356  typedef signalslot::Signal<void(StreamContext const&)> PreStreamEndLumi;
357  PreStreamEndLumi preStreamEndLumiSignal_;
358  void watchPreStreamEndLumi(PreStreamEndLumi::slot_type const& iSlot) {
359  preStreamEndLumiSignal_.connect(iSlot);
360  }
361  AR_WATCH_USING_METHOD_1(watchPreStreamEndLumi)
362 
363  typedef signalslot::Signal<void(StreamContext const&)> PostStreamEndLumi;
364  PostStreamEndLumi postStreamEndLumiSignal_;
365  void watchPostStreamEndLumi(PostStreamEndLumi::slot_type const& iSlot) {
366  postStreamEndLumiSignal_.connect_front(iSlot);
367  }
368  AR_WATCH_USING_METHOD_1(watchPostStreamEndLumi)
369 
370  typedef signalslot::Signal<void(StreamContext const&)> PreEvent;
372  PreEvent preEventSignal_;
373  void watchPreEvent(PreEvent::slot_type const& iSlot) {
374  preEventSignal_.connect(iSlot);
375  }
376  AR_WATCH_USING_METHOD_1(watchPreEvent)
377 
378  typedef signalslot::Signal<void(StreamContext const&)> PostEvent;
380  PostEvent postEventSignal_;
381  void watchPostEvent(PostEvent::slot_type const& iSlot) {
382  postEventSignal_.connect_front(iSlot);
383  }
384  AR_WATCH_USING_METHOD_1(watchPostEvent)
385 
386 
387  typedef signalslot::Signal<void(StreamContext const&, PathContext const&)> PrePathEvent;
388  PrePathEvent prePathEventSignal_;
389  void watchPrePathEvent(PrePathEvent::slot_type const& iSlot) {
390  prePathEventSignal_.connect(iSlot);
391  }
392  AR_WATCH_USING_METHOD_2(watchPrePathEvent)
393 
394 
395  typedef signalslot::Signal<void(StreamContext const&, PathContext const&, HLTPathStatus const&)> PostPathEvent;
396  PostPathEvent postPathEventSignal_;
397  void watchPostPathEvent(PostPathEvent::slot_type const& iSlot) {
398  postPathEventSignal_.connect_front(iSlot);
399  }
400  AR_WATCH_USING_METHOD_3(watchPostPathEvent)
401 
402 
403  typedef signalslot::Signal<void(StreamContext const&, TerminationOrigin)> PreStreamEarlyTermination;
405  PreStreamEarlyTermination preStreamEarlyTerminationSignal_;
406  void watchPreStreamEarlyTermination(PreStreamEarlyTermination::slot_type const& iSlot) {
407  preStreamEarlyTerminationSignal_.connect(iSlot);
408  }
409  AR_WATCH_USING_METHOD_2(watchPreStreamEarlyTermination)
410 
411 
412  typedef signalslot::Signal<void(GlobalContext const&, TerminationOrigin)> PreGlobalEarlyTermination;
414  PreGlobalEarlyTermination preGlobalEarlyTerminationSignal_;
415  void watchPreGlobalEarlyTermination(PreGlobalEarlyTermination::slot_type const& iSlot) {
416  preGlobalEarlyTerminationSignal_.connect(iSlot);
417  }
418  AR_WATCH_USING_METHOD_2(watchPreGlobalEarlyTermination)
419 
420 
421  typedef signalslot::Signal<void(TerminationOrigin)> PreSourceEarlyTermination;
423  PreSourceEarlyTermination preSourceEarlyTerminationSignal_;
424  void watchPreSourceEarlyTermination(PreSourceEarlyTermination::slot_type const& iSlot) {
425  preSourceEarlyTerminationSignal_.connect(iSlot);
426  }
427  AR_WATCH_USING_METHOD_1(watchPreSourceEarlyTermination)
428 
429  // OLD DELETE THIS
430  typedef signalslot::ObsoleteSignal<void(EventID const&, Timestamp const&)> PreProcessEvent;
432  PreProcessEvent preProcessEventSignal_;
433  void watchPreProcessEvent(PreProcessEvent::slot_type const& iSlot) {
434  preProcessEventSignal_.connect(iSlot);
435  }
436  AR_WATCH_USING_METHOD_2(watchPreProcessEvent)
437 
438  // OLD DELETE THIS
439  typedef signalslot::ObsoleteSignal<void(Event const&, EventSetup const&)> PostProcessEvent;
441  PostProcessEvent postProcessEventSignal_;
442  void watchPostProcessEvent(PostProcessEvent::slot_type const& iSlot) {
443  postProcessEventSignal_.connect_front(iSlot);
444  }
445  AR_WATCH_USING_METHOD_2(watchPostProcessEvent)
446 
447  // OLD DELETE THIS
448  typedef signalslot::ObsoleteSignal<void(RunID const&, Timestamp const&)> PreBeginRun;
450  PreBeginRun preBeginRunSignal_;
451  void watchPreBeginRun(PreBeginRun::slot_type const& iSlot) {
452  preBeginRunSignal_.connect(iSlot);
453  }
454  AR_WATCH_USING_METHOD_2(watchPreBeginRun)
455 
456  // OLD DELETE THIS
457  typedef signalslot::ObsoleteSignal<void(Run const&, EventSetup const&)> PostBeginRun;
459  PostBeginRun postBeginRunSignal_;
460  void watchPostBeginRun(PostBeginRun::slot_type const& iSlot) {
461  postBeginRunSignal_.connect_front(iSlot);
462  }
463  AR_WATCH_USING_METHOD_2(watchPostBeginRun)
464 
465  // OLD DELETE THIS
466  typedef signalslot::ObsoleteSignal<void(RunID const&, Timestamp const&)> PreEndRun;
468  PreEndRun preEndRunSignal_;
469  void watchPreEndRun(PreEndRun::slot_type const& iSlot) {
470  preEndRunSignal_.connect(iSlot);
471  }
472  AR_WATCH_USING_METHOD_2(watchPreEndRun)
473 
474  // OLD DELETE THIS
475  typedef signalslot::ObsoleteSignal<void(Run const&, EventSetup const&)> PostEndRun;
477  PostEndRun postEndRunSignal_;
478  void watchPostEndRun(PostEndRun::slot_type const& iSlot) {
479  postEndRunSignal_.connect_front(iSlot);
480  }
481  AR_WATCH_USING_METHOD_2(watchPostEndRun)
482 
483  // OLD DELETE THIS
484  typedef signalslot::ObsoleteSignal<void(LuminosityBlockID const&, Timestamp const&)> PreBeginLumi;
486  PreBeginLumi preBeginLumiSignal_;
487  void watchPreBeginLumi(PreBeginLumi::slot_type const& iSlot) {
488  preBeginLumiSignal_.connect(iSlot);
489  }
490  AR_WATCH_USING_METHOD_2(watchPreBeginLumi)
491 
492  // OLD DELETE THIS
493  typedef signalslot::ObsoleteSignal<void(LuminosityBlock const&, EventSetup const&)> PostBeginLumi;
495  PostBeginLumi postBeginLumiSignal_;
496  void watchPostBeginLumi(PostBeginLumi::slot_type const& iSlot) {
497  postBeginLumiSignal_.connect_front(iSlot);
498  }
499  AR_WATCH_USING_METHOD_2(watchPostBeginLumi)
500 
501  // OLD DELETE THIS
502  typedef signalslot::ObsoleteSignal<void(LuminosityBlockID const&, Timestamp const&)> PreEndLumi;
504  PreEndLumi preEndLumiSignal_;
505  void watchPreEndLumi(PreEndLumi::slot_type const& iSlot) {
506  preEndLumiSignal_.connect(iSlot);
507  }
508  AR_WATCH_USING_METHOD_2(watchPreEndLumi)
509 
510  // OLD DELETE THIS
511  typedef signalslot::ObsoleteSignal<void(LuminosityBlock const&, EventSetup const&)> PostEndLumi;
513  PostEndLumi postEndLumiSignal_;
514  void watchPostEndLumi(PostEndLumi::slot_type const& iSlot) {
515  postEndLumiSignal_.connect_front(iSlot);
516  }
517  AR_WATCH_USING_METHOD_2(watchPostEndLumi)
518 
519  // OLD DELETE THIS
521  typedef signalslot::ObsoleteSignal<void(std::string const&)> PreProcessPath;
522  PreProcessPath preProcessPathSignal_;
523  void watchPreProcessPath(PreProcessPath::slot_type const& iSlot) {
524  preProcessPathSignal_.connect(iSlot);
525  }
526  AR_WATCH_USING_METHOD_1(watchPreProcessPath)
527 
528  // OLD DELETE THIS
530  typedef signalslot::ObsoleteSignal<void(std::string const&, HLTPathStatus const&)> PostProcessPath;
531  PostProcessPath postProcessPathSignal_;
532  void watchPostProcessPath(PostProcessPath::slot_type const& iSlot) {
533  postProcessPathSignal_.connect_front(iSlot);
534  }
535  AR_WATCH_USING_METHOD_2(watchPostProcessPath)
536 
537  // OLD DELETE THIS
539  typedef signalslot::ObsoleteSignal<void(std::string const&)> PrePathBeginRun;
540  PrePathBeginRun prePathBeginRunSignal_;
541  void watchPrePathBeginRun(PrePathBeginRun::slot_type const& iSlot) {
542  prePathBeginRunSignal_.connect(iSlot);
543  }
544  AR_WATCH_USING_METHOD_1(watchPrePathBeginRun)
545 
546  // OLD DELETE THIS
548  typedef signalslot::ObsoleteSignal<void(std::string const&, HLTPathStatus const&)> PostPathBeginRun;
549  PostPathBeginRun postPathBeginRunSignal_;
550  void watchPostPathBeginRun(PostPathBeginRun::slot_type const& iSlot) {
551  postPathBeginRunSignal_.connect_front(iSlot);
552  }
553  AR_WATCH_USING_METHOD_2(watchPostPathBeginRun)
554 
555  // OLD DELETE THIS
557  typedef signalslot::ObsoleteSignal<void(std::string const&)> PrePathEndRun;
558  PrePathEndRun prePathEndRunSignal_;
559  void watchPrePathEndRun(PrePathEndRun::slot_type const& iSlot) {
560  prePathEndRunSignal_.connect(iSlot);
561  }
562  AR_WATCH_USING_METHOD_1(watchPrePathEndRun)
563 
564  // OLD DELETE THIS
566  typedef signalslot::ObsoleteSignal<void(std::string const&, HLTPathStatus const&)> PostPathEndRun;
567  PostPathEndRun postPathEndRunSignal_;
568  void watchPostPathEndRun(PostPathEndRun::slot_type const& iSlot) {
569  postPathEndRunSignal_.connect_front(iSlot);
570  }
571  AR_WATCH_USING_METHOD_2(watchPostPathEndRun)
572 
573  // OLD DELETE THIS
575  typedef signalslot::ObsoleteSignal<void(std::string const&)> PrePathBeginLumi;
576  PrePathBeginLumi prePathBeginLumiSignal_;
577  void watchPrePathBeginLumi(PrePathBeginLumi::slot_type const& iSlot) {
578  prePathBeginLumiSignal_.connect(iSlot);
579  }
580  AR_WATCH_USING_METHOD_1(watchPrePathBeginLumi)
581 
582  // OLD DELETE THIS
584  typedef signalslot::ObsoleteSignal<void(std::string const&, HLTPathStatus const&)> PostPathBeginLumi;
585  PostPathBeginLumi postPathBeginLumiSignal_;
586  void watchPostPathBeginLumi(PostPathBeginLumi::slot_type const& iSlot) {
587  postPathBeginLumiSignal_.connect_front(iSlot);
588  }
589  AR_WATCH_USING_METHOD_2(watchPostPathBeginLumi)
590 
591  // OLD DELETE THIS
593  typedef signalslot::ObsoleteSignal<void(std::string const&)> PrePathEndLumi;
594  PrePathEndLumi prePathEndLumiSignal_;
595  void watchPrePathEndLumi(PrePathEndLumi::slot_type const& iSlot) {
596  prePathEndLumiSignal_.connect(iSlot);
597  }
598  AR_WATCH_USING_METHOD_1(watchPrePathEndLumi)
599 
600  // OLD DELETE THIS
602  typedef signalslot::ObsoleteSignal<void(std::string const&, HLTPathStatus const&)> PostPathEndLumi;
603  PostPathEndLumi postPathEndLumiSignal_;
604  void watchPostPathEndLumi(PostPathEndLumi::slot_type const& iSlot) {
605  postPathEndLumiSignal_.connect_front(iSlot);
606  }
607  AR_WATCH_USING_METHOD_2(watchPostPathEndLumi)
608 
609  /* Note M:
610  Concerning use of address of module descriptor
611  during functions called before/after module or source construction:
612  Unlike the case in the Run, Lumi, and Event loops,
613  the Module descriptor (often passed by pointer or reference
614  as an argument named desc) in the construction phase is NOT
615  at some permanent fixed address during the construction phase.
616  Therefore, any optimization of caching the module name keying
617  off of address of the descriptor will NOT be valid during
618  such functions. mf / cj 9/11/09
619  */
620 
621 
622  typedef signalslot::Signal<void(ModuleDescription const&)> PreModuleConstruction;
623  PreModuleConstruction preModuleConstructionSignal_;
624  void watchPreModuleConstruction(PreModuleConstruction::slot_type const& iSlot) {
625  preModuleConstructionSignal_.connect(iSlot);
626  }
627  // WARNING - ModuleDescription is not in fixed place. See note M above.
628  AR_WATCH_USING_METHOD_1(watchPreModuleConstruction)
629 
630 
631  typedef signalslot::Signal<void(ModuleDescription const&)> PostModuleConstruction;
632  PostModuleConstruction postModuleConstructionSignal_;
633  void watchPostModuleConstruction(PostModuleConstruction::slot_type const& iSlot) {
634  postModuleConstructionSignal_.connect_front(iSlot);
635  }
636  // WARNING - ModuleDescription is not in fixed place. See note M above.
637  AR_WATCH_USING_METHOD_1(watchPostModuleConstruction)
638 
639 
640  typedef signalslot::Signal<void(ModuleDescription const&)> PreModuleBeginJob;
641  PreModuleBeginJob preModuleBeginJobSignal_;
642  void watchPreModuleBeginJob(PreModuleBeginJob::slot_type const& iSlot) {
643  preModuleBeginJobSignal_.connect(iSlot);
644  }
645  AR_WATCH_USING_METHOD_1(watchPreModuleBeginJob)
646 
647 
648  typedef signalslot::Signal<void(ModuleDescription const&)> PostModuleBeginJob;
649  PostModuleBeginJob postModuleBeginJobSignal_;
650  void watchPostModuleBeginJob(PostModuleBeginJob::slot_type const& iSlot) {
651  postModuleBeginJobSignal_.connect_front(iSlot);
652  }
653  AR_WATCH_USING_METHOD_1(watchPostModuleBeginJob)
654 
655 
656  typedef signalslot::Signal<void(ModuleDescription const&)> PreModuleEndJob;
657  PreModuleEndJob preModuleEndJobSignal_;
658  void watchPreModuleEndJob(PreModuleEndJob::slot_type const& iSlot) {
659  preModuleEndJobSignal_.connect(iSlot);
660  }
661  AR_WATCH_USING_METHOD_1(watchPreModuleEndJob)
662 
663 
664  typedef signalslot::Signal<void(ModuleDescription const&)> PostModuleEndJob;
665  PostModuleEndJob postModuleEndJobSignal_;
666  void watchPostModuleEndJob(PostModuleEndJob::slot_type const& iSlot) {
667  postModuleEndJobSignal_.connect_front(iSlot);
668  }
669  AR_WATCH_USING_METHOD_1(watchPostModuleEndJob)
670 
671 
672  typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PreModuleEventPrefetching;
673  PreModuleEventPrefetching preModuleEventPrefetchingSignal_;
674  void watchPreModuleEventPrefetching(PreModuleEventPrefetching::slot_type const& iSlot) {
675  preModuleEventPrefetchingSignal_.connect(iSlot);
676  }
677  AR_WATCH_USING_METHOD_2(watchPreModuleEventPrefetching)
678 
679 
680  typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PostModuleEventPrefetching;
681  PostModuleEventPrefetching postModuleEventPrefetchingSignal_;
682  void watchPostModuleEventPrefetching(PostModuleEventPrefetching::slot_type const& iSlot) {
683  postModuleEventPrefetchingSignal_.connect_front(iSlot);
684  }
685  AR_WATCH_USING_METHOD_2(watchPostModuleEventPrefetching)
686 
687 
688  typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PreModuleEvent;
689  PreModuleEvent preModuleEventSignal_;
690  void watchPreModuleEvent(PreModuleEvent::slot_type const& iSlot) {
691  preModuleEventSignal_.connect(iSlot);
692  }
693  AR_WATCH_USING_METHOD_2(watchPreModuleEvent)
694 
695 
696  typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PostModuleEvent;
697  PostModuleEvent postModuleEventSignal_;
698  void watchPostModuleEvent(PostModuleEvent::slot_type const& iSlot) {
699  postModuleEventSignal_.connect_front(iSlot);
700  }
701  AR_WATCH_USING_METHOD_2(watchPostModuleEvent)
702 
703 
704  typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PreModuleEventAcquire;
705  PreModuleEventAcquire preModuleEventAcquireSignal_;
706  void watchPreModuleEventAcquire(PreModuleEventAcquire::slot_type const& iSlot) {
707  preModuleEventAcquireSignal_.connect(iSlot);
708  }
709  AR_WATCH_USING_METHOD_2(watchPreModuleEventAcquire)
710 
711 
712  typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PostModuleEventAcquire;
713  PostModuleEventAcquire postModuleEventAcquireSignal_;
714  void watchPostModuleEventAcquire(PostModuleEventAcquire::slot_type const& iSlot) {
715  postModuleEventAcquireSignal_.connect_front(iSlot);
716  }
717  AR_WATCH_USING_METHOD_2(watchPostModuleEventAcquire)
718 
719 
720  typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PreModuleEventDelayedGet;
721  PreModuleEventDelayedGet preModuleEventDelayedGetSignal_;
722  void watchPreModuleEventDelayedGet(PreModuleEventDelayedGet::slot_type const& iSlot) {
723  preModuleEventDelayedGetSignal_.connect(iSlot);
724  }
725  AR_WATCH_USING_METHOD_2(watchPreModuleEventDelayedGet)
726 
727 
728  typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PostModuleEventDelayedGet;
729  PostModuleEventDelayedGet postModuleEventDelayedGetSignal_;
730  void watchPostModuleEventDelayedGet(PostModuleEventDelayedGet::slot_type const& iSlot) {
731  postModuleEventDelayedGetSignal_.connect_front(iSlot);
732  }
733  AR_WATCH_USING_METHOD_2(watchPostModuleEventDelayedGet)
734 
735 
736  typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PreEventReadFromSource;
737  PreEventReadFromSource preEventReadFromSourceSignal_;
738  void watchPreEventReadFromSource(PreEventReadFromSource::slot_type const& iSlot) {
739  preEventReadFromSourceSignal_.connect(iSlot);
740  }
741  AR_WATCH_USING_METHOD_2(watchPreEventReadFromSource)
742 
743 
744  typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PostEventReadFromSource;
745  PostEventReadFromSource postEventReadFromSourceSignal_;
746  void watchPostEventReadFromSource(PostEventReadFromSource::slot_type const& iSlot) {
747  postEventReadFromSourceSignal_.connect_front(iSlot);
748  }
749  AR_WATCH_USING_METHOD_2(watchPostEventReadFromSource)
750 
751  typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PreModuleStreamBeginRun;
752  PreModuleStreamBeginRun preModuleStreamBeginRunSignal_;
753  void watchPreModuleStreamBeginRun(PreModuleStreamBeginRun::slot_type const& iSlot) {
754  preModuleStreamBeginRunSignal_.connect(iSlot);
755  }
756  AR_WATCH_USING_METHOD_2(watchPreModuleStreamBeginRun)
757 
758  typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PostModuleStreamBeginRun;
759  PostModuleStreamBeginRun postModuleStreamBeginRunSignal_;
760  void watchPostModuleStreamBeginRun(PostModuleStreamBeginRun::slot_type const& iSlot) {
761  postModuleStreamBeginRunSignal_.connect_front(iSlot);
762  }
763  AR_WATCH_USING_METHOD_2(watchPostModuleStreamBeginRun)
764 
765  typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PreModuleStreamEndRun;
766  PreModuleStreamEndRun preModuleStreamEndRunSignal_;
767  void watchPreModuleStreamEndRun(PreModuleStreamEndRun::slot_type const& iSlot) {
768  preModuleStreamEndRunSignal_.connect(iSlot);
769  }
770  AR_WATCH_USING_METHOD_2(watchPreModuleStreamEndRun)
771 
772  typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PostModuleStreamEndRun;
773  PostModuleStreamEndRun postModuleStreamEndRunSignal_;
774  void watchPostModuleStreamEndRun(PostModuleStreamEndRun::slot_type const& iSlot) {
775  postModuleStreamEndRunSignal_.connect_front(iSlot);
776  }
777  AR_WATCH_USING_METHOD_2(watchPostModuleStreamEndRun)
778 
779  typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PreModuleStreamBeginLumi;
780  PreModuleStreamBeginLumi preModuleStreamBeginLumiSignal_;
781  void watchPreModuleStreamBeginLumi(PreModuleStreamBeginLumi::slot_type const& iSlot) {
782  preModuleStreamBeginLumiSignal_.connect(iSlot);
783  }
784  AR_WATCH_USING_METHOD_2(watchPreModuleStreamBeginLumi)
785 
786  typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PostModuleStreamBeginLumi;
787  PostModuleStreamBeginLumi postModuleStreamBeginLumiSignal_;
788  void watchPostModuleStreamBeginLumi(PostModuleStreamBeginLumi::slot_type const& iSlot) {
789  postModuleStreamBeginLumiSignal_.connect_front(iSlot);
790  }
791  AR_WATCH_USING_METHOD_2(watchPostModuleStreamBeginLumi)
792 
793  typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PreModuleStreamEndLumi;
794  PreModuleStreamEndLumi preModuleStreamEndLumiSignal_;
795  void watchPreModuleStreamEndLumi(PreModuleStreamEndLumi::slot_type const& iSlot) {
796  preModuleStreamEndLumiSignal_.connect(iSlot);
797  }
798  AR_WATCH_USING_METHOD_2(watchPreModuleStreamEndLumi)
799 
800  typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PostModuleStreamEndLumi;
801  PostModuleStreamEndLumi postModuleStreamEndLumiSignal_;
802  void watchPostModuleStreamEndLumi(PostModuleStreamEndLumi::slot_type const& iSlot) {
803  postModuleStreamEndLumiSignal_.connect_front(iSlot);
804  }
805  AR_WATCH_USING_METHOD_2(watchPostModuleStreamEndLumi)
806 
807  typedef signalslot::Signal<void(GlobalContext const&, ModuleCallingContext const&)> PreModuleGlobalBeginRun;
808  PreModuleGlobalBeginRun preModuleGlobalBeginRunSignal_;
809  void watchPreModuleGlobalBeginRun(PreModuleGlobalBeginRun::slot_type const& iSlot) {
810  preModuleGlobalBeginRunSignal_.connect(iSlot);
811  }
812  AR_WATCH_USING_METHOD_2(watchPreModuleGlobalBeginRun)
813 
814  typedef signalslot::Signal<void(GlobalContext const&, ModuleCallingContext const&)> PostModuleGlobalBeginRun;
815  PostModuleGlobalBeginRun postModuleGlobalBeginRunSignal_;
816  void watchPostModuleGlobalBeginRun(PostModuleGlobalBeginRun::slot_type const& iSlot) {
817  postModuleGlobalBeginRunSignal_.connect_front(iSlot);
818  }
819  AR_WATCH_USING_METHOD_2(watchPostModuleGlobalBeginRun)
820 
821  typedef signalslot::Signal<void(GlobalContext const&, ModuleCallingContext const&)> PreModuleGlobalEndRun;
822  PreModuleGlobalEndRun preModuleGlobalEndRunSignal_;
823  void watchPreModuleGlobalEndRun(PreModuleGlobalEndRun::slot_type const& iSlot) {
824  preModuleGlobalEndRunSignal_.connect(iSlot);
825  }
826  AR_WATCH_USING_METHOD_2(watchPreModuleGlobalEndRun)
827 
828  typedef signalslot::Signal<void(GlobalContext const&, ModuleCallingContext const&)> PostModuleGlobalEndRun;
829  PostModuleGlobalEndRun postModuleGlobalEndRunSignal_;
830  void watchPostModuleGlobalEndRun(PostModuleGlobalEndRun::slot_type const& iSlot) {
831  postModuleGlobalEndRunSignal_.connect_front(iSlot);
832  }
833  AR_WATCH_USING_METHOD_2(watchPostModuleGlobalEndRun)
834 
835  typedef signalslot::Signal<void(GlobalContext const&, ModuleCallingContext const&)> PreModuleGlobalBeginLumi;
836  PreModuleGlobalBeginLumi preModuleGlobalBeginLumiSignal_;
837  void watchPreModuleGlobalBeginLumi(PreModuleGlobalBeginLumi::slot_type const& iSlot) {
838  preModuleGlobalBeginLumiSignal_.connect(iSlot);
839  }
840  AR_WATCH_USING_METHOD_2(watchPreModuleGlobalBeginLumi)
841 
842  typedef signalslot::Signal<void(GlobalContext const&, ModuleCallingContext const&)> PostModuleGlobalBeginLumi;
843  PostModuleGlobalBeginLumi postModuleGlobalBeginLumiSignal_;
844  void watchPostModuleGlobalBeginLumi(PostModuleGlobalBeginLumi::slot_type const& iSlot) {
845  postModuleGlobalBeginLumiSignal_.connect_front(iSlot);
846  }
847  AR_WATCH_USING_METHOD_2(watchPostModuleGlobalBeginLumi)
848 
849  typedef signalslot::Signal<void(GlobalContext const&, ModuleCallingContext const&)> PreModuleGlobalEndLumi;
850  PreModuleGlobalEndLumi preModuleGlobalEndLumiSignal_;
851  void watchPreModuleGlobalEndLumi(PreModuleGlobalEndLumi::slot_type const& iSlot) {
852  preModuleGlobalEndLumiSignal_.connect(iSlot);
853  }
854  AR_WATCH_USING_METHOD_2(watchPreModuleGlobalEndLumi)
855 
856  typedef signalslot::Signal<void(GlobalContext const&, ModuleCallingContext const&)> PostModuleGlobalEndLumi;
857  PostModuleGlobalEndLumi postModuleGlobalEndLumiSignal_;
858  void watchPostModuleGlobalEndLumi(PostModuleGlobalEndLumi::slot_type const& iSlot) {
859  postModuleGlobalEndLumiSignal_.connect_front(iSlot);
860  }
861  AR_WATCH_USING_METHOD_2(watchPostModuleGlobalEndLumi)
862 
863  // OLD DELETE THIS
865  typedef signalslot::ObsoleteSignal<void(ModuleDescription const&)> PreModule;
866  PreModule preModuleSignal_;
867  void watchPreModule(PreModule::slot_type const& iSlot) {
868  preModuleSignal_.connect(iSlot);
869  }
870  AR_WATCH_USING_METHOD_1(watchPreModule)
871 
872  // OLD DELETE THIS
874  typedef signalslot::ObsoleteSignal<void(ModuleDescription const&)> PostModule;
875  PostModule postModuleSignal_;
876  void watchPostModule(PostModule::slot_type const& iSlot) {
877  postModuleSignal_.connect_front(iSlot);
878  }
879  AR_WATCH_USING_METHOD_1(watchPostModule)
880 
881  // OLD DELETE THIS
883  typedef signalslot::ObsoleteSignal<void(ModuleDescription const&)> PreModuleBeginRun;
884  PreModuleBeginRun preModuleBeginRunSignal_;
885  void watchPreModuleBeginRun(PreModuleBeginRun::slot_type const& iSlot) {
886  preModuleBeginRunSignal_.connect(iSlot);
887  }
888  AR_WATCH_USING_METHOD_1(watchPreModuleBeginRun)
889 
890  // OLD DELETE THIS
892  typedef signalslot::ObsoleteSignal<void(ModuleDescription const&)> PostModuleBeginRun;
893  PostModuleBeginRun postModuleBeginRunSignal_;
894  void watchPostModuleBeginRun(PostModuleBeginRun::slot_type const& iSlot) {
895  postModuleBeginRunSignal_.connect_front(iSlot);
896 
897  }
898  AR_WATCH_USING_METHOD_1(watchPostModuleBeginRun)
899 
900  // OLD DELETE THIS
902  typedef signalslot::ObsoleteSignal<void(ModuleDescription const&)> PreModuleEndRun;
903  PreModuleEndRun preModuleEndRunSignal_;
904  void watchPreModuleEndRun(PreModuleEndRun::slot_type const& iSlot) {
905  preModuleEndRunSignal_.connect(iSlot);
906  }
907  AR_WATCH_USING_METHOD_1(watchPreModuleEndRun)
908 
909  // OLD DELETE THIS
911  typedef signalslot::ObsoleteSignal<void(ModuleDescription const&)> PostModuleEndRun;
912  PostModuleEndRun postModuleEndRunSignal_;
913  void watchPostModuleEndRun(PostModuleEndRun::slot_type const& iSlot) {
914  postModuleEndRunSignal_.connect_front(iSlot);
915  }
916  AR_WATCH_USING_METHOD_1(watchPostModuleEndRun)
917 
918  // OLD DELETE THIS
920  typedef signalslot::ObsoleteSignal<void(ModuleDescription const&)> PreModuleBeginLumi;
921  PreModuleBeginLumi preModuleBeginLumiSignal_;
922  void watchPreModuleBeginLumi(PreModuleBeginLumi::slot_type const& iSlot) {
923  preModuleBeginLumiSignal_.connect(iSlot);
924  }
925  AR_WATCH_USING_METHOD_1(watchPreModuleBeginLumi)
926 
927  // OLD DELETE THIS
929  typedef signalslot::ObsoleteSignal<void(ModuleDescription const&)> PostModuleBeginLumi;
930  PostModuleBeginLumi postModuleBeginLumiSignal_;
931  void watchPostModuleBeginLumi(PostModuleBeginLumi::slot_type const& iSlot) {
932  postModuleBeginLumiSignal_.connect_front(iSlot);
933  }
934  AR_WATCH_USING_METHOD_1(watchPostModuleBeginLumi)
935 
936  // OLD DELETE THIS
938  typedef signalslot::ObsoleteSignal<void(ModuleDescription const&)> PreModuleEndLumi;
939  PreModuleEndLumi preModuleEndLumiSignal_;
940  void watchPreModuleEndLumi(PreModuleEndLumi::slot_type const& iSlot) {
941  preModuleEndLumiSignal_.connect(iSlot);
942  }
943  AR_WATCH_USING_METHOD_1(watchPreModuleEndLumi)
944 
945  // OLD DELETE THIS
947  typedef signalslot::ObsoleteSignal<void(ModuleDescription const&)> PostModuleEndLumi;
948  PostModuleEndLumi postModuleEndLumiSignal_;
949  void watchPostModuleEndLumi(PostModuleEndLumi::slot_type const& iSlot) {
950  postModuleEndLumiSignal_.connect_front(iSlot);
951  }
952  AR_WATCH_USING_METHOD_1(watchPostModuleEndLumi)
953 
954 
955  typedef signalslot::Signal<void(ModuleDescription const&)> PreSourceConstruction;
956  PreSourceConstruction preSourceConstructionSignal_;
957  void watchPreSourceConstruction(PreSourceConstruction::slot_type const& iSlot) {
958  preSourceConstructionSignal_.connect(iSlot);
959  }
960  // WARNING - ModuleDescription is not in fixed place. See note M above.
961  AR_WATCH_USING_METHOD_1(watchPreSourceConstruction)
962 
963 
964  typedef signalslot::Signal<void(ModuleDescription const&)> PostSourceConstruction;
965  PostSourceConstruction postSourceConstructionSignal_;
966  void watchPostSourceConstruction(PostSourceConstruction::slot_type const& iSlot) {
967  postSourceConstructionSignal_.connect_front(iSlot);
968  }
969  // WARNING - ModuleDescription is not in fixed place. See note M above.
970  AR_WATCH_USING_METHOD_1(watchPostSourceConstruction)
971 
972  // ---------- member functions ---------------------------
973 
974 
975  void connect(ActivityRegistry& iOther);
976 
979  void connectToSubProcess(ActivityRegistry& iOther);
980 
986  void copySlotsFrom(ActivityRegistry& iOther);
987 
988  private:
989  // forwards subprocess independent signals to slots connected to iOther
990  void connectGlobals(ActivityRegistry& iOther);
991 
992  // forwards subprocess dependent signals to slots connected to iOther
993  void connectLocals(ActivityRegistry& iOther);
994  };
995 }
996 #undef AR_WATCH_USING_METHOD
997 #endif
edm::ActivityRegistry::watchPreallocate
void watchPreallocate(Preallocate::slot_type const &iSlot)
Definition: ActivityRegistry.h:97
edm::signalslot::throwObsoleteSignalException
void throwObsoleteSignalException()
Definition: ActivityRegistry.cc:89
edm::ActivityRegistry::Preallocate
signalslot::Signal< void(service::SystemBounds const &)> Preallocate
Definition: ActivityRegistry.h:94
edm::signalslot::Signal::connect_front
void connect_front(U iFunc)
Definition: Signal.h:68
mitigatedMETSequence_cff.U
U
Definition: mitigatedMETSequence_cff.py:36
edm::ActivityRegistry::preallocateSignal_
Preallocate preallocateSignal_
signal is emitted before beginJob
Definition: ActivityRegistry.h:96
edm::signalslot::Signal< void(service::SystemBounds const &)>::slot_type
std::function< void(service::SystemBounds const &) > slot_type
Definition: Signal.h:39
AR_WATCH_USING_METHOD_1
#define AR_WATCH_USING_METHOD_1(method)
Definition: ActivityRegistry.h:40
AR_WATCH_USING_METHOD_0
#define AR_WATCH_USING_METHOD_0(method)
Definition: ActivityRegistry.h:39
connect
edm::Handle< T > connect(const T *&ptr, edm::EDGetTokenT< T > token, const edm::Event &evt)
Definition: SiStripGainsPCLWorker.h:203
edm
HLT enums.
Definition: AlignableModifier.h:17
AR_WATCH_USING_METHOD_3
#define AR_WATCH_USING_METHOD_3(method)
Definition: ActivityRegistry.h:42
AR_WATCH_USING_METHOD_2
#define AR_WATCH_USING_METHOD_2(method)
Definition: ActivityRegistry.h:41
edm::signalslot::Signal::connect
void connect(U iFunc)
Definition: Signal.h:63
edm::Run
Definition: Run.h:43
Signal
Definition: vlib.h:39
Generated for CMSSW Reference Manual by doxygen 1.8.11