Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2024-07-28 22:48:28 

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

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!