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&)> PreModuleEventDelayedGet;
705  PreModuleEventDelayedGet preModuleEventDelayedGetSignal_;
706  void watchPreModuleEventDelayedGet(PreModuleEventDelayedGet::slot_type const& iSlot) {
707  preModuleEventDelayedGetSignal_.connect(iSlot);
708  }
709  AR_WATCH_USING_METHOD_2(watchPreModuleEventDelayedGet)
710 
711 
712  typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PostModuleEventDelayedGet;
713  PostModuleEventDelayedGet postModuleEventDelayedGetSignal_;
714  void watchPostModuleEventDelayedGet(PostModuleEventDelayedGet::slot_type const& iSlot) {
715  postModuleEventDelayedGetSignal_.connect_front(iSlot);
716  }
717  AR_WATCH_USING_METHOD_2(watchPostModuleEventDelayedGet)
718 
719 
720  typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PreEventReadFromSource;
721  PreEventReadFromSource preEventReadFromSourceSignal_;
722  void watchPreEventReadFromSource(PreEventReadFromSource::slot_type const& iSlot) {
723  preEventReadFromSourceSignal_.connect(iSlot);
724  }
725  AR_WATCH_USING_METHOD_2(watchPreEventReadFromSource)
726 
727 
728  typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PostEventReadFromSource;
729  PostEventReadFromSource postEventReadFromSourceSignal_;
730  void watchPostEventReadFromSource(PostEventReadFromSource::slot_type const& iSlot) {
731  postEventReadFromSourceSignal_.connect_front(iSlot);
732  }
733  AR_WATCH_USING_METHOD_2(watchPostEventReadFromSource)
734 
735  typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PreModuleStreamBeginRun;
736  PreModuleStreamBeginRun preModuleStreamBeginRunSignal_;
737  void watchPreModuleStreamBeginRun(PreModuleStreamBeginRun::slot_type const& iSlot) {
738  preModuleStreamBeginRunSignal_.connect(iSlot);
739  }
740  AR_WATCH_USING_METHOD_2(watchPreModuleStreamBeginRun)
741 
742  typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PostModuleStreamBeginRun;
743  PostModuleStreamBeginRun postModuleStreamBeginRunSignal_;
744  void watchPostModuleStreamBeginRun(PostModuleStreamBeginRun::slot_type const& iSlot) {
745  postModuleStreamBeginRunSignal_.connect_front(iSlot);
746  }
747  AR_WATCH_USING_METHOD_2(watchPostModuleStreamBeginRun)
748 
749  typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PreModuleStreamEndRun;
750  PreModuleStreamEndRun preModuleStreamEndRunSignal_;
751  void watchPreModuleStreamEndRun(PreModuleStreamEndRun::slot_type const& iSlot) {
752  preModuleStreamEndRunSignal_.connect(iSlot);
753  }
754  AR_WATCH_USING_METHOD_2(watchPreModuleStreamEndRun)
755 
756  typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PostModuleStreamEndRun;
757  PostModuleStreamEndRun postModuleStreamEndRunSignal_;
758  void watchPostModuleStreamEndRun(PostModuleStreamEndRun::slot_type const& iSlot) {
759  postModuleStreamEndRunSignal_.connect_front(iSlot);
760  }
761  AR_WATCH_USING_METHOD_2(watchPostModuleStreamEndRun)
762 
763  typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PreModuleStreamBeginLumi;
764  PreModuleStreamBeginLumi preModuleStreamBeginLumiSignal_;
765  void watchPreModuleStreamBeginLumi(PreModuleStreamBeginLumi::slot_type const& iSlot) {
766  preModuleStreamBeginLumiSignal_.connect(iSlot);
767  }
768  AR_WATCH_USING_METHOD_2(watchPreModuleStreamBeginLumi)
769 
770  typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PostModuleStreamBeginLumi;
771  PostModuleStreamBeginLumi postModuleStreamBeginLumiSignal_;
772  void watchPostModuleStreamBeginLumi(PostModuleStreamBeginLumi::slot_type const& iSlot) {
773  postModuleStreamBeginLumiSignal_.connect_front(iSlot);
774  }
775  AR_WATCH_USING_METHOD_2(watchPostModuleStreamBeginLumi)
776 
777  typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PreModuleStreamEndLumi;
778  PreModuleStreamEndLumi preModuleStreamEndLumiSignal_;
779  void watchPreModuleStreamEndLumi(PreModuleStreamEndLumi::slot_type const& iSlot) {
780  preModuleStreamEndLumiSignal_.connect(iSlot);
781  }
782  AR_WATCH_USING_METHOD_2(watchPreModuleStreamEndLumi)
783 
784  typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PostModuleStreamEndLumi;
785  PostModuleStreamEndLumi postModuleStreamEndLumiSignal_;
786  void watchPostModuleStreamEndLumi(PostModuleStreamEndLumi::slot_type const& iSlot) {
787  postModuleStreamEndLumiSignal_.connect_front(iSlot);
788  }
789  AR_WATCH_USING_METHOD_2(watchPostModuleStreamEndLumi)
790 
791  typedef signalslot::Signal<void(GlobalContext const&, ModuleCallingContext const&)> PreModuleGlobalBeginRun;
792  PreModuleGlobalBeginRun preModuleGlobalBeginRunSignal_;
793  void watchPreModuleGlobalBeginRun(PreModuleGlobalBeginRun::slot_type const& iSlot) {
794  preModuleGlobalBeginRunSignal_.connect(iSlot);
795  }
796  AR_WATCH_USING_METHOD_2(watchPreModuleGlobalBeginRun)
797 
798  typedef signalslot::Signal<void(GlobalContext const&, ModuleCallingContext const&)> PostModuleGlobalBeginRun;
799  PostModuleGlobalBeginRun postModuleGlobalBeginRunSignal_;
800  void watchPostModuleGlobalBeginRun(PostModuleGlobalBeginRun::slot_type const& iSlot) {
801  postModuleGlobalBeginRunSignal_.connect_front(iSlot);
802  }
803  AR_WATCH_USING_METHOD_2(watchPostModuleGlobalBeginRun)
804 
805  typedef signalslot::Signal<void(GlobalContext const&, ModuleCallingContext const&)> PreModuleGlobalEndRun;
806  PreModuleGlobalEndRun preModuleGlobalEndRunSignal_;
807  void watchPreModuleGlobalEndRun(PreModuleGlobalEndRun::slot_type const& iSlot) {
808  preModuleGlobalEndRunSignal_.connect(iSlot);
809  }
810  AR_WATCH_USING_METHOD_2(watchPreModuleGlobalEndRun)
811 
812  typedef signalslot::Signal<void(GlobalContext const&, ModuleCallingContext const&)> PostModuleGlobalEndRun;
813  PostModuleGlobalEndRun postModuleGlobalEndRunSignal_;
814  void watchPostModuleGlobalEndRun(PostModuleGlobalEndRun::slot_type const& iSlot) {
815  postModuleGlobalEndRunSignal_.connect_front(iSlot);
816  }
817  AR_WATCH_USING_METHOD_2(watchPostModuleGlobalEndRun)
818 
819  typedef signalslot::Signal<void(GlobalContext const&, ModuleCallingContext const&)> PreModuleGlobalBeginLumi;
820  PreModuleGlobalBeginLumi preModuleGlobalBeginLumiSignal_;
821  void watchPreModuleGlobalBeginLumi(PreModuleGlobalBeginLumi::slot_type const& iSlot) {
822  preModuleGlobalBeginLumiSignal_.connect(iSlot);
823  }
824  AR_WATCH_USING_METHOD_2(watchPreModuleGlobalBeginLumi)
825 
826  typedef signalslot::Signal<void(GlobalContext const&, ModuleCallingContext const&)> PostModuleGlobalBeginLumi;
827  PostModuleGlobalBeginLumi postModuleGlobalBeginLumiSignal_;
828  void watchPostModuleGlobalBeginLumi(PostModuleGlobalBeginLumi::slot_type const& iSlot) {
829  postModuleGlobalBeginLumiSignal_.connect_front(iSlot);
830  }
831  AR_WATCH_USING_METHOD_2(watchPostModuleGlobalBeginLumi)
832 
833  typedef signalslot::Signal<void(GlobalContext const&, ModuleCallingContext const&)> PreModuleGlobalEndLumi;
834  PreModuleGlobalEndLumi preModuleGlobalEndLumiSignal_;
835  void watchPreModuleGlobalEndLumi(PreModuleGlobalEndLumi::slot_type const& iSlot) {
836  preModuleGlobalEndLumiSignal_.connect(iSlot);
837  }
838  AR_WATCH_USING_METHOD_2(watchPreModuleGlobalEndLumi)
839 
840  typedef signalslot::Signal<void(GlobalContext const&, ModuleCallingContext const&)> PostModuleGlobalEndLumi;
841  PostModuleGlobalEndLumi postModuleGlobalEndLumiSignal_;
842  void watchPostModuleGlobalEndLumi(PostModuleGlobalEndLumi::slot_type const& iSlot) {
843  postModuleGlobalEndLumiSignal_.connect_front(iSlot);
844  }
845  AR_WATCH_USING_METHOD_2(watchPostModuleGlobalEndLumi)
846 
847  // OLD DELETE THIS
849  typedef signalslot::ObsoleteSignal<void(ModuleDescription const&)> PreModule;
850  PreModule preModuleSignal_;
851  void watchPreModule(PreModule::slot_type const& iSlot) {
852  preModuleSignal_.connect(iSlot);
853  }
854  AR_WATCH_USING_METHOD_1(watchPreModule)
855 
856  // OLD DELETE THIS
858  typedef signalslot::ObsoleteSignal<void(ModuleDescription const&)> PostModule;
859  PostModule postModuleSignal_;
860  void watchPostModule(PostModule::slot_type const& iSlot) {
861  postModuleSignal_.connect_front(iSlot);
862  }
863  AR_WATCH_USING_METHOD_1(watchPostModule)
864 
865  // OLD DELETE THIS
867  typedef signalslot::ObsoleteSignal<void(ModuleDescription const&)> PreModuleBeginRun;
868  PreModuleBeginRun preModuleBeginRunSignal_;
869  void watchPreModuleBeginRun(PreModuleBeginRun::slot_type const& iSlot) {
870  preModuleBeginRunSignal_.connect(iSlot);
871  }
872  AR_WATCH_USING_METHOD_1(watchPreModuleBeginRun)
873 
874  // OLD DELETE THIS
876  typedef signalslot::ObsoleteSignal<void(ModuleDescription const&)> PostModuleBeginRun;
877  PostModuleBeginRun postModuleBeginRunSignal_;
878  void watchPostModuleBeginRun(PostModuleBeginRun::slot_type const& iSlot) {
879  postModuleBeginRunSignal_.connect_front(iSlot);
880 
881  }
882  AR_WATCH_USING_METHOD_1(watchPostModuleBeginRun)
883 
884  // OLD DELETE THIS
886  typedef signalslot::ObsoleteSignal<void(ModuleDescription const&)> PreModuleEndRun;
887  PreModuleEndRun preModuleEndRunSignal_;
888  void watchPreModuleEndRun(PreModuleEndRun::slot_type const& iSlot) {
889  preModuleEndRunSignal_.connect(iSlot);
890  }
891  AR_WATCH_USING_METHOD_1(watchPreModuleEndRun)
892 
893  // OLD DELETE THIS
895  typedef signalslot::ObsoleteSignal<void(ModuleDescription const&)> PostModuleEndRun;
896  PostModuleEndRun postModuleEndRunSignal_;
897  void watchPostModuleEndRun(PostModuleEndRun::slot_type const& iSlot) {
898  postModuleEndRunSignal_.connect_front(iSlot);
899  }
900  AR_WATCH_USING_METHOD_1(watchPostModuleEndRun)
901 
902  // OLD DELETE THIS
904  typedef signalslot::ObsoleteSignal<void(ModuleDescription const&)> PreModuleBeginLumi;
905  PreModuleBeginLumi preModuleBeginLumiSignal_;
906  void watchPreModuleBeginLumi(PreModuleBeginLumi::slot_type const& iSlot) {
907  preModuleBeginLumiSignal_.connect(iSlot);
908  }
909  AR_WATCH_USING_METHOD_1(watchPreModuleBeginLumi)
910 
911  // OLD DELETE THIS
913  typedef signalslot::ObsoleteSignal<void(ModuleDescription const&)> PostModuleBeginLumi;
914  PostModuleBeginLumi postModuleBeginLumiSignal_;
915  void watchPostModuleBeginLumi(PostModuleBeginLumi::slot_type const& iSlot) {
916  postModuleBeginLumiSignal_.connect_front(iSlot);
917  }
918  AR_WATCH_USING_METHOD_1(watchPostModuleBeginLumi)
919 
920  // OLD DELETE THIS
922  typedef signalslot::ObsoleteSignal<void(ModuleDescription const&)> PreModuleEndLumi;
923  PreModuleEndLumi preModuleEndLumiSignal_;
924  void watchPreModuleEndLumi(PreModuleEndLumi::slot_type const& iSlot) {
925  preModuleEndLumiSignal_.connect(iSlot);
926  }
927  AR_WATCH_USING_METHOD_1(watchPreModuleEndLumi)
928 
929  // OLD DELETE THIS
931  typedef signalslot::ObsoleteSignal<void(ModuleDescription const&)> PostModuleEndLumi;
932  PostModuleEndLumi postModuleEndLumiSignal_;
933  void watchPostModuleEndLumi(PostModuleEndLumi::slot_type const& iSlot) {
934  postModuleEndLumiSignal_.connect_front(iSlot);
935  }
936  AR_WATCH_USING_METHOD_1(watchPostModuleEndLumi)
937 
938 
939  typedef signalslot::Signal<void(ModuleDescription const&)> PreSourceConstruction;
940  PreSourceConstruction preSourceConstructionSignal_;
941  void watchPreSourceConstruction(PreSourceConstruction::slot_type const& iSlot) {
942  preSourceConstructionSignal_.connect(iSlot);
943  }
944  // WARNING - ModuleDescription is not in fixed place. See note M above.
945  AR_WATCH_USING_METHOD_1(watchPreSourceConstruction)
946 
947 
948  typedef signalslot::Signal<void(ModuleDescription const&)> PostSourceConstruction;
949  PostSourceConstruction postSourceConstructionSignal_;
950  void watchPostSourceConstruction(PostSourceConstruction::slot_type const& iSlot) {
951  postSourceConstructionSignal_.connect_front(iSlot);
952  }
953  // WARNING - ModuleDescription is not in fixed place. See note M above.
954  AR_WATCH_USING_METHOD_1(watchPostSourceConstruction)
955 
956  // ---------- member functions ---------------------------
957 
958 
959  void connect(ActivityRegistry& iOther);
960 
963  void connectToSubProcess(ActivityRegistry& iOther);
964 
970  void copySlotsFrom(ActivityRegistry& iOther);
971 
972  private:
973  // forwards subprocess independent signals to slots connected to iOther
974  void connectGlobals(ActivityRegistry& iOther);
975 
976  // forwards subprocess dependent signals to slots connected to iOther
977  void connectLocals(ActivityRegistry& iOther);
978  };
979 }
980 #undef AR_WATCH_USING_METHOD
981 #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:204
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:42
Signal
Definition: vlib.h:39
Generated for CMSSW Reference Manual by doxygen 1.8.11