/data/refman/pasoursint/CMSSW_6_1_1/src/FWCore/ServiceRegistry/interface/ActivityRegistry.h

Go to the documentation of this file.

#ifndef FWCore_ServiceRegistry_ActivityRegistry_h
#define FWCore_ServiceRegistry_ActivityRegistry_h
// -*- C++ -*-
//
// Package:     ServiceRegistry
// Class  :     ActivityRegistry
// 
//
// Original Author:  Chris Jones
//         Created:  Mon Sep  5 19:53:09 EDT 2005
//

// system include files
//#include "boost/signal.hpp"
#include "sigc++/signal.h"
#include "boost/bind.hpp"
#include "boost/mem_fn.hpp"
#include "boost/utility.hpp"

// user include files

#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)); }
#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)); }
#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)); }
// forward declarations
namespace edm {
   class EventID;
   class LuminosityBlockID;
   class RunID;
   class Timestamp;
   class ModuleDescription;
   class Event;
   class LuminosityBlock;
   class Run;
   class EventSetup;
   class HLTPathStatus;
   
   class ActivityRegistry : private boost::noncopyable {
   public:
      ActivityRegistry() {}

      // ---------- signals ------------------------------------
      typedef sigc::signal<void> PostBeginJob;
      PostBeginJob postBeginJobSignal_;
      void watchPostBeginJob(PostBeginJob::slot_type const& iSlot) {
         postBeginJobSignal_.connect(iSlot);
      }
      AR_WATCH_USING_METHOD_0(watchPostBeginJob)

      typedef sigc::signal<void> PostEndJob;
      PostEndJob postEndJobSignal_;
      void watchPostEndJob(PostEndJob::slot_type const& iSlot) {
         PostEndJob::slot_list_type sl = postEndJobSignal_.slots();
         sl.push_front(iSlot);
      }
      AR_WATCH_USING_METHOD_0(watchPostEndJob)

      typedef sigc::signal<void> JobFailure;
      JobFailure    jobFailureSignal_;
      void watchJobFailure(JobFailure::slot_type const& iSlot) {
         JobFailure::slot_list_type sl = jobFailureSignal_.slots();
         sl.push_front(iSlot);
      }
      AR_WATCH_USING_METHOD_0(watchJobFailure)
      
      
      typedef sigc::signal<void> PreSource;
      PreSource preSourceSignal_;
      void watchPreSource(PreSource::slot_type const& iSlot) {
        preSourceSignal_.connect(iSlot);
      }
      AR_WATCH_USING_METHOD_0(watchPreSource)

      
      typedef sigc::signal<void> PostSource;
      PostSource postSourceSignal_;
      void watchPostSource(PostSource::slot_type const& iSlot) {
         PostSource::slot_list_type sl = postSourceSignal_.slots();
         sl.push_front(iSlot);
      }
      AR_WATCH_USING_METHOD_0(watchPostSource)
        
      
      typedef sigc::signal<void> PreSourceLumi;
      PreSourceLumi preSourceLumiSignal_;
      void watchPreSourceLumi(PreSourceLumi::slot_type const& iSlot) {
        preSourceLumiSignal_.connect(iSlot);
      }
      AR_WATCH_USING_METHOD_0(watchPreSourceLumi)

      
      typedef sigc::signal<void> PostSourceLumi;
      PostSourceLumi postSourceLumiSignal_;
      void watchPostSourceLumi(PostSourceLumi::slot_type const& iSlot) {
         PostSourceLumi::slot_list_type sl = postSourceLumiSignal_.slots();
         sl.push_front(iSlot);
      }
      AR_WATCH_USING_METHOD_0(watchPostSourceLumi)
        
      
      typedef sigc::signal<void> PreSourceRun;
      PreSourceRun preSourceRunSignal_;
      void watchPreSourceRun(PreSourceRun::slot_type const& iSlot) {
        preSourceRunSignal_.connect(iSlot);
      }
      AR_WATCH_USING_METHOD_0(watchPreSourceRun)

      
      typedef sigc::signal<void> PostSourceRun;
      PostSourceRun postSourceRunSignal_;
      void watchPostSourceRun(PostSourceRun::slot_type const& iSlot) {
         PostSourceRun::slot_list_type sl = postSourceRunSignal_.slots();
         sl.push_front(iSlot);
      }
      AR_WATCH_USING_METHOD_0(watchPostSourceRun)
        
      
      typedef sigc::signal<void> PreOpenFile;
      PreOpenFile preOpenFileSignal_;
      void watchPreOpenFile(PreOpenFile::slot_type const& iSlot) {
        preOpenFileSignal_.connect(iSlot);
      }
      AR_WATCH_USING_METHOD_0(watchPreOpenFile)

      
      //   Note this is only done for a primary file, not a secondary one.
      typedef sigc::signal<void> PostOpenFile;
      PostOpenFile postOpenFileSignal_;
      void watchPostOpenFile(PostOpenFile::slot_type const& iSlot) {
         PostOpenFile::slot_list_type sl = postOpenFileSignal_.slots();
         sl.push_front(iSlot);
      }
      AR_WATCH_USING_METHOD_0(watchPostOpenFile)
        
      
      //   First argument is the LFN of the file which is being closed.
      //   Second argument is false if fallback is used; true otherwise.
      typedef sigc::signal<void, std::string const&, bool> PreCloseFile;
      PreCloseFile preCloseFileSignal_;
      void watchPreCloseFile(PreCloseFile::slot_type const& iSlot) {
        preCloseFileSignal_.connect(iSlot);
      }
      AR_WATCH_USING_METHOD_2(watchPreCloseFile)

      
      typedef sigc::signal<void> PostCloseFile;
      PostCloseFile postCloseFileSignal_;
      void watchPostCloseFile(PostCloseFile::slot_type const& iSlot) {
         PostCloseFile::slot_list_type sl = postCloseFileSignal_.slots();
         sl.push_front(iSlot);
      }
      AR_WATCH_USING_METHOD_0(watchPostCloseFile)
        
