#include <EPStates.h>

Inheritance diagram for statemachine::HandleRuns:

Public Types
typedef sc::transition< File, NewInputAndOutputFiles >	reactions
Public Member Functions
void	beginRun (Run const &run)
bool	beginRunCalled () const
void	beginRunIfNotDoneAlready ()
Run const &	currentRun () const
void	endRun (Run const &run, bool cleaningUpAfterException)
void	exit ()
void	finalizeRun (Run const &)
void	finalizeRun (bool cleaningUpAfterException)
	HandleRuns (my_context ctx)
bool	runException () const
void	setupCurrentRun ()
	~HandleRuns ()
Private Attributes
bool	beginRunCalled_
Run	currentRun_
edm::IEventProcessor &	ep_
bool	exitCalled_
bool	runException_

Detailed Description

Definition at line 233 of file EPStates.h.

Member Typedef Documentation

typedef sc::transition<File, NewInputAndOutputFiles> statemachine::HandleRuns::reactions

Definition at line 240 of file EPStates.h.

Constructor & Destructor Documentation

statemachine::HandleRuns::HandleRuns ( my_context ctx )

Definition at line 192 of file EPStates.cc.

                                       :
    my_base(ctx),
    ep_(context<Machine>().ep()),
    exitCalled_(false),
    beginRunCalled_(false),
    currentRun_(INVALID_RUN),
    runException_(false) { }

statemachine::HandleRuns::~HandleRuns ( )

Definition at line 206 of file EPStates.cc.

References ep_, exitCalled_, finalizeRun(), python::rootplot::argparse::message, and edm::IEventProcessor::setExceptionMessageRuns().

                          {
    if(!exitCalled_) {
      try {
        finalizeRun(true);
      }
      catch(...) {
        std::string message("Another exception was caught while trying to clean up runs after the primary fatal exception.");
        ep_.setExceptionMessageRuns(message);
      }
    }
  }

Member Function Documentation

void statemachine::HandleRuns::beginRun ( Run const & run )

Definition at line 233 of file EPStates.cc.

References edm::IEventProcessor::beginRun(), beginRunCalled_, ep_, and runException_.

Referenced by beginRunIfNotDoneAlready(), and setupCurrentRun().

                                          {
    beginRunCalled_ = true;

    runException_ = true;
    ep_.beginRun(run);
    runException_ = false;
  }

bool statemachine::HandleRuns::beginRunCalled ( ) const

Definition at line 218 of file EPStates.cc.

References beginRunCalled_.

{ return beginRunCalled_; }

void statemachine::HandleRuns::beginRunIfNotDoneAlready ( )

Definition at line 265 of file EPStates.cc.

References beginRun(), beginRunCalled_, and currentRun().

                                            {
    if(!beginRunCalled_) beginRun(currentRun());
  }

Run const & statemachine::HandleRuns::currentRun ( ) const

Definition at line 219 of file EPStates.cc.

References currentRun_.

Referenced by beginRunIfNotDoneAlready(), finalizeRun(), and setupCurrentRun().

{ return currentRun_; }

void statemachine::HandleRuns::endRun	(	Run const &	run,
		bool	cleaningUpAfterException
	)

Definition at line 241 of file EPStates.cc.

References beginRunCalled_, edm::IEventProcessor::endRun(), ep_, and runException_.

Referenced by finalizeRun().

                                                                       {
    beginRunCalled_ = false;

    runException_ = true;
    ep_.endRun(run, cleaningUpAfterException);
    runException_ = false;
  }

void statemachine::HandleRuns::exit ( )

Definition at line 200 of file EPStates.cc.

References edm::IEventProcessor::alreadyHandlingException(), ep_, exitCalled_, and finalizeRun().

                        {
    if(ep_.alreadyHandlingException()) return;
    exitCalled_ = true;
    finalizeRun(false);
  }

void statemachine::HandleRuns::finalizeRun ( bool cleaningUpAfterException )

Definition at line 253 of file EPStates.cc.

References beginRunCalled_, currentRun(), currentRun_, edm::IEventProcessor::deleteRunFromCache(), endRun(), ep_, runException_, and edm::IEventProcessor::writeRun().

                                                            {

    if(runException_) return;
    runException_ = true;

    if(beginRunCalled_) endRun(currentRun(), cleaningUpAfterException);
    ep_.writeRun(currentRun_);
    ep_.deleteRunFromCache(currentRun_);
    currentRun_ = INVALID_RUN;
    runException_ = false;
  }

void statemachine::HandleRuns::finalizeRun ( Run const & )

Definition at line 249 of file EPStates.cc.

Referenced by exit(), statemachine::HandleNewInputFile2::react(), statemachine::ContinueRun1::react(), and ~HandleRuns().

                                         {
    finalizeRun(false);
  }

bool statemachine::HandleRuns::runException ( ) const

Definition at line 220 of file EPStates.cc.

References runException_.

{ return runException_; }

void statemachine::HandleRuns::setupCurrentRun ( )

Definition at line 222 of file EPStates.cc.

References beginRun(), currentRun(), currentRun_, statemachine::doNotHandleEmptyRunsAndLumis, ep_, edm::IEventProcessor::readAndCacheRun(), and runException_.

                                   {

    runException_ = true;
    currentRun_ = ep_.readAndCacheRun(false);
    runException_ = false;

    if(context<Machine>().emptyRunLumiMode() != doNotHandleEmptyRunsAndLumis) {
      beginRun(currentRun());
    }
  }