Reference Manual

Go to the documentation of this file.
00001 #ifndef FWCore_ServiceRegistry_ActivityRegistry_h
00002 #define FWCore_ServiceRegistry_ActivityRegistry_h
00003 // -*- C++ -*-
00004 //
00005 // Package:     ServiceRegistry
00006 // Class  :     ActivityRegistry
00007 // 
00016 //
00017 // Original Author:  Chris Jones
00018 //         Created:  Mon Sep  5 19:53:09 EDT 2005
00019 //
00020 
00021 // system include files
00022 //#include "boost/signal.hpp"
00023 #include "FWCore/Utilities/interface/Signal.h"
00024 #include "boost/bind.hpp"
00025 #include "boost/mem_fn.hpp"
00026 #include "boost/utility.hpp"
00027 
00028 // user include files
00029 
00030 #define AR_WATCH_USING_METHOD_0(method) template<class TClass, class TMethod> void method (TClass* iObject, TMethod iMethod) { method (boost::bind(boost::mem_fn(iMethod), iObject)); }
00031 #define AR_WATCH_USING_METHOD_1(method) template<class TClass, class TMethod> void method (TClass* iObject, TMethod iMethod) { method (boost::bind(boost::mem_fn(iMethod), iObject, _1)); }
00032 #define AR_WATCH_USING_METHOD_2(method) template<class TClass, class TMethod> void method (TClass* iObject, TMethod iMethod) { method (boost::bind(boost::mem_fn(iMethod), iObject, _1, _2)); }
00033 // forward declarations
00034 namespace edm {
00035    class EventID;
00036    class LuminosityBlockID;
00037    class RunID;
00038    class Timestamp;
00039    class ModuleDescription;
00040    class Event;
00041    class LuminosityBlock;
00042    class Run;
00043    class EventSetup;
00044    class HLTPathStatus;
00045    
00046    class ActivityRegistry : private boost::noncopyable {
00047    public:
00048       ActivityRegistry() {}
00049 
00050       // ---------- signals ------------------------------------
00051       typedef signalslot::Signal<void()> PostBeginJob;
00053       PostBeginJob postBeginJobSignal_;
00055       void watchPostBeginJob(PostBeginJob::slot_type const& iSlot) {
00056          postBeginJobSignal_.connect(iSlot);
00057       }
00058       AR_WATCH_USING_METHOD_0(watchPostBeginJob)
00059 
00060       typedef signalslot::Signal<void()> PostEndJob;
00062       PostEndJob postEndJobSignal_;
00063       void watchPostEndJob(PostEndJob::slot_type const& iSlot) {
00064          postEndJobSignal_.connect_front(iSlot);
00065       }
00066       AR_WATCH_USING_METHOD_0(watchPostEndJob)
00067 
00068       typedef signalslot::Signal<void()> JobFailure;
00071       JobFailure    jobFailureSignal_;
00073       void watchJobFailure(JobFailure::slot_type const& iSlot) {
00074          jobFailureSignal_.connect_front(iSlot);
00075       }
00076       AR_WATCH_USING_METHOD_0(watchJobFailure)
00077       
00078       
00079       typedef signalslot::Signal<void()> PreSource;
00080       PreSource preSourceSignal_;
00081       void watchPreSource(PreSource::slot_type const& iSlot) {
00082         preSourceSignal_.connect(iSlot);
00083       }
00084       AR_WATCH_USING_METHOD_0(watchPreSource)
00085 
00086       
00087       typedef signalslot::Signal<void()> PostSource;
00088       PostSource postSourceSignal_;
00089       void watchPostSource(PostSource::slot_type const& iSlot) {
00090          postSourceSignal_.connect_front(iSlot);
00091       }
00092       AR_WATCH_USING_METHOD_0(watchPostSource)
00093         
00094       
00095       typedef signalslot::Signal<void()> PreSourceLumi;
00096       PreSourceLumi preSourceLumiSignal_;
00097       void watchPreSourceLumi(PreSourceLumi::slot_type const& iSlot) {
00098         preSourceLumiSignal_.connect(iSlot);
00099       }
00100       AR_WATCH_USING_METHOD_0(watchPreSourceLumi)
00101 
00102       
00103       typedef signalslot::Signal<void()> PostSourceLumi;
00104       PostSourceLumi postSourceLumiSignal_;
00105       void watchPostSourceLumi(PostSourceLumi::slot_type const& iSlot) {
00106          postSourceLumiSignal_.connect_front(iSlot);
00107       }
00108       AR_WATCH_USING_METHOD_0(watchPostSourceLumi)
00109         
00110       
00111       typedef signalslot::Signal<void()> PreSourceRun;
00112       PreSourceRun preSourceRunSignal_;
00113       void watchPreSourceRun(PreSourceRun::slot_type const& iSlot) {
00114         preSourceRunSignal_.connect(iSlot);
00115       }
00116       AR_WATCH_USING_METHOD_0(watchPreSourceRun)
00117 
00118       
00119       typedef signalslot::Signal<void()> PostSourceRun;
00120       PostSourceRun postSourceRunSignal_;
00121       void watchPostSourceRun(PostSourceRun::slot_type const& iSlot) {
00122          postSourceRunSignal_.connect_front(iSlot);
00123       }
00124       AR_WATCH_USING_METHOD_0(watchPostSourceRun)
00125         
00126       
00127       typedef signalslot::Signal<void()> PreOpenFile;
00128       PreOpenFile preOpenFileSignal_;
00129       void watchPreOpenFile(PreOpenFile::slot_type const& iSlot) {
00130         preOpenFileSignal_.connect(iSlot);
00131       }
00132       AR_WATCH_USING_METHOD_0(watchPreOpenFile)
00133 
00134       
00135       //   Note this is only done for a primary file, not a secondary one.
00136       typedef signalslot::Signal<void()> PostOpenFile;
00137       PostOpenFile postOpenFileSignal_;
00138       void watchPostOpenFile(PostOpenFile::slot_type const& iSlot) {
00139          postOpenFileSignal_.connect_front(iSlot);
00140       }
00141       AR_WATCH_USING_METHOD_0(watchPostOpenFile)
00142         
00143       
00144       //   First argument is the LFN of the file which is being closed.
00145       //   Second argument is false if fallback is used; true otherwise.
00146       typedef signalslot::Signal<void(std::string const&, bool)> PreCloseFile;
00147       PreCloseFile preCloseFileSignal_;
00148       void watchPreCloseFile(PreCloseFile::slot_type const& iSlot) {
00149         preCloseFileSignal_.connect(iSlot);
00150       }
00151       AR_WATCH_USING_METHOD_2(watchPreCloseFile)
00152 
00153       
00154       typedef signalslot::Signal<void()> PostCloseFile;
00155       PostCloseFile postCloseFileSignal_;
00156       void watchPostCloseFile(PostCloseFile::slot_type const& iSlot) {
00157          postCloseFileSignal_.connect_front(iSlot);
00158       }
00159       AR_WATCH_USING_METHOD_0(watchPostCloseFile)
00160         
00161       typedef signalslot::Signal<void(EventID const&, Timestamp const&)> PreProcessEvent;
00163       PreProcessEvent preProcessEventSignal_;
00164       void watchPreProcessEvent(PreProcessEvent::slot_type const& iSlot) {
00165          preProcessEventSignal_.connect(iSlot);
00166       }
00167       AR_WATCH_USING_METHOD_2(watchPreProcessEvent)
00168       
00169       typedef signalslot::Signal<void(Event const&, EventSetup const&)> PostProcessEvent;
00171       PostProcessEvent postProcessEventSignal_;
00172       void watchPostProcessEvent(PostProcessEvent::slot_type const& iSlot) {
00173          postProcessEventSignal_.connect_front(iSlot);
00174       }
00175       AR_WATCH_USING_METHOD_2(watchPostProcessEvent)
00176 
00177       typedef signalslot::Signal<void(RunID const&, Timestamp const&)> PreBeginRun;
00179       PreBeginRun preBeginRunSignal_;
00180       void watchPreBeginRun(PreBeginRun::slot_type const& iSlot) {
00181          preBeginRunSignal_.connect(iSlot);
00182       }
00183       AR_WATCH_USING_METHOD_2(watchPreBeginRun)
00184       
00185       typedef signalslot::Signal<void(Run const&, EventSetup const&)> PostBeginRun;
00187       PostBeginRun postBeginRunSignal_;
00188       void watchPostBeginRun(PostBeginRun::slot_type const& iSlot) {
00189          postBeginRunSignal_.connect_front(iSlot);
00190       }
00191       AR_WATCH_USING_METHOD_2(watchPostBeginRun)
00192 
00193       typedef signalslot::Signal<void(RunID const&, Timestamp const&)> PreEndRun;
00195       PreEndRun preEndRunSignal_;
00196       void watchPreEndRun(PreEndRun::slot_type const& iSlot) {
00197          preEndRunSignal_.connect(iSlot);
00198       }
00199       AR_WATCH_USING_METHOD_2(watchPreEndRun)
00200       
00201       typedef signalslot::Signal<void(Run const&, EventSetup const&)> PostEndRun;
00203       PostEndRun postEndRunSignal_;
00204       void watchPostEndRun(PostEndRun::slot_type const& iSlot) {
00205          postEndRunSignal_.connect_front(iSlot);
00206       }
00207       AR_WATCH_USING_METHOD_2(watchPostEndRun)
00208 
00209       typedef signalslot::Signal<void(LuminosityBlockID const&, Timestamp const&)> PreBeginLumi;
00211       PreBeginLumi preBeginLumiSignal_;
00212       void watchPreBeginLumi(PreBeginLumi::slot_type const& iSlot) {
00213          preBeginLumiSignal_.connect(iSlot);
00214       }
00215       AR_WATCH_USING_METHOD_2(watchPreBeginLumi)
00216       
00217       typedef signalslot::Signal<void(LuminosityBlock const&, EventSetup const&)> PostBeginLumi;
00219       PostBeginLumi postBeginLumiSignal_;
00220       void watchPostBeginLumi(PostBeginLumi::slot_type const& iSlot) {
00221          postBeginLumiSignal_.connect_front(iSlot);
00222       }
00223       AR_WATCH_USING_METHOD_2(watchPostBeginLumi)
00224 
00225       typedef signalslot::Signal<void(LuminosityBlockID const&, Timestamp const&)> PreEndLumi;
00227       PreEndLumi preEndLumiSignal_;
00228       void watchPreEndLumi(PreEndLumi::slot_type const& iSlot) {
00229          preEndLumiSignal_.connect(iSlot);
00230       }
00231       AR_WATCH_USING_METHOD_2(watchPreEndLumi)
00232       
00233       typedef signalslot::Signal<void(LuminosityBlock const&, EventSetup const&)> PostEndLumi;
00235       PostEndLumi postEndLumiSignal_;
00236       void watchPostEndLumi(PostEndLumi::slot_type const& iSlot) {
00237          postEndLumiSignal_.connect_front(iSlot);
00238       }
00239       AR_WATCH_USING_METHOD_2(watchPostEndLumi)
00240 
00241       
00242       typedef signalslot::Signal<void(std::string const&)> PreProcessPath;
00243       PreProcessPath preProcessPathSignal_;
00244       void watchPreProcessPath(PreProcessPath::slot_type const& iSlot) {
00245         preProcessPathSignal_.connect(iSlot);
00246       }
00247       AR_WATCH_USING_METHOD_1(watchPreProcessPath)
00248         
00249       
00250       typedef signalslot::Signal<void(std::string const&, HLTPathStatus const&)> PostProcessPath;
00251       PostProcessPath postProcessPathSignal_;
00252       void watchPostProcessPath(PostProcessPath::slot_type const& iSlot) {
00253          postProcessPathSignal_.connect_front(iSlot);
00254       }  
00255       AR_WATCH_USING_METHOD_2(watchPostProcessPath)
00256         
00257       
00258       typedef signalslot::Signal<void(std::string const&)> PrePathBeginRun;
00259       PrePathBeginRun prePathBeginRunSignal_;
00260       void watchPrePathBeginRun(PrePathBeginRun::slot_type const& iSlot) {
00261         prePathBeginRunSignal_.connect(iSlot);
00262       }
00263       AR_WATCH_USING_METHOD_1(watchPrePathBeginRun)
00264         
00265       
00266       typedef signalslot::Signal<void(std::string const&, HLTPathStatus const&)> PostPathBeginRun;
00267       PostPathBeginRun postPathBeginRunSignal_;
00268       void watchPostPathBeginRun(PostPathBeginRun::slot_type const& iSlot) {
00269          postPathBeginRunSignal_.connect_front(iSlot);
00270       }  
00271       AR_WATCH_USING_METHOD_2(watchPostPathBeginRun)
00272         
00273       
00274       typedef signalslot::Signal<void(std::string const&)> PrePathEndRun;
00275       PrePathEndRun prePathEndRunSignal_;
00276       void watchPrePathEndRun(PrePathEndRun::slot_type const& iSlot) {
00277         prePathEndRunSignal_.connect(iSlot);
00278       }
00279       AR_WATCH_USING_METHOD_1(watchPrePathEndRun)
00280         
00281       
00282       typedef signalslot::Signal<void(std::string const&, HLTPathStatus const&)> PostPathEndRun;
00283       PostPathEndRun postPathEndRunSignal_;
00284       void watchPostPathEndRun(PostPathEndRun::slot_type const& iSlot) {
00285          postPathEndRunSignal_.connect_front(iSlot);
00286       }  
00287       AR_WATCH_USING_METHOD_2(watchPostPathEndRun)
00288         
00289       
00290       typedef signalslot::Signal<void(std::string const&)> PrePathBeginLumi;
00291       PrePathBeginLumi prePathBeginLumiSignal_;
00292       void watchPrePathBeginLumi(PrePathBeginLumi::slot_type const& iSlot) {
00293         prePathBeginLumiSignal_.connect(iSlot);
00294       }
00295       AR_WATCH_USING_METHOD_1(watchPrePathBeginLumi)
00296         
00297       
00298       typedef signalslot::Signal<void(std::string const&, HLTPathStatus const&)> PostPathBeginLumi;
00299       PostPathBeginLumi postPathBeginLumiSignal_;
00300       void watchPostPathBeginLumi(PostPathBeginLumi::slot_type const& iSlot) {
00301          postPathBeginLumiSignal_.connect_front(iSlot);
00302       }  
00303       AR_WATCH_USING_METHOD_2(watchPostPathBeginLumi)
00304         
00305       
00306       typedef signalslot::Signal<void(std::string const&)> PrePathEndLumi;
00307       PrePathEndLumi prePathEndLumiSignal_;
00308       void watchPrePathEndLumi(PrePathEndLumi::slot_type const& iSlot) {
00309         prePathEndLumiSignal_.connect(iSlot);
00310       }
00311       AR_WATCH_USING_METHOD_1(watchPrePathEndLumi)
00312         
00313       
00314       typedef signalslot::Signal<void(std::string const&, HLTPathStatus const&)> PostPathEndLumi;
00315       PostPathEndLumi postPathEndLumiSignal_;
00316       void watchPostPathEndLumi(PostPathEndLumi::slot_type const& iSlot) {
00317          postPathEndLumiSignal_.connect_front(iSlot);
00318       }  
00319       AR_WATCH_USING_METHOD_2(watchPostPathEndLumi)
00320 
00321         /* Note M:
00322            Concerning use of address of module descriptor
00323            during functions called before/after module or source construction:
00324                Unlike the case in the Run, Lumi, and Event loops,
00325                the Module descriptor (often passed by pointer or reference
00326                as an argument named desc) in the construction phase is NOT
00327                at some permanent fixed address during the construction phase.  
00328                Therefore, any optimization of caching the module name keying 
00329                off of address of the descriptor will NOT be valid during 
00330                such functions.  mf / cj 9/11/09
00331         */
00332         
00333       
00334       typedef signalslot::Signal<void(ModuleDescription const&)> PreModuleConstruction;
00335       PreModuleConstruction preModuleConstructionSignal_;
00336       void watchPreModuleConstruction(PreModuleConstruction::slot_type const& iSlot) {
00337          preModuleConstructionSignal_.connect(iSlot);
00338       }
00339       // WARNING - ModuleDescription is not in fixed place.  See note M above.
00340       AR_WATCH_USING_METHOD_1(watchPreModuleConstruction)
00341          
00342       
00343       typedef signalslot::Signal<void(ModuleDescription const&)> PostModuleConstruction;
00344       PostModuleConstruction postModuleConstructionSignal_;
00345       void watchPostModuleConstruction(PostModuleConstruction::slot_type const& iSlot) {
00346          postModuleConstructionSignal_.connect_front(iSlot);
00347       }
00348       // WARNING - ModuleDescription is not in fixed place.  See note M above.
00349       AR_WATCH_USING_METHOD_1(watchPostModuleConstruction)
00350 
00351       
00352       typedef signalslot::Signal<void(ModuleDescription const&)> PreModuleBeginJob;
00353       PreModuleBeginJob preModuleBeginJobSignal_;
00354       void watchPreModuleBeginJob(PreModuleBeginJob::slot_type const& iSlot) {
00355         preModuleBeginJobSignal_.connect(iSlot);
00356       }
00357       AR_WATCH_USING_METHOD_1(watchPreModuleBeginJob)
00358         
00359       
00360       typedef signalslot::Signal<void(ModuleDescription const&)> PostModuleBeginJob;
00361       PostModuleBeginJob postModuleBeginJobSignal_;
00362       void watchPostModuleBeginJob(PostModuleBeginJob::slot_type const& iSlot) {
00363          postModuleBeginJobSignal_.connect_front(iSlot);
00364       }
00365       AR_WATCH_USING_METHOD_1(watchPostModuleBeginJob)
00366         
00367       
00368       typedef signalslot::Signal<void(ModuleDescription const&)> PreModuleEndJob;
00369       PreModuleEndJob preModuleEndJobSignal_;
00370       void watchPreModuleEndJob(PreModuleEndJob::slot_type const& iSlot) {
00371         preModuleEndJobSignal_.connect(iSlot);
00372       }
00373       AR_WATCH_USING_METHOD_1(watchPreModuleEndJob)
00374         
00375       
00376       typedef signalslot::Signal<void(ModuleDescription const&)> PostModuleEndJob;
00377       PostModuleEndJob postModuleEndJobSignal_;
00378       void watchPostModuleEndJob(PostModuleEndJob::slot_type const& iSlot) {
00379          postModuleEndJobSignal_.connect_front(iSlot);
00380       }
00381       AR_WATCH_USING_METHOD_1(watchPostModuleEndJob)
00382         
00383       
00384       typedef signalslot::Signal<void(ModuleDescription const&)> PreModule;
00385       PreModule preModuleSignal_;
00386       void watchPreModule(PreModule::slot_type const& iSlot) {
00387          preModuleSignal_.connect(iSlot);
00388       }
00389       AR_WATCH_USING_METHOD_1(watchPreModule)
00390          
00391       
00392       typedef signalslot::Signal<void(ModuleDescription const&)> PostModule;
00393       PostModule postModuleSignal_;
00394       void watchPostModule(PostModule::slot_type const& iSlot) {
00395          postModuleSignal_.connect_front(iSlot);
00396       }
00397       AR_WATCH_USING_METHOD_1(watchPostModule)
00398          
00399       
00400       typedef signalslot::Signal<void(ModuleDescription const&)> PreModuleBeginRun;
00401       PreModuleBeginRun preModuleBeginRunSignal_;
00402       void watchPreModuleBeginRun(PreModuleBeginRun::slot_type const& iSlot) {
00403          preModuleBeginRunSignal_.connect(iSlot);
00404       }
00405       AR_WATCH_USING_METHOD_1(watchPreModuleBeginRun)
00406          
00407       
00408       typedef signalslot::Signal<void(ModuleDescription const&)> PostModuleBeginRun;
00409       PostModuleBeginRun postModuleBeginRunSignal_;
00410       void watchPostModuleBeginRun(PostModuleBeginRun::slot_type const& iSlot) {
00411          postModuleBeginRunSignal_.connect_front(iSlot);
00412          
00413       }
00414       AR_WATCH_USING_METHOD_1(watchPostModuleBeginRun)
00415          
00416       
00417       typedef signalslot::Signal<void(ModuleDescription const&)> PreModuleEndRun;
00418       PreModuleEndRun preModuleEndRunSignal_;
00419       void watchPreModuleEndRun(PreModuleEndRun::slot_type const& iSlot) {
00420          preModuleEndRunSignal_.connect(iSlot);
00421       }
00422       AR_WATCH_USING_METHOD_1(watchPreModuleEndRun)
00423          
00424       
00425       typedef signalslot::Signal<void(ModuleDescription const&)> PostModuleEndRun;
00426       PostModuleEndRun postModuleEndRunSignal_;
00427       void watchPostModuleEndRun(PostModuleEndRun::slot_type const& iSlot) {
00428          postModuleEndRunSignal_.connect_front(iSlot);
00429       }
00430       AR_WATCH_USING_METHOD_1(watchPostModuleEndRun)
00431          
00432       
00433       typedef signalslot::Signal<void(ModuleDescription const&)> PreModuleBeginLumi;
00434       PreModuleBeginLumi preModuleBeginLumiSignal_;
00435       void watchPreModuleBeginLumi(PreModuleBeginLumi::slot_type const& iSlot) {
00436          preModuleBeginLumiSignal_.connect(iSlot);
00437       }
00438       AR_WATCH_USING_METHOD_1(watchPreModuleBeginLumi)
00439          
00440       
00441       typedef signalslot::Signal<void(ModuleDescription const&)> PostModuleBeginLumi;
00442       PostModuleBeginLumi postModuleBeginLumiSignal_;
00443       void watchPostModuleBeginLumi(PostModuleBeginLumi::slot_type const& iSlot) {
00444          postModuleBeginLumiSignal_.connect_front(iSlot);
00445       }
00446       AR_WATCH_USING_METHOD_1(watchPostModuleBeginLumi)
00447          
00448       
00449       typedef signalslot::Signal<void(ModuleDescription const&)> PreModuleEndLumi;
00450       PreModuleEndLumi preModuleEndLumiSignal_;
00451       void watchPreModuleEndLumi(PreModuleEndLumi::slot_type const& iSlot) {
00452          preModuleEndLumiSignal_.connect(iSlot);
00453       }
00454       AR_WATCH_USING_METHOD_1(watchPreModuleEndLumi)
00455          
00456       
00457       typedef signalslot::Signal<void(ModuleDescription const&)> PostModuleEndLumi;
00458       PostModuleEndLumi postModuleEndLumiSignal_;
00459       void watchPostModuleEndLumi(PostModuleEndLumi::slot_type const& iSlot) {
00460          postModuleEndLumiSignal_.connect_front(iSlot);
00461       }
00462       AR_WATCH_USING_METHOD_1(watchPostModuleEndLumi)
00463          
00464       
00465       typedef signalslot::Signal<void(ModuleDescription const&)> PreSourceConstruction;
00466       PreSourceConstruction preSourceConstructionSignal_;
00467       void watchPreSourceConstruction(PreSourceConstruction::slot_type const& iSlot) {
00468         preSourceConstructionSignal_.connect(iSlot);
00469       }
00470       // WARNING - ModuleDescription is not in fixed place.  See note M above.
00471       AR_WATCH_USING_METHOD_1(watchPreSourceConstruction)
00472         
00473       
00474       typedef signalslot::Signal<void(ModuleDescription const&)> PostSourceConstruction;
00475       PostSourceConstruction postSourceConstructionSignal_;
00476       void watchPostSourceConstruction(PostSourceConstruction::slot_type const& iSlot) {
00477          postSourceConstructionSignal_.connect_front(iSlot);
00478       }
00479       // WARNING - ModuleDescription is not in fixed place.  See note M above.
00480       AR_WATCH_USING_METHOD_1(watchPostSourceConstruction)
00481 
00482       
00483       typedef signalslot::Signal<void()> PreForkReleaseResources;
00484       PreForkReleaseResources preForkReleaseResourcesSignal_;
00485       void watchPreForkReleaseResources(PreForkReleaseResources::slot_type const& iSlot) {
00486          preForkReleaseResourcesSignal_.connect_front(iSlot);
00487       }
00488       AR_WATCH_USING_METHOD_0(watchPreForkReleaseResources)
00489       
00490       
00491       typedef signalslot::Signal<void(unsigned int, unsigned int)> PostForkReacquireResources;
00492       PostForkReacquireResources postForkReacquireResourcesSignal_;
00493       void watchPostForkReacquireResources(PostForkReacquireResources::slot_type const& iSlot) {
00494          postForkReacquireResourcesSignal_.connect_front(iSlot);
00495       }
00496       AR_WATCH_USING_METHOD_2(watchPostForkReacquireResources)
00497       
00498       // ---------- member functions ---------------------------
00499       
00500       
00501       void connect(ActivityRegistry& iOther);
00502 
00505       void connectToSubProcess(ActivityRegistry& iOther);
00506       
00512       void copySlotsFrom(ActivityRegistry& iOther);
00513       
00514    private:
00515       // forwards subprocess independent signals to slots connected to iOther
00516       void connectGlobals(ActivityRegistry& iOther);
00517 
00518       // forwards subprocess dependent signals to slots connected to iOther
00519       void connectLocals(ActivityRegistry& iOther);
00520    };
00521 }
00522 #undef AR_WATCH_USING_METHOD
00523 #endif
/afs/cern.ch/work/a/aaltunda/public/www/CMSSW_6_2_7/src/FWCore/ServiceRegistry/interface/ActivityRegistry.h