      typedef sigc::signal<void, EventID const&, Timestamp const&> PreProcessEvent;
      PreProcessEvent preProcessEventSignal_;
      void watchPreProcessEvent(PreProcessEvent::slot_type const& iSlot) {
         preProcessEventSignal_.connect(iSlot);
      }
      AR_WATCH_USING_METHOD_2(watchPreProcessEvent)
      
      typedef sigc::signal<void, Event const&, EventSetup const&> PostProcessEvent;
      PostProcessEvent postProcessEventSignal_;
      void watchPostProcessEvent(PostProcessEvent::slot_type const& iSlot) {
         PostProcessEvent::slot_list_type sl = postProcessEventSignal_.slots();
         sl.push_front(iSlot);
      }
      AR_WATCH_USING_METHOD_2(watchPostProcessEvent)

      typedef sigc::signal<void, RunID const&, Timestamp const&> PreBeginRun;
      PreBeginRun preBeginRunSignal_;
      void watchPreBeginRun(PreBeginRun::slot_type const& iSlot) {
         preBeginRunSignal_.connect(iSlot);
      }
      AR_WATCH_USING_METHOD_2(watchPreBeginRun)
      
      typedef sigc::signal<void, Run const&, EventSetup const&> PostBeginRun;
      PostBeginRun postBeginRunSignal_;
      void watchPostBeginRun(PostBeginRun::slot_type const& iSlot) {
         PostBeginRun::slot_list_type sl = postBeginRunSignal_.slots();
         sl.push_front(iSlot);
      }
      AR_WATCH_USING_METHOD_2(watchPostBeginRun)

      typedef sigc::signal<void, RunID const&, Timestamp const&> PreEndRun;
      PreEndRun preEndRunSignal_;
      void watchPreEndRun(PreEndRun::slot_type const& iSlot) {
         preEndRunSignal_.connect(iSlot);
      }
      AR_WATCH_USING_METHOD_2(watchPreEndRun)
      
