ServiceRegistry/interface/ActivityRegistry.h

0001 #ifndef FWCore_ServiceRegistry_ActivityRegistry_h
0002 #define FWCore_ServiceRegistry_ActivityRegistry_h
0003 // -*- C++ -*-
0004 //
0005 // Package:     ServiceRegistry
0006 // Class  :     ActivityRegistry
0007 //
0008 /**\class ActivityRegistry ActivityRegistry.h FWCore/ServiceRegistry/interface/ActivityRegistry.h
0009
0010  Description: Registry holding the signals that Services can subscribe to
0011
0012  Usage:
0013     Services can connect to the signals distributed by the ActivityRegistry in order to monitor the activity of the application.
0014
0015 There are unit tests for the signals that use the Tracer
0016 to print out the transitions as they occur and then
0017 compare to a reference file. One test does this for
0018 a SubProcess test and the other for a test using
0019 unscheduled execution. The tests are in FWCore/Integration/test:
0020   run_SubProcess.sh
0021   testSubProcess_cfg.py
0022   run_TestGetBy.sh
0023   testGetBy1_cfg.py
0024   testGetBy2_cfg.py
0025
0026 There are four little details you should remember when adding new signals
0027 to this file that go beyond the obvious cut and paste type of edits.
0028   1. The number at the end of the AR_WATCH_USING_METHOD_X macro definition
0029   is the number of function arguments. It will not compile if you use the
0030   wrong number there.
0031   2. Use connect or connect_front depending on whether the callback function
0032   should be called for different services in the order the Services were
0033   constructed or in reverse order. Begin signals are usually forward and
0034   End signals in reverse, but if the service does not depend on other services
0035   and vice versa this does not matter.
0036   3. The signal needs to be added to either connectGlobals or connectLocals
0037   in the ActivityRegistry.cc file, depending on whether a signal is seen
0038   by children or parents when there are SubProcesses. For example, source
0039   signals are only generated in the top level process and should be seen
0040   by all child SubProcesses so they are in connectGlobals. Most signals
0041   however belong in connectLocals. It does not really matter in jobs
0042   without at least one SubProcess.
0043   4. Each signal also needs to be added in copySlotsFrom in
0044   ActivityRegistry.cc. Whether it uses copySlotsToFrom or
0045   copySlotsToFromReverse depends on the same ordering issue as the connect
0046   or connect_front choice in item 2 above.
0047 */
0048 //
0049 // Original Author:  Chris Jones
0050 //         Created:  Mon Sep  5 19:53:09 EDT 2005
0051 //
0052
0053 // system include files
0054 #include <functional>
0055 #include <string>
0056
0057 // user include files
0058 #include "FWCore/ServiceRegistry/interface/TerminationOrigin.h"
0059 #include "FWCore/Utilities/interface/LuminosityBlockIndex.h"
0060 #include "FWCore/Utilities/interface/RunIndex.h"
0061 #include "FWCore/Utilities/interface/Signal.h"
0062 #include "FWCore/Utilities/interface/StreamID.h"
0063
0064 #define AR_WATCH_USING_METHOD_0(method)               \
0065   template <class TClass, class TMethod>              \
0066   void method(TClass* iObject, TMethod iMethod) {     \
0067     method(std::bind(std::mem_fn(iMethod), iObject)); \
0068   }
0069 #define AR_WATCH_USING_METHOD_1(method)                                      \
0070   template <class TClass, class TMethod>                                     \
0071   void method(TClass* iObject, TMethod iMethod) {                            \
0072     method(std::bind(std::mem_fn(iMethod), iObject, std::placeholders::_1)); \
0073   }
0074 #define AR_WATCH_USING_METHOD_2(method)                                                             \
0075   template <class TClass, class TMethod>                                                            \
0076   void method(TClass* iObject, TMethod iMethod) {                                                   \
0077     method(std::bind(std::mem_fn(iMethod), iObject, std::placeholders::_1, std::placeholders::_2)); \
0078   }
0079 #define AR_WATCH_USING_METHOD_3(method)                                                                       \
0080   template <class TClass, class TMethod>                                                                      \
0081   void method(TClass* iObject, TMethod iMethod) {                                                             \
0082     method(std::bind(                                                                                         \
0083         std::mem_fn(iMethod), iObject, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)); \
0084   }
0085 // forward declarations
0086 namespace edm {
0087   class EventID;
0088   class LuminosityBlockID;
0089   class RunID;
0090   class Timestamp;
0091   class ModuleDescription;
0092   class Event;
0093   class LuminosityBlock;
0094   class Run;
0095   class EventSetup;
0096   class IOVSyncValue;
0097   class HLTPathStatus;
0098   class GlobalContext;
0099   class StreamContext;
0100   class PathContext;
0101   class ProcessContext;
0102   class ModuleCallingContext;
0103   class PathsAndConsumesOfModulesBase;
0104   class ESModuleCallingContext;
0105   namespace eventsetup {
0106     struct ComponentDescription;
0107     class DataKey;
0108     class EventSetupRecordKey;
0109   }  // namespace eventsetup
0110   namespace service {
0111     class SystemBounds;
0112   }
0113
0114   namespace signalslot {
0115     void throwObsoleteSignalException();
0116
0117     template <class T>
0118     class ObsoleteSignal {
0119     public:
0120       typedef std::function<T> slot_type;
0121
0122       ObsoleteSignal() = default;
0123
0124       template <typename U>
0125       void connect(U /*  iFunc */) {
0126         throwObsoleteSignalException();
0127       }
0128
0129       template <typename U>
0130       void connect_front(U /*  iFunc*/) {
0131         throwObsoleteSignalException();
0132       }
0133     };
0134   }  // namespace signalslot
0135   class ActivityRegistry {
0136   public:
0137     ActivityRegistry() {}
0138     ActivityRegistry(ActivityRegistry const&) = delete;             // Disallow copying and moving
0139     ActivityRegistry& operator=(ActivityRegistry const&) = delete;  // Disallow copying and moving
0140
0141     // ---------- signals ------------------------------------
0142     typedef signalslot::Signal<void(service::SystemBounds const&)> Preallocate;
0143     ///signal is emitted before beginJob
0144     Preallocate preallocateSignal_;
0145     void watchPreallocate(Preallocate::slot_type const& iSlot) { preallocateSignal_.connect(iSlot); }
0146     AR_WATCH_USING_METHOD_1(watchPreallocate)
0147
0148     typedef signalslot::Signal<void(PathsAndConsumesOfModulesBase const&, ProcessContext const&)> PreBeginJob;
0149     ///signal is emitted before all modules have gotten their beginJob called
0150     PreBeginJob preBeginJobSignal_;
0151     ///convenience function for attaching to signal
0152     void watchPreBeginJob(PreBeginJob::slot_type const& iSlot) { preBeginJobSignal_.connect(iSlot); }
0153     AR_WATCH_USING_METHOD_2(watchPreBeginJob)
0154
0155     typedef signalslot::Signal<void()> PostBeginJob;
0156     ///signal is emitted after all modules have gotten their beginJob called
0157     PostBeginJob postBeginJobSignal_;
0158     ///convenience function for attaching to signal
0159     void watchPostBeginJob(PostBeginJob::slot_type const& iSlot) { postBeginJobSignal_.connect(iSlot); }
0160     AR_WATCH_USING_METHOD_0(watchPostBeginJob)
0161
0162     typedef signalslot::Signal<void()> PreEndJob;
0163     ///signal is emitted before any modules have gotten their endJob called
0164     PreEndJob preEndJobSignal_;
0165     void watchPreEndJob(PreEndJob::slot_type const& iSlot) { preEndJobSignal_.connect_front(iSlot); }
0166     AR_WATCH_USING_METHOD_0(watchPreEndJob)
0167
0168     typedef signalslot::Signal<void()> PostEndJob;
0169     ///signal is emitted after all modules have gotten their endJob called
0170     PostEndJob postEndJobSignal_;
0171     void watchPostEndJob(PostEndJob::slot_type const& iSlot) { postEndJobSignal_.connect_front(iSlot); }
0172     AR_WATCH_USING_METHOD_0(watchPostEndJob)
0173
0174     typedef signalslot::Signal<void()> JobFailure;
0175     /// signal is emitted if event processing or end-of-job
0176     /// processing fails with an uncaught exception.
0177     JobFailure jobFailureSignal_;
0178     ///convenience function for attaching to signal
0179     void watchJobFailure(JobFailure::slot_type const& iSlot) { jobFailureSignal_.connect_front(iSlot); }
0180     AR_WATCH_USING_METHOD_0(watchJobFailure)
0181
0182     /// signal is emitted before the source starts creating an Event
0183     typedef signalslot::Signal<void(StreamID)> PreSourceEvent;
0184     PreSourceEvent preSourceSignal_;
0185     void watchPreSourceEvent(PreSourceEvent::slot_type const& iSlot) { preSourceSignal_.connect(iSlot); }
0186     AR_WATCH_USING_METHOD_1(watchPreSourceEvent)
0187
0188     /// signal is emitted after the source starts creating an Event
0189     typedef signalslot::Signal<void(StreamID)> PostSourceEvent;
0190     PostSourceEvent postSourceSignal_;
0191     void watchPostSourceEvent(PostSourceEvent::slot_type const& iSlot) { postSourceSignal_.connect_front(iSlot); }
0192     AR_WATCH_USING_METHOD_1(watchPostSourceEvent)
0193
0194     /// signal is emitted before the source starts creating a Lumi
0195     typedef signalslot::Signal<void(LuminosityBlockIndex)> PreSourceLumi;
0196     PreSourceLumi preSourceLumiSignal_;
0197     void watchPreSourceLumi(PreSourceLumi::slot_type const& iSlot) { preSourceLumiSignal_.connect(iSlot); }
0198     AR_WATCH_USING_METHOD_1(watchPreSourceLumi)
0199
0200     /// signal is emitted after the source starts creating a Lumi
0201     typedef signalslot::Signal<void(LuminosityBlockIndex)> PostSourceLumi;
0202     PostSourceLumi postSourceLumiSignal_;
0203     void watchPostSourceLumi(PostSourceLumi::slot_type const& iSlot) { postSourceLumiSignal_.connect_front(iSlot); }
0204     AR_WATCH_USING_METHOD_1(watchPostSourceLumi)
0205
0206     /// signal is emitted before the source starts creating a Run
0207     typedef signalslot::Signal<void(RunIndex)> PreSourceRun;
0208     PreSourceRun preSourceRunSignal_;
0209     void watchPreSourceRun(PreSourceRun::slot_type const& iSlot) { preSourceRunSignal_.connect(iSlot); }
0210     AR_WATCH_USING_METHOD_1(watchPreSourceRun)
0211
0212     /// signal is emitted after the source starts creating a Run
0213     typedef signalslot::Signal<void(RunIndex)> PostSourceRun;
0214     PostSourceRun postSourceRunSignal_;
0215     void watchPostSourceRun(PostSourceRun::slot_type const& iSlot) { postSourceRunSignal_.connect_front(iSlot); }
0216     AR_WATCH_USING_METHOD_1(watchPostSourceRun)
0217
0218     /// signal is emitted before the source starts creating a ProcessBlock
0219     typedef signalslot::Signal<void()> PreSourceProcessBlock;
0220     PreSourceProcessBlock preSourceProcessBlockSignal_;
0221     void watchPreSourceProcessBlock(PreSourceProcessBlock::slot_type const& iSlot) {
0222       preSourceProcessBlockSignal_.connect(iSlot);
0223     }
0224     AR_WATCH_USING_METHOD_0(watchPreSourceProcessBlock)
0225
0226     /// signal is emitted after the source starts creating a ProcessBlock
0227     typedef signalslot::Signal<void(std::string const&)> PostSourceProcessBlock;
0228     PostSourceProcessBlock postSourceProcessBlockSignal_;
0229     void watchPostSourceProcessBlock(PostSourceProcessBlock::slot_type const& iSlot) {
0230       postSourceProcessBlockSignal_.connect_front(iSlot);
0231     }
0232     AR_WATCH_USING_METHOD_1(watchPostSourceProcessBlock)
0233
0234     /// signal is emitted before the source opens a file
0235     typedef signalslot::Signal<void(std::string const&)> PreOpenFile;
0236     PreOpenFile preOpenFileSignal_;
0237     void watchPreOpenFile(PreOpenFile::slot_type const& iSlot) { preOpenFileSignal_.connect(iSlot); }
0238     AR_WATCH_USING_METHOD_1(watchPreOpenFile)
0239
0240     /// signal is emitted after the source opens a file
0241     //   Note this is only done for a primary file, not a secondary one.
0242     typedef signalslot::Signal<void(std::string const&)> PostOpenFile;
0243     PostOpenFile postOpenFileSignal_;
0244     void watchPostOpenFile(PostOpenFile::slot_type const& iSlot) { postOpenFileSignal_.connect_front(iSlot); }
0245     AR_WATCH_USING_METHOD_1(watchPostOpenFile)
0246
0247     /// signal is emitted before the source closes a file
0248     //   First argument is the LFN of the file which is being closed.
0249     typedef signalslot::Signal<void(std::string const&)> PreCloseFile;
0250     PreCloseFile preCloseFileSignal_;
0251     void watchPreCloseFile(PreCloseFile::slot_type const& iSlot) { preCloseFileSignal_.connect(iSlot); }
0252     AR_WATCH_USING_METHOD_1(watchPreCloseFile)
0253
0254     /// signal is emitted after the source closes a file
0255     typedef signalslot::Signal<void(std::string const&)> PostCloseFile;
0256     PostCloseFile postCloseFileSignal_;
0257     void watchPostCloseFile(PostCloseFile::slot_type const& iSlot) { postCloseFileSignal_.connect_front(iSlot); }
0258     AR_WATCH_USING_METHOD_1(watchPostCloseFile)
0259
0260     typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PreModuleBeginStream;
0261     PreModuleBeginStream preModuleBeginStreamSignal_;
0262     void watchPreModuleBeginStream(PreModuleBeginStream::slot_type const& iSlot) {
0263       preModuleBeginStreamSignal_.connect(iSlot);
0264     }
0265     AR_WATCH_USING_METHOD_2(watchPreModuleBeginStream)
0266
0267     typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PostModuleBeginStream;
0268     PostModuleBeginStream postModuleBeginStreamSignal_;
0269     void watchPostModuleBeginStream(PostModuleBeginStream::slot_type const& iSlot) {
0270       postModuleBeginStreamSignal_.connect_front(iSlot);
0271     }
0272     AR_WATCH_USING_METHOD_2(watchPostModuleBeginStream)
0273
0274     typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PreModuleEndStream;
0275     PreModuleEndStream preModuleEndStreamSignal_;
0276     void watchPreModuleEndStream(PreModuleEndStream::slot_type const& iSlot) {
0277       preModuleEndStreamSignal_.connect(iSlot);
0278     }
0279     AR_WATCH_USING_METHOD_2(watchPreModuleEndStream)
0280
0281     typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PostModuleEndStream;
0282     PostModuleEndStream postModuleEndStreamSignal_;
0283     void watchPostModuleEndStream(PostModuleEndStream::slot_type const& iSlot) {
0284       postModuleEndStreamSignal_.connect_front(iSlot);
0285     }
0286     AR_WATCH_USING_METHOD_2(watchPostModuleEndStream)
0287
0288     typedef signalslot::Signal<void(GlobalContext const&)> PreBeginProcessBlock;
0289     PreBeginProcessBlock preBeginProcessBlockSignal_;
0290     void watchPreBeginProcessBlock(PreBeginProcessBlock::slot_type const& iSlot) {
0291       preBeginProcessBlockSignal_.connect(iSlot);
0292     }
0293     AR_WATCH_USING_METHOD_1(watchPreBeginProcessBlock)
0294
0295     typedef signalslot::Signal<void(GlobalContext const&)> PostBeginProcessBlock;
0296     PostBeginProcessBlock postBeginProcessBlockSignal_;
0297     void watchPostBeginProcessBlock(PostBeginProcessBlock::slot_type const& iSlot) {
0298       postBeginProcessBlockSignal_.connect_front(iSlot);
0299     }
0300     AR_WATCH_USING_METHOD_1(watchPostBeginProcessBlock)
0301
0302     typedef signalslot::Signal<void(GlobalContext const&)> PreAccessInputProcessBlock;
0303     PreAccessInputProcessBlock preAccessInputProcessBlockSignal_;
0304     void watchPreAccessInputProcessBlock(PreAccessInputProcessBlock::slot_type const& iSlot) {
0305       preAccessInputProcessBlockSignal_.connect(iSlot);
0306     }
0307     AR_WATCH_USING_METHOD_1(watchPreAccessInputProcessBlock)
0308
0309     typedef signalslot::Signal<void(GlobalContext const&)> PostAccessInputProcessBlock;
0310     PostAccessInputProcessBlock postAccessInputProcessBlockSignal_;
0311     void watchPostAccessInputProcessBlock(PostAccessInputProcessBlock::slot_type const& iSlot) {
0312       postAccessInputProcessBlockSignal_.connect_front(iSlot);
0313     }
0314     AR_WATCH_USING_METHOD_1(watchPostAccessInputProcessBlock)
0315
0316     typedef signalslot::Signal<void(GlobalContext const&)> PreEndProcessBlock;
0317     PreEndProcessBlock preEndProcessBlockSignal_;
0318     void watchPreEndProcessBlock(PreEndProcessBlock::slot_type const& iSlot) {
0319       preEndProcessBlockSignal_.connect(iSlot);
0320     }
0321     AR_WATCH_USING_METHOD_1(watchPreEndProcessBlock)
0322
0323     typedef signalslot::Signal<void(GlobalContext const&)> PostEndProcessBlock;
0324     PostEndProcessBlock postEndProcessBlockSignal_;
0325     void watchPostEndProcessBlock(PostEndProcessBlock::slot_type const& iSlot) {
0326       postEndProcessBlockSignal_.connect_front(iSlot);
0327     }
0328     AR_WATCH_USING_METHOD_1(watchPostEndProcessBlock)
0329
0330     typedef signalslot::Signal<void()> BeginProcessing;
0331     /// signal is emitted just before the transitions from the Source will begin to be processed
0332     BeginProcessing beginProcessingSignal_;
0333     void watchBeginProcessing(BeginProcessing::slot_type const& iSlot) { beginProcessingSignal_.connect(iSlot); }
0334     AR_WATCH_USING_METHOD_0(watchBeginProcessing)
0335
0336     typedef signalslot::Signal<void()> EndProcessing;
0337     /// signal is emitted after all work has been done processing all source transitions
0338     EndProcessing endProcessingSignal_;
0339     void watchEndProcessing(EndProcessing::slot_type const& iSlot) { endProcessingSignal_.connect(iSlot); }
0340     AR_WATCH_USING_METHOD_0(watchEndProcessing)
0341
0342     typedef signalslot::Signal<void(GlobalContext const&)> PreGlobalBeginRun;
0343     /// signal is emitted after the Run has been created by the InputSource but before any modules have seen the Run
0344     PreGlobalBeginRun preGlobalBeginRunSignal_;
0345     void watchPreGlobalBeginRun(PreGlobalBeginRun::slot_type const& iSlot) { preGlobalBeginRunSignal_.connect(iSlot); }
0346     AR_WATCH_USING_METHOD_1(watchPreGlobalBeginRun)
0347
0348     typedef signalslot::Signal<void(GlobalContext const&)> PostGlobalBeginRun;
0349     PostGlobalBeginRun postGlobalBeginRunSignal_;
0350     void watchPostGlobalBeginRun(PostGlobalBeginRun::slot_type const& iSlot) {
0351       postGlobalBeginRunSignal_.connect_front(iSlot);
0352     }
0353     AR_WATCH_USING_METHOD_1(watchPostGlobalBeginRun)
0354
0355     typedef signalslot::Signal<void(GlobalContext const&)> PreGlobalEndRun;
0356     PreGlobalEndRun preGlobalEndRunSignal_;
0357     void watchPreGlobalEndRun(PreGlobalEndRun::slot_type const& iSlot) { preGlobalEndRunSignal_.connect(iSlot); }
0358     AR_WATCH_USING_METHOD_1(watchPreGlobalEndRun)
0359
0360     typedef signalslot::Signal<void(GlobalContext const&)> PostGlobalEndRun;
0361     PostGlobalEndRun postGlobalEndRunSignal_;
0362     void watchPostGlobalEndRun(PostGlobalEndRun::slot_type const& iSlot) {
0363       postGlobalEndRunSignal_.connect_front(iSlot);
0364     }
0365     AR_WATCH_USING_METHOD_1(watchPostGlobalEndRun)
0366
0367     typedef signalslot::Signal<void(GlobalContext const&)> PreWriteProcessBlock;
0368     PreWriteProcessBlock preWriteProcessBlockSignal_;
0369     void watchPreWriteProcessBlock(PreWriteProcessBlock::slot_type const& iSlot) {
0370       preWriteProcessBlockSignal_.connect(iSlot);
0371     }
0372     AR_WATCH_USING_METHOD_1(watchPreWriteProcessBlock)
0373
0374     typedef signalslot::Signal<void(GlobalContext const&)> PostWriteProcessBlock;
0375     PostWriteProcessBlock postWriteProcessBlockSignal_;
0376     void watchPostWriteProcessBlock(PostWriteProcessBlock::slot_type const& iSlot) {
0377       postWriteProcessBlockSignal_.connect_front(iSlot);
0378     }
0379     AR_WATCH_USING_METHOD_1(watchPostWriteProcessBlock)
0380
0381     typedef signalslot::Signal<void(GlobalContext const&)> PreGlobalWriteRun;
0382     PreGlobalWriteRun preGlobalWriteRunSignal_;
0383     void watchPreGlobalWriteRun(PreGlobalWriteRun::slot_type const& iSlot) { preGlobalWriteRunSignal_.connect(iSlot); }
0384     AR_WATCH_USING_METHOD_1(watchPreGlobalWriteRun)
0385
0386     typedef signalslot::Signal<void(GlobalContext const&)> PostGlobalWriteRun;
0387     PostGlobalWriteRun postGlobalWriteRunSignal_;
0388     void watchPostGlobalWriteRun(PostGlobalWriteRun::slot_type const& iSlot) {
0389       postGlobalWriteRunSignal_.connect_front(iSlot);
0390     }
0391     AR_WATCH_USING_METHOD_1(watchPostGlobalWriteRun)
0392
0393     typedef signalslot::Signal<void(StreamContext const&)> PreStreamBeginRun;
0394     PreStreamBeginRun preStreamBeginRunSignal_;
0395     void watchPreStreamBeginRun(PreStreamBeginRun::slot_type const& iSlot) { preStreamBeginRunSignal_.connect(iSlot); }
0396     AR_WATCH_USING_METHOD_1(watchPreStreamBeginRun)
0397
0398     typedef signalslot::Signal<void(StreamContext const&)> PostStreamBeginRun;
0399     PostStreamBeginRun postStreamBeginRunSignal_;
0400     void watchPostStreamBeginRun(PostStreamBeginRun::slot_type const& iSlot) {
0401       postStreamBeginRunSignal_.connect_front(iSlot);
0402     }
0403     AR_WATCH_USING_METHOD_1(watchPostStreamBeginRun)
0404
0405     typedef signalslot::Signal<void(StreamContext const&)> PreStreamEndRun;
0406     PreStreamEndRun preStreamEndRunSignal_;
0407     void watchPreStreamEndRun(PreStreamEndRun::slot_type const& iSlot) { preStreamEndRunSignal_.connect(iSlot); }
0408     AR_WATCH_USING_METHOD_1(watchPreStreamEndRun)
0409
0410     typedef signalslot::Signal<void(StreamContext const&)> PostStreamEndRun;
0411     PostStreamEndRun postStreamEndRunSignal_;
0412     void watchPostStreamEndRun(PostStreamEndRun::slot_type const& iSlot) {
0413       postStreamEndRunSignal_.connect_front(iSlot);
0414     }
0415     AR_WATCH_USING_METHOD_1(watchPostStreamEndRun)
0416
0417     typedef signalslot::Signal<void(GlobalContext const&)> PreGlobalBeginLumi;
0418     PreGlobalBeginLumi preGlobalBeginLumiSignal_;
0419     void watchPreGlobalBeginLumi(PreGlobalBeginLumi::slot_type const& iSlot) {
0420       preGlobalBeginLumiSignal_.connect(iSlot);
0421     }
0422     AR_WATCH_USING_METHOD_1(watchPreGlobalBeginLumi)
0423
0424     typedef signalslot::Signal<void(GlobalContext const&)> PostGlobalBeginLumi;
0425     PostGlobalBeginLumi postGlobalBeginLumiSignal_;
0426     void watchPostGlobalBeginLumi(PostGlobalBeginLumi::slot_type const& iSlot) {
0427       postGlobalBeginLumiSignal_.connect_front(iSlot);
0428     }
0429     AR_WATCH_USING_METHOD_1(watchPostGlobalBeginLumi)
0430
0431     typedef signalslot::Signal<void(GlobalContext const&)> PreGlobalEndLumi;
0432     PreGlobalEndLumi preGlobalEndLumiSignal_;
0433     void watchPreGlobalEndLumi(PreGlobalEndLumi::slot_type const& iSlot) { preGlobalEndLumiSignal_.connect(iSlot); }
0434     AR_WATCH_USING_METHOD_1(watchPreGlobalEndLumi)
0435
0436     typedef signalslot::Signal<void(GlobalContext const&)> PostGlobalEndLumi;
0437     PostGlobalEndLumi postGlobalEndLumiSignal_;
0438     void watchPostGlobalEndLumi(PostGlobalEndLumi::slot_type const& iSlot) {
0439       postGlobalEndLumiSignal_.connect_front(iSlot);
0440     }
0441     AR_WATCH_USING_METHOD_1(watchPostGlobalEndLumi)
0442
0443     typedef signalslot::Signal<void(GlobalContext const&)> PreGlobalWriteLumi;
0444     PreGlobalEndLumi preGlobalWriteLumiSignal_;
0445     void watchPreGlobalWriteLumi(PreGlobalWriteLumi::slot_type const& iSlot) {
0446       preGlobalWriteLumiSignal_.connect(iSlot);
0447     }
0448     AR_WATCH_USING_METHOD_1(watchPreGlobalWriteLumi)
0449
0450     typedef signalslot::Signal<void(GlobalContext const&)> PostGlobalWriteLumi;
0451     PostGlobalEndLumi postGlobalWriteLumiSignal_;
0452     void watchPostGlobalWriteLumi(PostGlobalEndLumi::slot_type const& iSlot) {
0453       postGlobalWriteLumiSignal_.connect_front(iSlot);
0454     }
0455     AR_WATCH_USING_METHOD_1(watchPostGlobalWriteLumi)
0456
0457     typedef signalslot::Signal<void(StreamContext const&)> PreStreamBeginLumi;
0458     PreStreamBeginLumi preStreamBeginLumiSignal_;
0459     void watchPreStreamBeginLumi(PreStreamBeginLumi::slot_type const& iSlot) {
0460       preStreamBeginLumiSignal_.connect(iSlot);
0461     }
0462     AR_WATCH_USING_METHOD_1(watchPreStreamBeginLumi)
0463
0464     typedef signalslot::Signal<void(StreamContext const&)> PostStreamBeginLumi;
0465     PostStreamBeginLumi postStreamBeginLumiSignal_;
0466     void watchPostStreamBeginLumi(PostStreamBeginLumi::slot_type const& iSlot) {
0467       postStreamBeginLumiSignal_.connect_front(iSlot);
0468     }
0469     AR_WATCH_USING_METHOD_1(watchPostStreamBeginLumi)
0470
0471     typedef signalslot::Signal<void(StreamContext const&)> PreStreamEndLumi;
0472     PreStreamEndLumi preStreamEndLumiSignal_;
0473     void watchPreStreamEndLumi(PreStreamEndLumi::slot_type const& iSlot) { preStreamEndLumiSignal_.connect(iSlot); }
0474     AR_WATCH_USING_METHOD_1(watchPreStreamEndLumi)
0475
0476     typedef signalslot::Signal<void(StreamContext const&)> PostStreamEndLumi;
0477     PostStreamEndLumi postStreamEndLumiSignal_;
0478     void watchPostStreamEndLumi(PostStreamEndLumi::slot_type const& iSlot) {
0479       postStreamEndLumiSignal_.connect_front(iSlot);
0480     }
0481     AR_WATCH_USING_METHOD_1(watchPostStreamEndLumi)
0482
0483     typedef signalslot::Signal<void(StreamContext const&)> PreEvent;
0484     /// signal is emitted after the Event has been created by the InputSource but before any modules have seen the Event
0485     PreEvent preEventSignal_;
0486     void watchPreEvent(PreEvent::slot_type const& iSlot) { preEventSignal_.connect(iSlot); }
0487     AR_WATCH_USING_METHOD_1(watchPreEvent)
0488
0489     typedef signalslot::Signal<void(StreamContext const&)> PostEvent;
0490     /// signal is emitted after all modules have finished processing the Event
0491     PostEvent postEventSignal_;
0492     void watchPostEvent(PostEvent::slot_type const& iSlot) { postEventSignal_.connect_front(iSlot); }
0493     AR_WATCH_USING_METHOD_1(watchPostEvent)
0494
0495     /// signal is emitted before starting to process a Path for an event
0496     typedef signalslot::Signal<void(StreamContext const&, PathContext const&)> PrePathEvent;
0497     PrePathEvent prePathEventSignal_;
0498     void watchPrePathEvent(PrePathEvent::slot_type const& iSlot) { prePathEventSignal_.connect(iSlot); }
0499     AR_WATCH_USING_METHOD_2(watchPrePathEvent)
0500
0501     /// signal is emitted after all modules have finished for the Path for an event
0502     typedef signalslot::Signal<void(StreamContext const&, PathContext const&, HLTPathStatus const&)> PostPathEvent;
0503     PostPathEvent postPathEventSignal_;
0504     void watchPostPathEvent(PostPathEvent::slot_type const& iSlot) { postPathEventSignal_.connect_front(iSlot); }
0505     AR_WATCH_USING_METHOD_3(watchPostPathEvent)
0506
0507     /// signal is emitted when began processing a stream transition and
0508     ///  then we began terminating the application
0509     typedef signalslot::Signal<void(StreamContext const&, TerminationOrigin)> PreStreamEarlyTermination;
0510     PreStreamEarlyTermination preStreamEarlyTerminationSignal_;
0511     void watchPreStreamEarlyTermination(PreStreamEarlyTermination::slot_type const& iSlot) {
0512       preStreamEarlyTerminationSignal_.connect(iSlot);
0513     }
0514     AR_WATCH_USING_METHOD_2(watchPreStreamEarlyTermination)
0515
0516     /// signal is emitted if a began processing a global transition and
0517     ///  then we began terminating the application
0518     typedef signalslot::Signal<void(GlobalContext const&, TerminationOrigin)> PreGlobalEarlyTermination;
0519     PreGlobalEarlyTermination preGlobalEarlyTerminationSignal_;
0520     void watchPreGlobalEarlyTermination(PreGlobalEarlyTermination::slot_type const& iSlot) {
0521       preGlobalEarlyTerminationSignal_.connect(iSlot);
0522     }
0523     AR_WATCH_USING_METHOD_2(watchPreGlobalEarlyTermination)
0524
0525     /// signal is emitted if while communicating with a source we began terminating
0526     ///  the application
0527     typedef signalslot::Signal<void(TerminationOrigin)> PreSourceEarlyTermination;
0528     PreSourceEarlyTermination preSourceEarlyTerminationSignal_;
0529     void watchPreSourceEarlyTermination(PreSourceEarlyTermination::slot_type const& iSlot) {
0530       preSourceEarlyTerminationSignal_.connect(iSlot);
0531     }
0532     AR_WATCH_USING_METHOD_1(watchPreSourceEarlyTermination)
0533
0534     /// signal is emitted after the ESModule is registered with EventSetupProvider
0535     using PostESModuleRegistration = signalslot::Signal<void(eventsetup::ComponentDescription const&)>;
0536     PostESModuleRegistration postESModuleRegistrationSignal_;
0537     void watchPostESModuleRegistration(PostESModuleRegistration::slot_type const& iSlot) {
0538       postESModuleRegistrationSignal_.connect(iSlot);
0539     }
0540     AR_WATCH_USING_METHOD_1(watchPostESModuleRegistration)
0541
0542     /// signal is emitted when a new IOV may be needed so we queue a task to do that
0543     using ESSyncIOVQueuing = signalslot::Signal<void(IOVSyncValue const&)>;
0544     ESSyncIOVQueuing esSyncIOVQueuingSignal_;
0545     void watchESSyncIOVQueuing(ESSyncIOVQueuing::slot_type const& iSlot) { esSyncIOVQueuingSignal_.connect(iSlot); }
0546     AR_WATCH_USING_METHOD_1(watchESSyncIOVQueuing)
0547
0548     /// signal is emitted just before a new IOV is synchronized
0549     using PreESSyncIOV = signalslot::Signal<void(IOVSyncValue const&)>;
0550     PreESSyncIOV preESSyncIOVSignal_;
0551     void watchPreESSyncIOV(PreESSyncIOV::slot_type const& iSlot) { preESSyncIOVSignal_.connect(iSlot); }
0552     AR_WATCH_USING_METHOD_1(watchPreESSyncIOV)
0553
0554     /// signal is emitted just after a new IOV is synchronized
0555     using PostESSyncIOV = signalslot::Signal<void(IOVSyncValue const&)>;
0556     PostESSyncIOV postESSyncIOVSignal_;
0557     void watchPostESSyncIOV(PostESSyncIOV::slot_type const& iSlot) { postESSyncIOVSignal_.connect(iSlot); }
0558     AR_WATCH_USING_METHOD_1(watchPostESSyncIOV)
0559
0560     /// signal is emitted before the esmodule starts processing and before prefetching has started
0561     typedef signalslot::Signal<void(eventsetup::EventSetupRecordKey const&, ESModuleCallingContext const&)>
0562         PreESModulePrefetching;
0563     PreESModulePrefetching preESModulePrefetchingSignal_;
0564     void watchPreESModulePrefetching(PreESModulePrefetching::slot_type const& iSlot) {
0565       preESModulePrefetchingSignal_.connect(iSlot);
0566     }
0567     AR_WATCH_USING_METHOD_2(watchPreESModulePrefetching)
0568
0569     /// signal is emitted before the esmodule starts processing  and after prefetching has finished
0570     typedef signalslot::Signal<void(eventsetup::EventSetupRecordKey const&, ESModuleCallingContext const&)>
0571         PostESModulePrefetching;
0572     PostESModulePrefetching postESModulePrefetchingSignal_;
0573     void watchPostESModulePrefetching(PostESModulePrefetching::slot_type const& iSlot) {
0574       postESModulePrefetchingSignal_.connect_front(iSlot);
0575     }
0576     AR_WATCH_USING_METHOD_2(watchPostESModulePrefetching)
0577
0578     /// signal is emitted before the esmodule starts processing
0579     typedef signalslot::Signal<void(eventsetup::EventSetupRecordKey const&, ESModuleCallingContext const&)> PreESModule;
0580     PreESModule preESModuleSignal_;
0581     void watchPreESModule(PreESModule::slot_type const& iSlot) { preESModuleSignal_.connect(iSlot); }
0582     AR_WATCH_USING_METHOD_2(watchPreESModule)
0583
0584     /// signal is emitted after the esmodule finished processing
0585     typedef signalslot::Signal<void(eventsetup::EventSetupRecordKey const&, ESModuleCallingContext const&)> PostESModule;
0586     PostESModule postESModuleSignal_;
0587     void watchPostESModule(PostESModule::slot_type const& iSlot) { postESModuleSignal_.connect_front(iSlot); }
0588     AR_WATCH_USING_METHOD_2(watchPostESModule)
0589
0590     /// signal is emitted before an esmodule starts running its acquire method
0591     typedef signalslot::Signal<void(eventsetup::EventSetupRecordKey const&, ESModuleCallingContext const&)>
0592         PreESModuleAcquire;
0593     PreESModuleAcquire preESModuleAcquireSignal_;
0594     void watchPreESModuleAcquire(PreESModuleAcquire::slot_type const& iSlot) {
0595       preESModuleAcquireSignal_.connect(iSlot);
0596     }
0597     AR_WATCH_USING_METHOD_2(watchPreESModuleAcquire)
0598
0599     /// signal is emitted after an esmodule finishes running its acquire method
0600     typedef signalslot::Signal<void(eventsetup::EventSetupRecordKey const&, ESModuleCallingContext const&)>
0601         PostESModuleAcquire;
0602     PostESModuleAcquire postESModuleAcquireSignal_;
0603     void watchPostESModuleAcquire(PostESModuleAcquire::slot_type const& iSlot) {
0604       postESModuleAcquireSignal_.connect_front(iSlot);
0605     }
0606     AR_WATCH_USING_METHOD_2(watchPostESModuleAcquire)
0607
0608     /* Note M:
0609        Concerning use of address of module descriptor
0610        during functions called before/after module or source construction:
0611            Unlike the case in the Run, Lumi, and Event loops,
0612            the Module descriptor (often passed by pointer or reference
0613            as an argument named desc) in the construction phase is NOT
0614            at some permanent fixed address during the construction phase.
0615            Therefore, any optimization of caching the module name keying
0616            off of address of the descriptor will NOT be valid during
0617                such functions.  mf / cj 9/11/09
0618     */
0619
0620     /// signal is emitted before the module is constructed
0621     typedef signalslot::Signal<void(ModuleDescription const&)> PreModuleConstruction;
0622     PreModuleConstruction preModuleConstructionSignal_;
0623     void watchPreModuleConstruction(PreModuleConstruction::slot_type const& iSlot) {
0624       preModuleConstructionSignal_.connect(iSlot);
0625     }
0626     // WARNING - ModuleDescription is not in fixed place.  See note M above.
0627     AR_WATCH_USING_METHOD_1(watchPreModuleConstruction)
0628
0629     /// signal is emitted after the module was construction
0630     typedef signalslot::Signal<void(ModuleDescription const&)> PostModuleConstruction;
0631     PostModuleConstruction postModuleConstructionSignal_;
0632     void watchPostModuleConstruction(PostModuleConstruction::slot_type const& iSlot) {
0633       postModuleConstructionSignal_.connect_front(iSlot);
0634     }
0635     // WARNING - ModuleDescription is not in fixed place.  See note M above.
0636     AR_WATCH_USING_METHOD_1(watchPostModuleConstruction)
0637
0638     /// signal is emitted before the module is destructed, only for modules deleted before beginJob
0639     typedef signalslot::Signal<void(ModuleDescription const&)> PreModuleDestruction;
0640     PreModuleDestruction preModuleDestructionSignal_;
0641     void watchPreModuleDestruction(PreModuleDestruction::slot_type const& iSlot) {
0642       preModuleDestructionSignal_.connect(iSlot);
0643     }
0644     // note: ModuleDescription IS in the fixed place. See note M above.
0645     AR_WATCH_USING_METHOD_1(watchPreModuleDestruction)
0646
0647     /// signal is emitted after the module is destructed, only for modules deleted before beginJob
0648     typedef signalslot::Signal<void(ModuleDescription const&)> PostModuleDestruction;
0649     PostModuleDestruction postModuleDestructionSignal_;
0650     void watchPostModuleDestruction(PostModuleDestruction::slot_type const& iSlot) {
0651       postModuleDestructionSignal_.connect_front(iSlot);
0652     }
0653     // WARNING - ModuleDescription is not in fixed place.  See note M above.
0654     AR_WATCH_USING_METHOD_1(watchPostModuleDestruction)
0655
0656     /// signal is emitted before the module does beginJob
0657     typedef signalslot::Signal<void(ModuleDescription const&)> PreModuleBeginJob;
0658     PreModuleBeginJob preModuleBeginJobSignal_;
0659     void watchPreModuleBeginJob(PreModuleBeginJob::slot_type const& iSlot) { preModuleBeginJobSignal_.connect(iSlot); }
0660     AR_WATCH_USING_METHOD_1(watchPreModuleBeginJob)
0661
0662     /// signal is emitted after the module had done beginJob
0663     typedef signalslot::Signal<void(ModuleDescription const&)> PostModuleBeginJob;
0664     PostModuleBeginJob postModuleBeginJobSignal_;
0665     void watchPostModuleBeginJob(PostModuleBeginJob::slot_type const& iSlot) {
0666       postModuleBeginJobSignal_.connect_front(iSlot);
0667     }
0668     AR_WATCH_USING_METHOD_1(watchPostModuleBeginJob)
0669
0670     /// signal is emitted before the module does endJob
0671     typedef signalslot::Signal<void(ModuleDescription const&)> PreModuleEndJob;
0672     PreModuleEndJob preModuleEndJobSignal_;
0673     void watchPreModuleEndJob(PreModuleEndJob::slot_type const& iSlot) { preModuleEndJobSignal_.connect(iSlot); }
0674     AR_WATCH_USING_METHOD_1(watchPreModuleEndJob)
0675
0676     /// signal is emitted after the module had done endJob
0677     typedef signalslot::Signal<void(ModuleDescription const&)> PostModuleEndJob;
0678     PostModuleEndJob postModuleEndJobSignal_;
0679     void watchPostModuleEndJob(PostModuleEndJob::slot_type const& iSlot) {
0680       postModuleEndJobSignal_.connect_front(iSlot);
0681     }
0682     AR_WATCH_USING_METHOD_1(watchPostModuleEndJob)
0683
0684     /// signal is emitted before the module starts processing the Event and before prefetching has started
0685     typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PreModuleEventPrefetching;
0686     PreModuleEventPrefetching preModuleEventPrefetchingSignal_;
0687     void watchPreModuleEventPrefetching(PreModuleEventPrefetching::slot_type const& iSlot) {
0688       preModuleEventPrefetchingSignal_.connect(iSlot);
0689     }
0690     AR_WATCH_USING_METHOD_2(watchPreModuleEventPrefetching)
0691
0692     /// signal is emitted before the module starts processing the Event and after prefetching has finished
0693     typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PostModuleEventPrefetching;
0694     PostModuleEventPrefetching postModuleEventPrefetchingSignal_;
0695     void watchPostModuleEventPrefetching(PostModuleEventPrefetching::slot_type const& iSlot) {
0696       postModuleEventPrefetchingSignal_.connect_front(iSlot);
0697     }
0698     AR_WATCH_USING_METHOD_2(watchPostModuleEventPrefetching)
0699
0700     /// signal is emitted before the module starts processing the Event
0701     typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PreModuleEvent;
0702     PreModuleEvent preModuleEventSignal_;
0703     void watchPreModuleEvent(PreModuleEvent::slot_type const& iSlot) { preModuleEventSignal_.connect(iSlot); }
0704     AR_WATCH_USING_METHOD_2(watchPreModuleEvent)
0705
0706     /// signal is emitted after the module finished processing the Event
0707     typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PostModuleEvent;
0708     PostModuleEvent postModuleEventSignal_;
0709     void watchPostModuleEvent(PostModuleEvent::slot_type const& iSlot) { postModuleEventSignal_.connect_front(iSlot); }
0710     AR_WATCH_USING_METHOD_2(watchPostModuleEvent)
0711
0712     /// signal is emitted before the module starts the acquire method for the Event
0713     typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PreModuleEventAcquire;
0714     PreModuleEventAcquire preModuleEventAcquireSignal_;
0715     void watchPreModuleEventAcquire(PreModuleEventAcquire::slot_type const& iSlot) {
0716       preModuleEventAcquireSignal_.connect(iSlot);
0717     }
0718     AR_WATCH_USING_METHOD_2(watchPreModuleEventAcquire)
0719
0720     /// signal is emitted after the module finishes the acquire method for the Event
0721     typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PostModuleEventAcquire;
0722     PostModuleEventAcquire postModuleEventAcquireSignal_;
0723     void watchPostModuleEventAcquire(PostModuleEventAcquire::slot_type const& iSlot) {
0724       postModuleEventAcquireSignal_.connect_front(iSlot);
0725     }
0726     AR_WATCH_USING_METHOD_2(watchPostModuleEventAcquire)
0727
0728     /// signal is emitted after the module starts processing the Event and before a delayed get has started
0729     typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PreModuleEventDelayedGet;
0730     PreModuleEventDelayedGet preModuleEventDelayedGetSignal_;
0731     void watchPreModuleEventDelayedGet(PreModuleEventDelayedGet::slot_type const& iSlot) {
0732       preModuleEventDelayedGetSignal_.connect(iSlot);
0733     }
0734     AR_WATCH_USING_METHOD_2(watchPreModuleEventDelayedGet)
0735
0736     /// signal is emitted after the module starts processing the Event and after a delayed get has finished
0737     typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PostModuleEventDelayedGet;
0738     PostModuleEventDelayedGet postModuleEventDelayedGetSignal_;
0739     void watchPostModuleEventDelayedGet(PostModuleEventDelayedGet::slot_type const& iSlot) {
0740       postModuleEventDelayedGetSignal_.connect_front(iSlot);
0741     }
0742     AR_WATCH_USING_METHOD_2(watchPostModuleEventDelayedGet)
0743
0744     /// signal is emitted after the module starts processing the Event, after a delayed get has started, and before a source read
0745     typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PreEventReadFromSource;
0746     PreEventReadFromSource preEventReadFromSourceSignal_;
0747     void watchPreEventReadFromSource(PreEventReadFromSource::slot_type const& iSlot) {
0748       preEventReadFromSourceSignal_.connect(iSlot);
0749     }
0750     AR_WATCH_USING_METHOD_2(watchPreEventReadFromSource)
0751
0752     /// signal is emitted after the module starts processing the Event, after a delayed get has started, and after a source read
0753     typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PostEventReadFromSource;
0754     PostEventReadFromSource postEventReadFromSourceSignal_;
0755     void watchPostEventReadFromSource(PostEventReadFromSource::slot_type const& iSlot) {
0756       postEventReadFromSourceSignal_.connect_front(iSlot);
0757     }
0758     AR_WATCH_USING_METHOD_2(watchPostEventReadFromSource)
0759
0760     /// signal is emitted before the module starts processing a non-Event stream transition and before prefetching has started
0761     typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PreModuleStreamPrefetching;
0762     PreModuleStreamPrefetching preModuleStreamPrefetchingSignal_;
0763     void watchPreModuleStreamPrefetching(PreModuleStreamPrefetching::slot_type const& iSlot) {
0764       preModuleStreamPrefetchingSignal_.connect(iSlot);
0765     }
0766     AR_WATCH_USING_METHOD_2(watchPreModuleStreamPrefetching)
0767
0768     /// signal is emitted before the module starts processing a non-Event stream transition and after prefetching has finished
0769     typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PostModuleStreamPrefetching;
0770     PostModuleStreamPrefetching postModuleStreamPrefetchingSignal_;
0771     void watchPostModuleStreamPrefetching(PostModuleStreamPrefetching::slot_type const& iSlot) {
0772       postModuleStreamPrefetchingSignal_.connect_front(iSlot);
0773     }
0774     AR_WATCH_USING_METHOD_2(watchPostModuleStreamPrefetching)
0775
0776     typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PreModuleStreamBeginRun;
0777     PreModuleStreamBeginRun preModuleStreamBeginRunSignal_;
0778     void watchPreModuleStreamBeginRun(PreModuleStreamBeginRun::slot_type const& iSlot) {
0779       preModuleStreamBeginRunSignal_.connect(iSlot);
0780     }
0781     AR_WATCH_USING_METHOD_2(watchPreModuleStreamBeginRun)
0782
0783     typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PostModuleStreamBeginRun;
0784     PostModuleStreamBeginRun postModuleStreamBeginRunSignal_;
0785     void watchPostModuleStreamBeginRun(PostModuleStreamBeginRun::slot_type const& iSlot) {
0786       postModuleStreamBeginRunSignal_.connect_front(iSlot);
0787     }
0788     AR_WATCH_USING_METHOD_2(watchPostModuleStreamBeginRun)
0789
0790     typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PreModuleStreamEndRun;
0791     PreModuleStreamEndRun preModuleStreamEndRunSignal_;
0792     void watchPreModuleStreamEndRun(PreModuleStreamEndRun::slot_type const& iSlot) {
0793       preModuleStreamEndRunSignal_.connect(iSlot);
0794     }
0795     AR_WATCH_USING_METHOD_2(watchPreModuleStreamEndRun)
0796
0797     typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PostModuleStreamEndRun;
0798     PostModuleStreamEndRun postModuleStreamEndRunSignal_;
0799     void watchPostModuleStreamEndRun(PostModuleStreamEndRun::slot_type const& iSlot) {
0800       postModuleStreamEndRunSignal_.connect_front(iSlot);
0801     }
0802     AR_WATCH_USING_METHOD_2(watchPostModuleStreamEndRun)
0803
0804     typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PreModuleStreamBeginLumi;
0805     PreModuleStreamBeginLumi preModuleStreamBeginLumiSignal_;
0806     void watchPreModuleStreamBeginLumi(PreModuleStreamBeginLumi::slot_type const& iSlot) {
0807       preModuleStreamBeginLumiSignal_.connect(iSlot);
0808     }
0809     AR_WATCH_USING_METHOD_2(watchPreModuleStreamBeginLumi)
0810
0811     typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PostModuleStreamBeginLumi;
0812     PostModuleStreamBeginLumi postModuleStreamBeginLumiSignal_;
0813     void watchPostModuleStreamBeginLumi(PostModuleStreamBeginLumi::slot_type const& iSlot) {
0814       postModuleStreamBeginLumiSignal_.connect_front(iSlot);
0815     }
0816     AR_WATCH_USING_METHOD_2(watchPostModuleStreamBeginLumi)
0817
0818     typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PreModuleStreamEndLumi;
0819     PreModuleStreamEndLumi preModuleStreamEndLumiSignal_;
0820     void watchPreModuleStreamEndLumi(PreModuleStreamEndLumi::slot_type const& iSlot) {
0821       preModuleStreamEndLumiSignal_.connect(iSlot);
0822     }
0823     AR_WATCH_USING_METHOD_2(watchPreModuleStreamEndLumi)
0824
0825     typedef signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> PostModuleStreamEndLumi;
0826     PostModuleStreamEndLumi postModuleStreamEndLumiSignal_;
0827     void watchPostModuleStreamEndLumi(PostModuleStreamEndLumi::slot_type const& iSlot) {
0828       postModuleStreamEndLumiSignal_.connect_front(iSlot);
0829     }
0830     AR_WATCH_USING_METHOD_2(watchPostModuleStreamEndLumi)
0831
0832     typedef signalslot::Signal<void(GlobalContext const&, ModuleCallingContext const&)> PreModuleBeginProcessBlock;
0833     PreModuleBeginProcessBlock preModuleBeginProcessBlockSignal_;
0834     void watchPreModuleBeginProcessBlock(PreModuleBeginProcessBlock::slot_type const& iSlot) {
0835       preModuleBeginProcessBlockSignal_.connect(iSlot);
0836     }
0837     AR_WATCH_USING_METHOD_2(watchPreModuleBeginProcessBlock)
0838
0839     typedef signalslot::Signal<void(GlobalContext const&, ModuleCallingContext const&)> PostModuleBeginProcessBlock;
0840     PostModuleBeginProcessBlock postModuleBeginProcessBlockSignal_;
0841     void watchPostModuleBeginProcessBlock(PostModuleBeginProcessBlock::slot_type const& iSlot) {
0842       postModuleBeginProcessBlockSignal_.connect_front(iSlot);
0843     }
0844     AR_WATCH_USING_METHOD_2(watchPostModuleBeginProcessBlock)
0845
0846     typedef signalslot::Signal<void(GlobalContext const&, ModuleCallingContext const&)> PreModuleAccessInputProcessBlock;
0847     PreModuleAccessInputProcessBlock preModuleAccessInputProcessBlockSignal_;
0848     void watchPreModuleAccessInputProcessBlock(PreModuleAccessInputProcessBlock::slot_type const& iSlot) {
0849       preModuleAccessInputProcessBlockSignal_.connect(iSlot);
0850     }
0851     AR_WATCH_USING_METHOD_2(watchPreModuleAccessInputProcessBlock)
0852
0853     typedef signalslot::Signal<void(GlobalContext const&, ModuleCallingContext const&)>
0854         PostModuleAccessInputProcessBlock;
0855     PostModuleAccessInputProcessBlock postModuleAccessInputProcessBlockSignal_;
0856     void watchPostModuleAccessInputProcessBlock(PostModuleAccessInputProcessBlock::slot_type const& iSlot) {
0857       postModuleAccessInputProcessBlockSignal_.connect_front(iSlot);
0858     }
0859     AR_WATCH_USING_METHOD_2(watchPostModuleAccessInputProcessBlock)
0860
0861     typedef signalslot::Signal<void(GlobalContext const&, ModuleCallingContext const&)> PreModuleEndProcessBlock;
0862     PreModuleEndProcessBlock preModuleEndProcessBlockSignal_;
0863     void watchPreModuleEndProcessBlock(PreModuleEndProcessBlock::slot_type const& iSlot) {
0864       preModuleEndProcessBlockSignal_.connect(iSlot);
0865     }
0866     AR_WATCH_USING_METHOD_2(watchPreModuleEndProcessBlock)
0867
0868     typedef signalslot::Signal<void(GlobalContext const&, ModuleCallingContext const&)> PostModuleEndProcessBlock;
0869     PostModuleEndProcessBlock postModuleEndProcessBlockSignal_;
0870     void watchPostModuleEndProcessBlock(PostModuleEndProcessBlock::slot_type const& iSlot) {
0871       postModuleEndProcessBlockSignal_.connect_front(iSlot);
0872     }
0873     AR_WATCH_USING_METHOD_2(watchPostModuleEndProcessBlock)
0874
0875     /// signal is emitted before the module starts processing a global transition and before prefetching has started
0876     typedef signalslot::Signal<void(GlobalContext const&, ModuleCallingContext const&)> PreModuleGlobalPrefetching;
0877     PreModuleGlobalPrefetching preModuleGlobalPrefetchingSignal_;
0878     void watchPreModuleGlobalPrefetching(PreModuleGlobalPrefetching::slot_type const& iSlot) {
0879       preModuleGlobalPrefetchingSignal_.connect(iSlot);
0880     }
0881     AR_WATCH_USING_METHOD_2(watchPreModuleGlobalPrefetching)
0882
0883     /// signal is emitted before the module starts processing a global transition and after prefetching has finished
0884     typedef signalslot::Signal<void(GlobalContext const&, ModuleCallingContext const&)> PostModuleGlobalPrefetching;
0885     PostModuleGlobalPrefetching postModuleGlobalPrefetchingSignal_;
0886     void watchPostModuleGlobalPrefetching(PostModuleGlobalPrefetching::slot_type const& iSlot) {
0887       postModuleGlobalPrefetchingSignal_.connect_front(iSlot);
0888     }
0889     AR_WATCH_USING_METHOD_2(watchPostModuleGlobalPrefetching)
0890
0891     typedef signalslot::Signal<void(GlobalContext const&, ModuleCallingContext const&)> PreModuleGlobalBeginRun;
0892     PreModuleGlobalBeginRun preModuleGlobalBeginRunSignal_;
0893     void watchPreModuleGlobalBeginRun(PreModuleGlobalBeginRun::slot_type const& iSlot) {
0894       preModuleGlobalBeginRunSignal_.connect(iSlot);
0895     }
0896     AR_WATCH_USING_METHOD_2(watchPreModuleGlobalBeginRun)
0897
0898     typedef signalslot::Signal<void(GlobalContext const&, ModuleCallingContext const&)> PostModuleGlobalBeginRun;
0899     PostModuleGlobalBeginRun postModuleGlobalBeginRunSignal_;
0900     void watchPostModuleGlobalBeginRun(PostModuleGlobalBeginRun::slot_type const& iSlot) {
0901       postModuleGlobalBeginRunSignal_.connect_front(iSlot);
0902     }
0903     AR_WATCH_USING_METHOD_2(watchPostModuleGlobalBeginRun)
0904
0905     typedef signalslot::Signal<void(GlobalContext const&, ModuleCallingContext const&)> PreModuleGlobalEndRun;
0906     PreModuleGlobalEndRun preModuleGlobalEndRunSignal_;
0907     void watchPreModuleGlobalEndRun(PreModuleGlobalEndRun::slot_type const& iSlot) {
0908       preModuleGlobalEndRunSignal_.connect(iSlot);
0909     }
0910     AR_WATCH_USING_METHOD_2(watchPreModuleGlobalEndRun)
0911
0912     typedef signalslot::Signal<void(GlobalContext const&, ModuleCallingContext const&)> PostModuleGlobalEndRun;
0913     PostModuleGlobalEndRun postModuleGlobalEndRunSignal_;
0914     void watchPostModuleGlobalEndRun(PostModuleGlobalEndRun::slot_type const& iSlot) {
0915       postModuleGlobalEndRunSignal_.connect_front(iSlot);
0916     }
0917     AR_WATCH_USING_METHOD_2(watchPostModuleGlobalEndRun)
0918
0919     typedef signalslot::Signal<void(GlobalContext const&, ModuleCallingContext const&)> PreModuleGlobalBeginLumi;
0920     PreModuleGlobalBeginLumi preModuleGlobalBeginLumiSignal_;
0921     void watchPreModuleGlobalBeginLumi(PreModuleGlobalBeginLumi::slot_type const& iSlot) {
0922       preModuleGlobalBeginLumiSignal_.connect(iSlot);
0923     }
0924     AR_WATCH_USING_METHOD_2(watchPreModuleGlobalBeginLumi)
0925
0926     typedef signalslot::Signal<void(GlobalContext const&, ModuleCallingContext const&)> PostModuleGlobalBeginLumi;
0927     PostModuleGlobalBeginLumi postModuleGlobalBeginLumiSignal_;
0928     void watchPostModuleGlobalBeginLumi(PostModuleGlobalBeginLumi::slot_type const& iSlot) {
0929       postModuleGlobalBeginLumiSignal_.connect_front(iSlot);
0930     }
0931     AR_WATCH_USING_METHOD_2(watchPostModuleGlobalBeginLumi)
0932
0933     typedef signalslot::Signal<void(GlobalContext const&, ModuleCallingContext const&)> PreModuleGlobalEndLumi;
0934     PreModuleGlobalEndLumi preModuleGlobalEndLumiSignal_;
0935     void watchPreModuleGlobalEndLumi(PreModuleGlobalEndLumi::slot_type const& iSlot) {
0936       preModuleGlobalEndLumiSignal_.connect(iSlot);
0937     }
0938     AR_WATCH_USING_METHOD_2(watchPreModuleGlobalEndLumi)
0939
0940     typedef signalslot::Signal<void(GlobalContext const&, ModuleCallingContext const&)> PostModuleGlobalEndLumi;
0941     PostModuleGlobalEndLumi postModuleGlobalEndLumiSignal_;
0942     void watchPostModuleGlobalEndLumi(PostModuleGlobalEndLumi::slot_type const& iSlot) {
0943       postModuleGlobalEndLumiSignal_.connect_front(iSlot);
0944     }
0945     AR_WATCH_USING_METHOD_2(watchPostModuleGlobalEndLumi)
0946
0947     typedef signalslot::Signal<void(GlobalContext const&, ModuleCallingContext const&)> PreModuleWriteProcessBlock;
0948     PreModuleWriteProcessBlock preModuleWriteProcessBlockSignal_;
0949     void watchPreModuleWriteProcessBlock(PreModuleWriteProcessBlock::slot_type const& iSlot) {
0950       preModuleWriteProcessBlockSignal_.connect(iSlot);
0951     }
0952     AR_WATCH_USING_METHOD_2(watchPreModuleWriteProcessBlock)
0953
0954     typedef signalslot::Signal<void(GlobalContext const&, ModuleCallingContext const&)> PostModuleWriteProcessBlock;
0955     PostModuleWriteProcessBlock postModuleWriteProcessBlockSignal_;
0956     void watchPostModuleWriteProcessBlock(PostModuleWriteProcessBlock::slot_type const& iSlot) {
0957       postModuleWriteProcessBlockSignal_.connect_front(iSlot);
0958     }
0959     AR_WATCH_USING_METHOD_2(watchPostModuleWriteProcessBlock)
0960
0961     typedef signalslot::Signal<void(GlobalContext const&, ModuleCallingContext const&)> PreModuleWriteRun;
0962     PreModuleWriteRun preModuleWriteRunSignal_;
0963     void watchPreModuleWriteRun(PreModuleWriteRun::slot_type const& iSlot) { preModuleWriteRunSignal_.connect(iSlot); }
0964     AR_WATCH_USING_METHOD_2(watchPreModuleWriteRun)
0965
0966     typedef signalslot::Signal<void(GlobalContext const&, ModuleCallingContext const&)> PostModuleWriteRun;
0967     PostModuleWriteRun postModuleWriteRunSignal_;
0968     void watchPostModuleWriteRun(PostModuleWriteRun::slot_type const& iSlot) {
0969       postModuleWriteRunSignal_.connect_front(iSlot);
0970     }
0971     AR_WATCH_USING_METHOD_2(watchPostModuleWriteRun)
0972
0973     typedef signalslot::Signal<void(GlobalContext const&, ModuleCallingContext const&)> PreModuleWriteLumi;
0974     PreModuleWriteLumi preModuleWriteLumiSignal_;
0975     void watchPreModuleWriteLumi(PreModuleWriteLumi::slot_type const& iSlot) {
0976       preModuleWriteLumiSignal_.connect(iSlot);
0977     }
0978     AR_WATCH_USING_METHOD_2(watchPreModuleWriteLumi)
0979
0980     typedef signalslot::Signal<void(GlobalContext const&, ModuleCallingContext const&)> PostModuleWriteLumi;
0981     PostModuleWriteLumi postModuleWriteLumiSignal_;
0982     void watchPostModuleWriteLumi(PostModuleWriteLumi::slot_type const& iSlot) {
0983       postModuleWriteLumiSignal_.connect_front(iSlot);
0984     }
0985     AR_WATCH_USING_METHOD_2(watchPostModuleWriteLumi)
0986
0987     /// signal is emitted before the source is constructed
0988     typedef signalslot::Signal<void(ModuleDescription const&)> PreSourceConstruction;
0989     PreSourceConstruction preSourceConstructionSignal_;
0990     void watchPreSourceConstruction(PreSourceConstruction::slot_type const& iSlot) {
0991       preSourceConstructionSignal_.connect(iSlot);
0992     }
0993     // WARNING - ModuleDescription is not in fixed place.  See note M above.
0994     AR_WATCH_USING_METHOD_1(watchPreSourceConstruction)
0995
0996     /// signal is emitted after the source was construction
0997     typedef signalslot::Signal<void(ModuleDescription const&)> PostSourceConstruction;
0998     PostSourceConstruction postSourceConstructionSignal_;
0999     void watchPostSourceConstruction(PostSourceConstruction::slot_type const& iSlot) {
1000       postSourceConstructionSignal_.connect_front(iSlot);
1001     }
1002     // WARNING - ModuleDescription is not in fixed place.  See note M above.
1003     AR_WATCH_USING_METHOD_1(watchPostSourceConstruction)
1004
1005     // ---------- member functions ---------------------------
1006
1007     ///forwards our signals to slots connected to iOther
1008     void connect(ActivityRegistry& iOther);
1009
1010     ///forwards our subprocess independent signals to slots connected to iOther
1011     ///forwards iOther's subprocess dependent signals to slots connected to this
1012     void connectToSubProcess(ActivityRegistry& iOther);
1013
1014     ///copy the slots from iOther and connect them directly to our own
1015     /// this allows us to 'forward' signals more efficiently,
1016     /// BUT if iOther gains new slots after this call, we will not see them
1017     /// This is also careful to keep the order of the slots proper
1018     /// for services.
1019     void copySlotsFrom(ActivityRegistry& iOther);
1020
1021   private:
1022     // forwards subprocess independent signals to slots connected to iOther
1023     void connectGlobals(ActivityRegistry& iOther);
1024
1025     // forwards subprocess dependent signals to slots connected to iOther
1026     void connectLocals(ActivityRegistry& iOther);
1027   };
1028 }  // namespace edm
1029 #undef AR_WATCH_USING_METHOD
1030 #endif