ActivityRegistry.cc

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:     ServiceRegistry
// Class  :     ActivityRegistry
// 
// Implementation:
//     <Notes on implementation>
//
// Original Author:  Chris Jones
//         Created:  Tue Sep  6 10:26:49 EDT 2005
//

// system include files
#include <algorithm>

// user include files
#include "FWCore/ServiceRegistry/interface/ActivityRegistry.h"
#include "FWCore/Utilities/interface/Algorithms.h"

//
// constants, enums and typedefs
//

//
// static data member definitions
//

//
// constructors and destructor
//
//ActivityRegistry::ActivityRegistry() {
//}
   
// ActivityRegistry::ActivityRegistry(ActivityRegistry const& rhs) {
//    // do actual copying here;
// }

//ActivityRegistry::~ActivityRegistry() {
//}
   
//
// assignment operators
//
// ActivityRegistry const& ActivityRegistry::operator=(ActivityRegistry const& rhs) {
//   //An exception safe implementation is
//   ActivityRegistry temp(rhs);
//   swap(rhs);
//
//   return *this;
// }

//
// member functions
//
namespace edm {
  namespace {
    template<class T>
    inline
    void
    copySlotsToFrom(T& iTo, T& iFrom) {
      typename T::slot_list_type slots = iFrom.slots();
    
      for_all(slots, boost::bind(&T::connect, iTo, _1));
    }
  
    template<class T>
    inline
    void
    copySlotsToFromReverse(T& iTo, T& iFrom) {
      // This handles service slots that are supposed to be in reverse
      // order of construction. Copying new ones in is a little
      // tricky.  Here is an example of what follows
      // slots in iTo before  4 3 2 1  and copy in slots in iFrom 8 7 6 5
      // reverse both  1 2 3 4  plus 5 6 7 8
      // then do the copy 1 2 3 4 5 6 7 8
      // then reverse back again to get the desired order
      // 8 7 6 5 4 3 2 1
  
      typename T::slot_list_type slotsFrom = iFrom.slots();
      typename T::slot_list_type slotsTo   = iTo.slots();
    
      std::reverse(slotsTo.begin(), slotsTo.end());
      std::reverse(slotsFrom.begin(), slotsFrom.end());
  
      for_all(slotsFrom, boost::bind(&T::connect, iTo, _1));
  
      std::reverse(slotsTo.begin(), slotsTo.end());
  
      // Be nice and put these back in the state they were
      // at the beginning
      std::reverse(slotsFrom.begin(), slotsFrom.end());
    }
  }
  