      typedef sigc::signal<void, Run const&, EventSetup const&> PostEndRun;
      PostEndRun postEndRunSignal_;
      void watchPostEndRun(PostEndRun::slot_type const& iSlot) {
         PostEndRun::slot_list_type sl = postEndRunSignal_.slots();
         sl.push_front(iSlot);
      }
      AR_WATCH_USING_METHOD_2(watchPostEndRun)

      typedef sigc::signal<void, LuminosityBlockID const&, Timestamp const&> PreBeginLumi;
      PreBeginLumi preBeginLumiSignal_;
      void watchPreBeginLumi(PreBeginLumi::slot_type const& iSlot) {
         preBeginLumiSignal_.connect(iSlot);
      }
      AR_WATCH_USING_METHOD_2(watchPreBeginLumi)
      
      typedef sigc::signal<void, LuminosityBlock const&, EventSetup const&> PostBeginLumi;
      PostBeginLumi postBeginLumiSignal_;
      void watchPostBeginLumi(PostBeginLumi::slot_type const& iSlot) {
         PostBeginLumi::slot_list_type sl = postBeginLumiSignal_.slots();
         sl.push_front(iSlot);
      }
      AR_WATCH_USING_METHOD_2(watchPostBeginLumi)

      typedef sigc::signal<void, LuminosityBlockID const&, Timestamp const&> PreEndLumi;
      PreEndLumi preEndLumiSignal_;
      void watchPreEndLumi(PreEndLumi::slot_type const& iSlot) {
         preEndLumiSignal_.connect(iSlot);
      }
      AR_WATCH_USING_METHOD_2(watchPreEndLumi)
      
      typedef sigc::signal<void, LuminosityBlock const&, EventSetup const&> PostEndLumi;
      PostEndLumi postEndLumiSignal_;
      void watchPostEndLumi(PostEndLumi::slot_type const& iSlot) {
         PostEndLumi::slot_list_type sl = postEndLumiSignal_.slots();
         sl.push_front(iSlot);
      }
      AR_WATCH_USING_METHOD_2(watchPostEndLumi)

      
      typedef sigc::signal<void, std::string const&> PreProcessPath;
      PreProcessPath preProcessPathSignal_;
      void watchPreProcessPath(PreProcessPath::slot_type const& iSlot) {
        preProcessPathSignal_.connect(iSlot);
      }
      AR_WATCH_USING_METHOD_1(watchPreProcessPath)
        
      
      typedef sigc::signal<void, std::string const&, HLTPathStatus const&> PostProcessPath;
      PostProcessPath postProcessPathSignal_;
      void watchPostProcessPath(PostProcessPath::slot_type const& iSlot) {
         PostProcessPath::slot_list_type sl = postProcessPathSignal_.slots();
         sl.push_front(iSlot);
      }  
      AR_WATCH_USING_METHOD_2(watchPostProcessPath)
        
      
      typedef sigc::signal<void, std::string const&> PrePathBeginRun;
      PrePathBeginRun prePathBeginRunSignal_;
      void watchPrePathBeginRun(PrePathBeginRun::slot_type const& iSlot) {
        prePathBeginRunSignal_.connect(iSlot);
      }
      AR_WATCH_USING_METHOD_1(watchPrePathBeginRun)
        
      
      typedef sigc::signal<void, std::string const&, HLTPathStatus const&> PostPathBeginRun;
      PostPathBeginRun postPathBeginRunSignal_;
      void watchPostPathBeginRun(PostPathBeginRun::slot_type const& iSlot) {
         PostPathBeginRun::slot_list_type sl = postPathBeginRunSignal_.slots();
         sl.push_front(iSlot);
      }  
      AR_WATCH_USING_METHOD_2(watchPostPathBeginRun)
        
      
      typedef sigc::signal<void, std::string const&> PrePathEndRun;
      PrePathEndRun prePathEndRunSignal_;
      void watchPrePathEndRun(PrePathEndRun::slot_type const& iSlot) {
        prePathEndRunSignal_.connect(iSlot);
      }
      AR_WATCH_USING_METHOD_1(watchPrePathEndRun)
        
      
      typedef sigc::signal<void, std::string const&, HLTPathStatus const&> PostPathEndRun;
      PostPathEndRun postPathEndRunSignal_;
      void watchPostPathEndRun(PostPathEndRun::slot_type const& iSlot) {
         PostPathEndRun::slot_list_type sl = postPathEndRunSignal_.slots();
         sl.push_front(iSlot);
      }  
      AR_WATCH_USING_METHOD_2(watchPostPathEndRun)
        
      
      typedef sigc::signal<void, std::string const&> PrePathBeginLumi;
      PrePathBeginLumi prePathBeginLumiSignal_;
      void watchPrePathBeginLumi(PrePathBeginLumi::slot_type const& iSlot) {
        prePathBeginLumiSignal_.connect(iSlot);
      }
      AR_WATCH_USING_METHOD_1(watchPrePathBeginLumi)
        
      
      typedef sigc::signal<void, std::string const&, HLTPathStatus const&> PostPathBeginLumi;
      PostPathBeginLumi postPathBeginLumiSignal_;
      void watchPostPathBeginLumi(PostPathBeginLumi::slot_type const& iSlot) {
         PostPathBeginLumi::slot_list_type sl = postPathBeginLumiSignal_.slots();
         sl.push_front(iSlot);
      }  
      AR_WATCH_USING_METHOD_2(watchPostPathBeginLumi)
        
      
      typedef sigc::signal<void, std::string const&> PrePathEndLumi;
      PrePathEndLumi prePathEndLumiSignal_;
      void watchPrePathEndLumi(PrePathEndLumi::slot_type const& iSlot) {
        prePathEndLumiSignal_.connect(iSlot);
      }
      AR_WATCH_USING_METHOD_1(watchPrePathEndLumi)
        
      
      typedef sigc::signal<void, std::string const&, HLTPathStatus const&> PostPathEndLumi;
      PostPathEndLumi postPathEndLumiSignal_;
      void watchPostPathEndLumi(PostPathEndLumi::slot_type const& iSlot) {
         PostPathEndLumi::slot_list_type sl = postPathEndLumiSignal_.slots();
         sl.push_front(iSlot);
      }  
      AR_WATCH_USING_METHOD_2(watchPostPathEndLumi)

