ServiceRegistry/interface/ActivityRegistry.h

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