MicroStateServiceClassic.cc

Go to the documentation of this file.

#include "EventFilter/Utilities/interface/MicroStateServiceClassic.h"


namespace evf{


  MicroStateServiceClassic::MicroStateServiceClassic(const edm::ParameterSet& iPS, 
                       edm::ActivityRegistry& reg) : 
    MicroStateService(iPS,reg)
    ,microstate2_(&(reservedMicroStateNames[MicroStateService::mInvalid].moduleLabel()))
  {
  
    reg.watchPostBeginJob(this,&MicroStateServiceClassic::postBeginJob);
    reg.watchPostEndJob(this,&MicroStateServiceClassic::postEndJob);
  
    reg.watchPreProcessEvent(this,&MicroStateServiceClassic::preEventProcessing);
    reg.watchPostProcessEvent(this,&MicroStateServiceClassic::postEventProcessing);
    reg.watchPreSourceEvent(this,&MicroStateServiceClassic::preSourceEvent);
    reg.watchPostSourceEvent(this,&MicroStateServiceClassic::postSourceEvent);
  
    reg.watchPreModule(this,&MicroStateServiceClassic::preModule);
    reg.watchPostModule(this,&MicroStateServiceClassic::postModule);
    microstate1_ = "BJ";
  }


  MicroStateServiceClassic::~MicroStateServiceClassic()
  {
  }

  void MicroStateServiceClassic::postBeginJob()
  {
    boost::mutex::scoped_lock sl(lock_);
    microstate1_ = "BJD";
  }

  void MicroStateServiceClassic::postEndJob()
  {
    boost::mutex::scoped_lock sl(lock_);
    microstate1_ = "EJ";
    microstate2_ = &done;
  }

  void MicroStateServiceClassic::preEventProcessing(const edm::EventID& iID,
                         const edm::Timestamp& iTime)
  {
    boost::mutex::scoped_lock sl(lock_);
    microstate1_ = "PRO";
  }

  void MicroStateServiceClassic::postEventProcessing(const edm::Event& e, const edm::EventSetup&)
  {
    boost::mutex::scoped_lock sl(lock_);
    microstate2_ = &input;
  }

  void MicroStateServiceClassic::preSourceEvent(edm::StreamID)
  {
    boost::mutex::scoped_lock sl(lock_);
    microstate2_ = &input;
  }

  void MicroStateServiceClassic::postSourceEvent(edm::StreamID)
  {
    boost::mutex::scoped_lock sl(lock_);
    microstate2_ = &fwkovh;
  }

  void MicroStateServiceClassic::preModule(const edm::ModuleDescription& desc)
  {
    boost::mutex::scoped_lock sl(lock_);
    microstate2_ = &(desc.moduleLabel());
  }

  void MicroStateServiceClassic::postModule(const edm::ModuleDescription& desc)
  {
    boost::mutex::scoped_lock sl(lock_);
    microstate2_ = &fwkovh;
  }
  
  std::string MicroStateServiceClassic::getMicroState1()
  { 
    boost::mutex::scoped_lock sl(lock_);
    return microstate1_;
  }

  std::string const &MicroStateServiceClassic::getMicroState2()
  { 
    boost::mutex::scoped_lock sl(lock_);
    return *microstate2_;
  }

  void MicroStateServiceClassic::setMicroState(MicroStateService::Microstate m)
  {
        boost::mutex::scoped_lock sl(lock_);
    microstate2_ = &(reservedMicroStateNames[m].moduleLabel());
  }

} //end namespace evf