        /* Note M:
           Concerning use of address of module descriptor
           during functions called before/after module or source construction:
               Unlike the case in the Run, Lumi, and Event loops,
               the Module descriptor (often passed by pointer or reference
               as an argument named desc) in the construction phase is NOT
               at some permanent fixed address during the construction phase.  
               Therefore, any optimization of caching the module name keying 
               off of address of the descriptor will NOT be valid during 
               such functions.  mf / cj 9/11/09
        */
        
      
      typedef sigc::signal<void, ModuleDescription const&> PreModuleConstruction;
      PreModuleConstruction preModuleConstructionSignal_;
      void watchPreModuleConstruction(PreModuleConstruction::slot_type const& iSlot) {
         preModuleConstructionSignal_.connect(iSlot);
      }
      // WARNING - ModuleDescription is not in fixed place.  See note M above.
      AR_WATCH_USING_METHOD_1(watchPreModuleConstruction)
         
      
      typedef sigc::signal<void, ModuleDescription const&> PostModuleConstruction;
      PostModuleConstruction postModuleConstructionSignal_;
      void watchPostModuleConstruction(PostModuleConstruction::slot_type const& iSlot) {
         PostModuleConstruction::slot_list_type sl = postModuleConstructionSignal_.slots();
         sl.push_front(iSlot);
      }
      // WARNING - ModuleDescription is not in fixed place.  See note M above.
      AR_WATCH_USING_METHOD_1(watchPostModuleConstruction)

      
      typedef sigc::signal<void, ModuleDescription const&> PreModuleBeginJob;
      PreModuleBeginJob preModuleBeginJobSignal_;
      void watchPreModuleBeginJob(PreModuleBeginJob::slot_type const& iSlot) {
        preModuleBeginJobSignal_.connect(iSlot);
      }
      AR_WATCH_USING_METHOD_1(watchPreModuleBeginJob)
        
      
      typedef sigc::signal<void, ModuleDescription const&> PostModuleBeginJob;
      PostModuleBeginJob postModuleBeginJobSignal_;
      void watchPostModuleBeginJob(PostModuleBeginJob::slot_type const& iSlot) {
         PostModuleBeginJob::slot_list_type sl = postModuleBeginJobSignal_.slots();
         sl.push_front(iSlot);
      }
      AR_WATCH_USING_METHOD_1(watchPostModuleBeginJob)
        
      
      typedef sigc::signal<void, ModuleDescription const&> PreModuleEndJob;
      PreModuleEndJob preModuleEndJobSignal_;
      void watchPreModuleEndJob(PreModuleEndJob::slot_type const& iSlot) {
        preModuleEndJobSignal_.connect(iSlot);
      }
      AR_WATCH_USING_METHOD_1(watchPreModuleEndJob)
        
      
      typedef sigc::signal<void, ModuleDescription const&> PostModuleEndJob;
      PostModuleEndJob postModuleEndJobSignal_;
      void watchPostModuleEndJob(PostModuleEndJob::slot_type const& iSlot) {
         PostModuleEndJob::slot_list_type sl = postModuleEndJobSignal_.slots();
         sl.push_front(iSlot);
      }
      AR_WATCH_USING_METHOD_1(watchPostModuleEndJob)
        
      
      typedef sigc::signal<void, ModuleDescription const&> PreModule;
      PreModule preModuleSignal_;
      void watchPreModule(PreModule::slot_type const& iSlot) {
         preModuleSignal_.connect(iSlot);
      }
      AR_WATCH_USING_METHOD_1(watchPreModule)
         
      
      typedef sigc::signal<void, ModuleDescription const&> PostModule;
      PostModule postModuleSignal_;
      void watchPostModule(PostModule::slot_type const& iSlot) {
         PostModule::slot_list_type sl = postModuleSignal_.slots();
         sl.push_front(iSlot);
      }
      AR_WATCH_USING_METHOD_1(watchPostModule)
         
      
      typedef sigc::signal<void, ModuleDescription const&> PreModuleBeginRun;
      PreModuleBeginRun preModuleBeginRunSignal_;
      void watchPreModuleBeginRun(PreModuleBeginRun::slot_type const& iSlot) {
         preModuleBeginRunSignal_.connect(iSlot);
      }
      AR_WATCH_USING_METHOD_1(watchPreModuleBeginRun)
         
      
      typedef sigc::signal<void, ModuleDescription const&> PostModuleBeginRun;
      PostModuleBeginRun postModuleBeginRunSignal_;
      void watchPostModuleBeginRun(PostModuleBeginRun::slot_type const& iSlot) {
         PostModuleBeginRun::slot_list_type sl = postModuleBeginRunSignal_.slots();
         sl.push_front(iSlot);
      }
      AR_WATCH_USING_METHOD_1(watchPostModuleBeginRun)
         
      
      typedef sigc::signal<void, ModuleDescription const&> PreModuleEndRun;
      PreModuleEndRun preModuleEndRunSignal_;
      void watchPreModuleEndRun(PreModuleEndRun::slot_type const& iSlot) {
         preModuleEndRunSignal_.connect(iSlot);
      }
      AR_WATCH_USING_METHOD_1(watchPreModuleEndRun)
         
      
      typedef sigc::signal<void, ModuleDescription const&> PostModuleEndRun;
      PostModuleEndRun postModuleEndRunSignal_;
      void watchPostModuleEndRun(PostModuleEndRun::slot_type const& iSlot) {
         PostModuleEndRun::slot_list_type sl = postModuleEndRunSignal_.slots();
         sl.push_front(iSlot);
      }
      AR_WATCH_USING_METHOD_1(watchPostModuleEndRun)
         
      
      typedef sigc::signal<void, ModuleDescription const&> PreModuleBeginLumi;
      PreModuleBeginLumi preModuleBeginLumiSignal_;
      void watchPreModuleBeginLumi(PreModuleBeginLumi::slot_type const& iSlot) {
         preModuleBeginLumiSignal_.connect(iSlot);
      }
      AR_WATCH_USING_METHOD_1(watchPreModuleBeginLumi)
         
      
      typedef sigc::signal<void, ModuleDescription const&> PostModuleBeginLumi;
      PostModuleBeginLumi postModuleBeginLumiSignal_;
      void watchPostModuleBeginLumi(PostModuleBeginLumi::slot_type const& iSlot) {
         PostModuleBeginLumi::slot_list_type sl = postModuleBeginLumiSignal_.slots();
         sl.push_front(iSlot);
      }
      AR_WATCH_USING_METHOD_1(watchPostModuleBeginLumi)
         
      
      typedef sigc::signal<void, ModuleDescription const&> PreModuleEndLumi;
      PreModuleEndLumi preModuleEndLumiSignal_;
      void watchPreModuleEndLumi(PreModuleEndLumi::slot_type const& iSlot) {
         preModuleEndLumiSignal_.connect(iSlot);
      }
      AR_WATCH_USING_METHOD_1(watchPreModuleEndLumi)
         
      
      typedef sigc::signal<void, ModuleDescription const&> PostModuleEndLumi;
      PostModuleEndLumi postModuleEndLumiSignal_;
      void watchPostModuleEndLumi(PostModuleEndLumi::slot_type const& iSlot) {
         PostModuleEndLumi::slot_list_type sl = postModuleEndLumiSignal_.slots();
         sl.push_front(iSlot);
      }
      AR_WATCH_USING_METHOD_1(watchPostModuleEndLumi)
         
      
      typedef sigc::signal<void, ModuleDescription const&> PreSourceConstruction;
      PreSourceConstruction preSourceConstructionSignal_;
      void watchPreSourceConstruction(PreSourceConstruction::slot_type const& iSlot) {
        preSourceConstructionSignal_.connect(iSlot);
      }
      // WARNING - ModuleDescription is not in fixed place.  See note M above.
      AR_WATCH_USING_METHOD_1(watchPreSourceConstruction)
        
      
      typedef sigc::signal<void, ModuleDescription const&> PostSourceConstruction;
      PostSourceConstruction postSourceConstructionSignal_;
      void watchPostSourceConstruction(PostSourceConstruction::slot_type const& iSlot) {
         PostSourceConstruction::slot_list_type sl = postSourceConstructionSignal_.slots();
         sl.push_front(iSlot);
      }
      // WARNING - ModuleDescription is not in fixed place.  See note M above.
      AR_WATCH_USING_METHOD_1(watchPostSourceConstruction)

      
      typedef sigc::signal<void> PreForkReleaseResources;
      PreForkReleaseResources preForkReleaseResourcesSignal_;
      void watchPreForkReleaseResources(PreForkReleaseResources::slot_type const& iSlot) {
         PreForkReleaseResources::slot_list_type sl = preForkReleaseResourcesSignal_.slots();
         sl.push_front(iSlot);
      }
      AR_WATCH_USING_METHOD_0(watchPreForkReleaseResources)
      
      
      typedef sigc::signal<void, unsigned int, unsigned int> PostForkReacquireResources;
      PostForkReacquireResources postForkReacquireResourcesSignal_;
      void watchPostForkReacquireResources(PostForkReacquireResources::slot_type const& iSlot) {
         PostForkReacquireResources::slot_list_type sl = postForkReacquireResourcesSignal_.slots();
         sl.push_front(iSlot);
      }
      AR_WATCH_USING_METHOD_2(watchPostForkReacquireResources)
      
      // ---------- member functions ---------------------------
      
      
      void connect(ActivityRegistry& iOther);

      void connectToSubProcess(ActivityRegistry& iOther);
      
      void copySlotsFrom(ActivityRegistry& iOther);
      
   private:
      // forwards subprocess independent signals to slots connected to iOther
      void connectGlobals(ActivityRegistry& iOther);

      // forwards subprocess dependent signals to slots connected to iOther
      void connectLocals(ActivityRegistry& iOther);
   };
}
#undef AR_WATCH_USING_METHOD
#endif