  void 
  ActivityRegistry::connect(ActivityRegistry& iOther) {

     postBeginJobSignal_.connect(iOther.postBeginJobSignal_);
     postEndJobSignal_.connect(iOther.postEndJobSignal_);
  
     jobFailureSignal_.connect(iOther.jobFailureSignal_);
  
     preSourceSignal_.connect(iOther.preSourceSignal_);
     postSourceSignal_.connect(iOther.postSourceSignal_);
  
     preSourceLumiSignal_.connect(iOther.preSourceLumiSignal_);
     postSourceLumiSignal_.connect(iOther.postSourceLumiSignal_);
  
     preSourceRunSignal_.connect(iOther.preSourceRunSignal_);
     postSourceRunSignal_.connect(iOther.postSourceRunSignal_);
  
     preOpenFileSignal_.connect(iOther.preOpenFileSignal_);
     postOpenFileSignal_.connect(iOther.postOpenFileSignal_);
     
     preCloseFileSignal_.connect(iOther.preCloseFileSignal_);
     postCloseFileSignal_.connect(iOther.postCloseFileSignal_);
     
     preProcessEventSignal_.connect(iOther.preProcessEventSignal_);
     postProcessEventSignal_.connect(iOther.postProcessEventSignal_);
  
     preBeginRunSignal_.connect(iOther.preBeginRunSignal_);
     postBeginRunSignal_.connect(iOther.postBeginRunSignal_);
  
     preEndRunSignal_.connect(iOther.preEndRunSignal_);
     postEndRunSignal_.connect(iOther.postEndRunSignal_);
  
     preBeginLumiSignal_.connect(iOther.preBeginLumiSignal_);
     postBeginLumiSignal_.connect(iOther.postBeginLumiSignal_);
  
     preEndLumiSignal_.connect(iOther.preEndLumiSignal_);
     postEndLumiSignal_.connect(iOther.postEndLumiSignal_);
  
     preProcessPathSignal_.connect(iOther.preProcessPathSignal_);
     postProcessPathSignal_.connect(iOther.postProcessPathSignal_);
  
     prePathBeginRunSignal_.connect(iOther.prePathBeginRunSignal_);
     postPathBeginRunSignal_.connect(iOther.postPathBeginRunSignal_);
  
     prePathEndRunSignal_.connect(iOther.prePathEndRunSignal_);
     postPathEndRunSignal_.connect(iOther.postPathEndRunSignal_);
  
     prePathBeginLumiSignal_.connect(iOther.prePathBeginLumiSignal_);
     postPathBeginLumiSignal_.connect(iOther.postPathBeginLumiSignal_);
  
     prePathEndLumiSignal_.connect(iOther.prePathEndLumiSignal_);
     postPathEndLumiSignal_.connect(iOther.postPathEndLumiSignal_);
  
     preModuleSignal_.connect(iOther.preModuleSignal_);
     postModuleSignal_.connect(iOther.postModuleSignal_);
  
     preModuleBeginRunSignal_.connect(iOther.preModuleBeginRunSignal_);
     postModuleBeginRunSignal_.connect(iOther.postModuleBeginRunSignal_);
  
     preModuleEndRunSignal_.connect(iOther.preModuleEndRunSignal_);
     postModuleEndRunSignal_.connect(iOther.postModuleEndRunSignal_);
  
     preModuleBeginLumiSignal_.connect(iOther.preModuleBeginLumiSignal_);
     postModuleBeginLumiSignal_.connect(iOther.postModuleBeginLumiSignal_);
  
     preModuleEndLumiSignal_.connect(iOther.preModuleEndLumiSignal_);
     postModuleEndLumiSignal_.connect(iOther.postModuleEndLumiSignal_);
  
     preModuleConstructionSignal_.connect(iOther.preModuleConstructionSignal_);
     postModuleConstructionSignal_.connect(iOther.postModuleConstructionSignal_);
  
     preModuleBeginJobSignal_.connect(iOther.preModuleBeginJobSignal_);
     postModuleBeginJobSignal_.connect(iOther.postModuleBeginJobSignal_);
     
     preModuleEndJobSignal_.connect(iOther.preModuleEndJobSignal_);
     postModuleEndJobSignal_.connect(iOther.postModuleEndJobSignal_);
     
     preSourceConstructionSignal_.connect(iOther.preSourceConstructionSignal_);
     postSourceConstructionSignal_.connect(iOther.postSourceConstructionSignal_);
  
     preForkReleaseResourcesSignal_.connect(iOther.preForkReleaseResourcesSignal_);
     postForkReacquireResourcesSignal_.connect(iOther.postForkReacquireResourcesSignal_);
  }
  
