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