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