  void 
  ActivityRegistry::copySlotsFrom(ActivityRegistry& iOther) {
    copySlotsToFrom(postBeginJobSignal_, iOther.postBeginJobSignal_);
    copySlotsToFromReverse(postEndJobSignal_, iOther.postEndJobSignal_);
    
    copySlotsToFromReverse(jobFailureSignal_, iOther.jobFailureSignal_);
    
    copySlotsToFrom(preSourceSignal_, iOther.preSourceSignal_);
    copySlotsToFromReverse(postSourceSignal_, iOther.postSourceSignal_);
  
    copySlotsToFrom(preSourceLumiSignal_, iOther.preSourceLumiSignal_);
    copySlotsToFromReverse(postSourceLumiSignal_, iOther.postSourceLumiSignal_);
  
    copySlotsToFrom(preSourceRunSignal_, iOther.preSourceRunSignal_);
    copySlotsToFromReverse(postSourceRunSignal_, iOther.postSourceRunSignal_);
  
    copySlotsToFrom(preOpenFileSignal_, iOther.preOpenFileSignal_);
    copySlotsToFromReverse(postOpenFileSignal_, iOther.postOpenFileSignal_);
    
    copySlotsToFrom(preCloseFileSignal_, iOther.preCloseFileSignal_);
    copySlotsToFromReverse(postCloseFileSignal_, iOther.postCloseFileSignal_);
    
    copySlotsToFrom(preProcessEventSignal_, iOther.preProcessEventSignal_);
    copySlotsToFromReverse(postProcessEventSignal_, iOther.postProcessEventSignal_);
    
    copySlotsToFrom(preBeginRunSignal_, iOther.preBeginRunSignal_);
    copySlotsToFromReverse(postBeginRunSignal_, iOther.postBeginRunSignal_);
  
    copySlotsToFrom(preEndRunSignal_, iOther.preEndRunSignal_);
    copySlotsToFromReverse(postEndRunSignal_, iOther.postEndRunSignal_);
  
    copySlotsToFrom(preBeginLumiSignal_, iOther.preBeginLumiSignal_);
    copySlotsToFromReverse(postBeginLumiSignal_, iOther.postBeginLumiSignal_);
  
    copySlotsToFrom(preEndLumiSignal_, iOther.preEndLumiSignal_);
    copySlotsToFromReverse(postEndLumiSignal_, iOther.postEndLumiSignal_);
  
    copySlotsToFrom(preProcessPathSignal_, iOther.preProcessPathSignal_);
    copySlotsToFromReverse(postProcessPathSignal_, iOther.postProcessPathSignal_);
  
    copySlotsToFrom(prePathBeginRunSignal_, iOther.prePathBeginRunSignal_);
    copySlotsToFromReverse(postPathBeginRunSignal_, iOther.postPathBeginRunSignal_);
  
    copySlotsToFrom(prePathEndRunSignal_, iOther.prePathEndRunSignal_);
    copySlotsToFromReverse(postPathEndRunSignal_, iOther.postPathEndRunSignal_);
  
    copySlotsToFrom(prePathBeginLumiSignal_, iOther.prePathBeginLumiSignal_);
    copySlotsToFromReverse(postPathBeginLumiSignal_, iOther.postPathBeginLumiSignal_);
  
    copySlotsToFrom(prePathEndLumiSignal_, iOther.prePathEndLumiSignal_);
    copySlotsToFromReverse(postPathEndLumiSignal_, iOther.postPathEndLumiSignal_);
  
    copySlotsToFrom(preModuleSignal_, iOther.preModuleSignal_);
    copySlotsToFromReverse(postModuleSignal_, iOther.postModuleSignal_);
    
    copySlotsToFrom(preModuleBeginRunSignal_, iOther.preModuleBeginRunSignal_);
    copySlotsToFromReverse(postModuleBeginRunSignal_, iOther.postModuleBeginRunSignal_);
    
    copySlotsToFrom(preModuleEndRunSignal_, iOther.preModuleEndRunSignal_);
    copySlotsToFromReverse(postModuleEndRunSignal_, iOther.postModuleEndRunSignal_);
    
    copySlotsToFrom(preModuleBeginLumiSignal_, iOther.preModuleBeginLumiSignal_);
    copySlotsToFromReverse(postModuleBeginLumiSignal_, iOther.postModuleBeginLumiSignal_);
    
    copySlotsToFrom(preModuleEndLumiSignal_, iOther.preModuleEndLumiSignal_);
    copySlotsToFromReverse(postModuleEndLumiSignal_, iOther.postModuleEndLumiSignal_);
    
    copySlotsToFrom(preModuleConstructionSignal_, iOther.preModuleConstructionSignal_);
    copySlotsToFromReverse(postModuleConstructionSignal_, iOther.postModuleConstructionSignal_);
    
    copySlotsToFrom(preModuleBeginJobSignal_, iOther.preModuleBeginJobSignal_);
    copySlotsToFromReverse(postModuleBeginJobSignal_, iOther.postModuleBeginJobSignal_);
    
    copySlotsToFrom(preModuleEndJobSignal_, iOther.preModuleEndJobSignal_);
    copySlotsToFromReverse(postModuleEndJobSignal_, iOther.postModuleEndJobSignal_);
    
    copySlotsToFrom(preSourceConstructionSignal_, iOther.preSourceConstructionSignal_);
    copySlotsToFromReverse(postSourceConstructionSignal_, iOther.postSourceConstructionSignal_);
  
    copySlotsToFrom(preForkReleaseResourcesSignal_, iOther.preForkReleaseResourcesSignal_);
    copySlotsToFromReverse(postForkReacquireResourcesSignal_, iOther.postForkReacquireResourcesSignal_);
  }
  
  //
  // const member functions
  //
  
  //
  // static member functions
  //
}