#include <PrincipalCache.h>

Public Member Functions
void	adjustEventsToNewProductRegistry (std::shared_ptr< ProductRegistry const > reg)

void	adjustIndexesAfterProductRegistryAddition ()

void	deleteLumi (ProcessHistoryID const &phid, RunNumber_t run, LuminosityBlockNumber_t lumi)

void	deleteRun (ProcessHistoryID const &phid, RunNumber_t run)

EventPrincipal &	eventPrincipal (unsigned int iStreamIndex) const

bool	hasLumiPrincipal () const

bool	hasRunPrincipal () const

void	insert (std::shared_ptr< RunPrincipal > rp)

void	insert (std::shared_ptr< LuminosityBlockPrincipal > lbp)

void	insert (std::shared_ptr< EventPrincipal > ep)

LuminosityBlockPrincipal &	lumiPrincipal (ProcessHistoryID const &phid, RunNumber_t run, LuminosityBlockNumber_t lumi) const

LuminosityBlockPrincipal &	lumiPrincipal () const

std::shared_ptr< LuminosityBlockPrincipal > const &	lumiPrincipalPtr (ProcessHistoryID const &phid, RunNumber_t run, LuminosityBlockNumber_t lumi) const

std::shared_ptr< LuminosityBlockPrincipal > const &	lumiPrincipalPtr () const

void	merge (std::shared_ptr< RunAuxiliary > aux, std::shared_ptr< ProductRegistry const > reg)

void	merge (std::shared_ptr< LuminosityBlockAuxiliary > aux, std::shared_ptr< ProductRegistry const > reg)

	PrincipalCache ()

RunPrincipal &	runPrincipal (ProcessHistoryID const &phid, RunNumber_t run) const

RunPrincipal &	runPrincipal () const

std::shared_ptr< RunPrincipal > const &	runPrincipalPtr (ProcessHistoryID const &phid, RunNumber_t run) const

std::shared_ptr< RunPrincipal > const &	runPrincipalPtr () const

void	setNumberOfConcurrentPrincipals (PreallocationConfiguration const &)

void	setProcessHistoryRegistry (ProcessHistoryRegistry const &phr)

	~PrincipalCache ()

Private Member Functions
void	throwLumiMissing () const

void	throwRunMissing () const

Private Attributes
std::vector< std::shared_ptr< EventPrincipal > >	eventPrincipals_

ProcessHistoryID	inputProcessHistoryID_

LuminosityBlockNumber_t	lumi_

std::shared_ptr< LuminosityBlockPrincipal >	lumiPrincipal_

ProcessHistoryRegistry const *	processHistoryRegistry_

ProcessHistoryID	reducedInputProcessHistoryID_

RunNumber_t	run_

std::shared_ptr< RunPrincipal >	runPrincipal_

Detailed Description

Definition at line 45 of file PrincipalCache.h.

Constructor & Destructor Documentation

edm::PrincipalCache::PrincipalCache ( )

Definition at line 12 of file PrincipalCache.cc.

                                  :
     run_(0U),
     lumi_(0U) {
   }

edm::PrincipalCache::~PrincipalCache ( )

Definition at line 17 of file PrincipalCache.cc.

17 { }

Member Function Documentation

void edm::PrincipalCache::adjustEventsToNewProductRegistry ( std::shared_ptr< ProductRegistry const > reg )

Definition at line 255 of file PrincipalCache.cc.

References edm::Principal::adjustIndexesAfterProductRegistryAddition(), edm::Principal::adjustToNewProductRegistry(), eventPrincipal(), and eventPrincipals_.

Referenced by eventPrincipal(), and edm::EventProcessor::readFile().

                                                                                                 {
     for(auto &eventPrincipal : eventPrincipals_) {
       if (eventPrincipal) {
         eventPrincipal->adjustIndexesAfterProductRegistryAddition();
         bool eventOK = eventPrincipal->adjustToNewProductRegistry(*reg);
         assert(eventOK);
       }
     }
   }

void edm::PrincipalCache::adjustIndexesAfterProductRegistryAddition ( )

Definition at line 265 of file PrincipalCache.cc.

References lumiPrincipal_, and runPrincipal_.

Referenced by eventPrincipal(), and edm::EventProcessor::readFile().

                                                                  {
     if (runPrincipal_) {
       runPrincipal_->adjustIndexesAfterProductRegistryAddition();
     }
     if (lumiPrincipal_) {
       lumiPrincipal_->adjustIndexesAfterProductRegistryAddition();
     }
   }

void edm::PrincipalCache::deleteLumi	(	ProcessHistoryID const &	phid,
		RunNumber_t	run,
		LuminosityBlockNumber_t	lumi
	)

Definition at line 235 of file PrincipalCache.cc.

References Exception, edm::errors::LogicError, lumi_, lumiPrincipal_, reducedInputProcessHistoryID_, and run_.

Referenced by edm::SubProcess::deleteLumiFromCache(), edm::EventProcessor::deleteLumiFromCache(), and eventPrincipal().

                                                                                                              {
     if (lumiPrincipal_.get() == nullptr) {
       throw edm::Exception(edm::errors::LogicError)
         << "PrincipalCache::deleteLumi\n"
         << "Illegal attempt to delete luminosity block from cache\n"
         << "There is no luminosity block in the cache to delete\n"
         << "Contact a Framework Developer\n";
     }
     if (reducedInputProcessHistoryID_ != phid ||
         run != run_ ||
         lumi != lumi_) {
       throw edm::Exception(edm::errors::LogicError)
         << "PrincipalCache::deleteLumi\n"
         << "Illegal attempt to delete luminosity block from cache\n"
         << "Run number, lumi numbers, or reduced ProcessHistoryID inconsistent with those in cache\n"
         << "Contact a Framework Developer\n";
     }
     lumiPrincipal_.reset();
   }

void edm::PrincipalCache::deleteRun	(	ProcessHistoryID const &	phid,
		RunNumber_t	run
	)

Definition at line 216 of file PrincipalCache.cc.

References Exception, edm::errors::LogicError, reducedInputProcessHistoryID_, run_, and runPrincipal_.

Referenced by edm::SubProcess::deleteRunFromCache(), edm::EventProcessor::deleteRunFromCache(), and eventPrincipal().

                                                                               {
     if (runPrincipal_.get() == nullptr) {
       throw edm::Exception(edm::errors::LogicError)
         << "PrincipalCache::deleteRun\n"
         << "Illegal attempt to delete run from cache\n"
         << "There is no run in cache to delete\n"
         << "Contact a Framework Developer\n";
     }
     if (reducedInputProcessHistoryID_ != phid ||
         run != run_) {
       throw edm::Exception(edm::errors::LogicError)
         << "PrincipalCache::deleteRun\n"
         << "Illegal attempt to delete run from cache\n"
         << "Run number or reduced ProcessHistoryID inconsistent with those in cache\n"
         << "Contact a Framework Developer\n";
     }
     runPrincipal_.reset();
   }

EventPrincipal& edm::PrincipalCache::eventPrincipal ( unsigned int iStreamIndex ) const

inline

Definition at line 63 of file PrincipalCache.h.

References adjustEventsToNewProductRegistry(), adjustIndexesAfterProductRegistryAddition(), printConversionInfo::aux, deleteLumi(), deleteRun(), eventPrincipals_, insert(), merge(), and setNumberOfConcurrentPrincipals().

Referenced by adjustEventsToNewProductRegistry(), edm::SubProcess::processAsync(), edm::EventProcessor::processEventAsyncImpl(), and edm::EventProcessor::readEvent().

63 { return *(eventPrincipals_[iStreamIndex]); }

edm::PrincipalCache::eventPrincipals_

std::vector< std::shared_ptr< EventPrincipal > > eventPrincipals_

Definition: PrincipalCache.h:91

bool edm::PrincipalCache::hasLumiPrincipal ( ) const

inline

Definition at line 61 of file PrincipalCache.h.

References electrons_cff::bool, and lumiPrincipal_.

Referenced by edm::EventProcessor::readLuminosityBlock().

61 {return bool(lumiPrincipal_);}

edm::PrincipalCache::lumiPrincipal_

std::shared_ptr< LuminosityBlockPrincipal > lumiPrincipal_

Definition: PrincipalCache.h:90

electrons_cff.bool

bool

Definition: electrons_cff.py:266

bool edm::PrincipalCache::hasRunPrincipal ( ) const

inline

Definition at line 55 of file PrincipalCache.h.

References electrons_cff::bool, lumiPrincipal(), lumiPrincipalPtr(), and runPrincipal_.

Referenced by edm::EventProcessor::readLuminosityBlock(), and edm::EventProcessor::readRun().

55 {return bool(runPrincipal_);}

electrons_cff.bool

bool

Definition: electrons_cff.py:266

edm::PrincipalCache::runPrincipal_

std::shared_ptr< RunPrincipal > runPrincipal_

Definition: PrincipalCache.h:89

void edm::PrincipalCache::insert ( std::shared_ptr< RunPrincipal > rp )

Definition at line 160 of file PrincipalCache.cc.

References Exception, inputProcessHistoryID_, edm::errors::LogicError, processHistoryRegistry_, reducedInputProcessHistoryID_, edm::ProcessHistoryRegistry::reducedProcessHistoryID(), run_, and runPrincipal_.

Referenced by edm::SubProcess::doBeginLuminosityBlockAsync(), edm::SubProcess::doBeginRunAsync(), eventPrincipal(), edm::EventProcessor::init(), edm::EventProcessor::readLuminosityBlock(), edm::EventProcessor::readRun(), and edm::SubProcess::SubProcess().

                                                             {
     if (runPrincipal_.get() != nullptr) {
       throw edm::Exception(edm::errors::LogicError)
         << "PrincipalCache::insert\n"
         << "Illegal attempt to insert run into cache\n"
         << "Contact a Framework Developer\n";
     }
     if (inputProcessHistoryID_ != rp->aux().processHistoryID()) {
       reducedInputProcessHistoryID_ = processHistoryRegistry_->reducedProcessHistoryID(rp->aux().processHistoryID());
       inputProcessHistoryID_ = rp->aux().processHistoryID();
     }
     run_ = rp->run();
     runPrincipal_ = rp; 
   }

void edm::PrincipalCache::insert ( std::shared_ptr< LuminosityBlockPrincipal > lbp )

Definition at line 175 of file PrincipalCache.cc.

References Exception, inputProcessHistoryID_, edm::errors::LogicError, lumi_, lumiPrincipal_, processHistoryRegistry_, reducedInputProcessHistoryID_, edm::ProcessHistoryRegistry::reducedProcessHistoryID(), run_, and runPrincipal_.

                                                                          {
     if (lumiPrincipal_.get() != nullptr) {
       throw edm::Exception(edm::errors::LogicError)
         << "PrincipalCache::insert\n"
         << "Illegal attempt to insert lumi into cache\n"
         << "Contact a Framework Developer\n";
     }
     if (runPrincipal_.get() == nullptr) {
       throw edm::Exception(edm::errors::LogicError)
         << "PrincipalCache::insert\n"
         << "Illegal attempt to insert lumi into cache\n"
         << "Run is invalid\n"
         << "Contact a Framework Developer\n";
     }
     if (inputProcessHistoryID_ != lbp->aux().processHistoryID()) {
       if (reducedInputProcessHistoryID_ != processHistoryRegistry_->reducedProcessHistoryID(lbp->aux().processHistoryID())) {
         throw edm::Exception(edm::errors::LogicError)
           << "PrincipalCache::insert\n"
           << "Illegal attempt to insert lumi into cache\n"
           << "luminosity block has ProcessHistoryID inconsistent with run\n"
           << "Contact a Framework Developer\n";
       }
       inputProcessHistoryID_ = lbp->aux().processHistoryID();
     }
     if (lbp->run() != run_) {
       throw edm::Exception(edm::errors::LogicError)
         << "PrincipalCache::insert\n"
         << "Illegal attempt to insert lumi into cache\n"
         << "luminosity block inconsistent with run number of run in cache\n"
         << "Contact a Framework Developer\n";
     }
     lumi_ = lbp->luminosityBlock();
     lumiPrincipal_ = lbp; 
   }

void edm::PrincipalCache::insert ( std::shared_ptr< EventPrincipal > ep )

Definition at line 210 of file PrincipalCache.cc.

References eventPrincipals_.

                                                               {
     unsigned int iStreamIndex = ep->streamID().value();
     assert(iStreamIndex < eventPrincipals_.size());
     eventPrincipals_[iStreamIndex] = ep;
   }

LuminosityBlockPrincipal & edm::PrincipalCache::lumiPrincipal	(	ProcessHistoryID const &	phid,
		RunNumber_t	run,
		LuminosityBlockNumber_t	lumi
	)		const

Definition at line 62 of file PrincipalCache.cc.

References lumi_, lumiPrincipal_, reducedInputProcessHistoryID_, run_, and throwLumiMissing().

Referenced by edm::EventProcessor::beginLumi(), edm::EventProcessor::endLumi(), edm::SubProcess::writeLumi(), and edm::EventProcessor::writeLumi().

                                                                                                                  {
     if (phid != reducedInputProcessHistoryID_ ||
         run != run_ ||
         lumi != lumi_ ||
         lumiPrincipal_.get() == nullptr) {
       throwLumiMissing();
     }
     return *lumiPrincipal_.get();
   }

LuminosityBlockPrincipal & edm::PrincipalCache::lumiPrincipal ( ) const

Definition at line 84 of file PrincipalCache.cc.

References lumiPrincipal_, and throwLumiMissing().

Referenced by hasRunPrincipal().

                                       {
     if (lumiPrincipal_.get() == nullptr) {
       throwLumiMissing();
     }
     return *lumiPrincipal_.get();
   }

std::shared_ptr< LuminosityBlockPrincipal > const & edm::PrincipalCache::lumiPrincipalPtr	(	ProcessHistoryID const &	phid,
		RunNumber_t	run,
		LuminosityBlockNumber_t	lumi
	)		const

Definition at line 73 of file PrincipalCache.cc.

References lumi_, lumiPrincipal_, reducedInputProcessHistoryID_, run_, and throwLumiMissing().

Referenced by edm::SubProcess::doBeginLuminosityBlockAsync(), edm::SubProcess::doEndLuminosityBlockAsync(), edm::SubProcess::doStreamBeginLuminosityBlockAsync(), edm::SubProcess::doStreamEndLuminosityBlockAsync(), edm::SubProcess::processAsync(), edm::EventProcessor::processEventAsyncImpl(), and edm::EventProcessor::readAndMergeLumi().

                                                                                                                     {
     if (phid != reducedInputProcessHistoryID_ ||
         run != run_ ||
         lumi != lumi_ ||
         lumiPrincipal_.get() == nullptr) {
       throwLumiMissing();
     }
     return lumiPrincipal_;
   }

std::shared_ptr< LuminosityBlockPrincipal > const & edm::PrincipalCache::lumiPrincipalPtr ( ) const

Definition at line 92 of file PrincipalCache.cc.

References lumiPrincipal_, and throwLumiMissing().

Referenced by hasRunPrincipal().

                                          {
     if (lumiPrincipal_.get() == nullptr) {
       throwLumiMissing();
     }
     return lumiPrincipal_;
   }

void edm::PrincipalCache::merge	(	std::shared_ptr< RunAuxiliary >	aux,
		std::shared_ptr< ProductRegistry const >	reg
	)

Definition at line 99 of file PrincipalCache.cc.

References Exception, inputProcessHistoryID_, edm::errors::LogicError, processHistoryRegistry_, reducedInputProcessHistoryID_, edm::ProcessHistoryRegistry::reducedProcessHistoryID(), run_, and runPrincipal_.

Referenced by eventPrincipal(), edm::EventProcessor::readAndMergeLumi(), and edm::EventProcessor::readAndMergeRun().

                                                                                                       {
     if (runPrincipal_.get() == nullptr) {
       throw edm::Exception(edm::errors::LogicError)
         << "PrincipalCache::merge\n"
         << "Illegal attempt to merge run into cache\n"
         << "There is no run in cache to merge with\n"
         << "Contact a Framework Developer\n";
     }
     if (inputProcessHistoryID_ != aux->processHistoryID()) {
       if (reducedInputProcessHistoryID_ != processHistoryRegistry_->reducedProcessHistoryID(aux->processHistoryID())) {
         throw edm::Exception(edm::errors::LogicError)
           << "PrincipalCache::merge\n"
           << "Illegal attempt to merge run into cache\n"
           << "Reduced ProcessHistoryID inconsistent with the one already in cache\n"
           << "Contact a Framework Developer\n";
       }
       inputProcessHistoryID_ = aux->processHistoryID();
     }
     if (aux->run() != run_) {
       throw edm::Exception(edm::errors::LogicError)
         << "PrincipalCache::merge\n"
         << "Illegal attempt to merge run into cache\n"
         << "Run number inconsistent with run number already in cache\n"
         << "Contact a Framework Developer\n";
     }
     bool runOK = runPrincipal_->adjustToNewProductRegistry(*reg);
     assert(runOK);
     runPrincipal_->mergeAuxiliary(*aux);
   }

void edm::PrincipalCache::merge	(	std::shared_ptr< LuminosityBlockAuxiliary >	aux,
		std::shared_ptr< ProductRegistry const >	reg
	)

Definition at line 129 of file PrincipalCache.cc.

References Exception, inputProcessHistoryID_, edm::errors::LogicError, lumi_, lumiPrincipal_, processHistoryRegistry_, reducedInputProcessHistoryID_, edm::ProcessHistoryRegistry::reducedProcessHistoryID(), and run_.

                                                                                                                   {
     if (lumiPrincipal_.get() == nullptr) {
       throw edm::Exception(edm::errors::LogicError)
         << "PrincipalCache::merge\n"
         << "Illegal attempt to merge luminosity block into cache\n"
         << "There is no luminosity block in the cache to merge with\n"
         << "Contact a Framework Developer\n";
     }
     if (inputProcessHistoryID_ != aux->processHistoryID()) {
       if (reducedInputProcessHistoryID_ != processHistoryRegistry_->reducedProcessHistoryID(aux->processHistoryID())) {
         throw edm::Exception(edm::errors::LogicError)
           << "PrincipalCache::merge\n"
           << "Illegal attempt to merge run into cache\n"
           << "Reduced ProcessHistoryID inconsistent with the one already in cache\n"
           << "Contact a Framework Developer\n";
       }
       inputProcessHistoryID_ = aux->processHistoryID();
     }
     if (aux->run() != run_ ||
         aux->luminosityBlock() != lumi_) {
       throw edm::Exception(edm::errors::LogicError)
         << "PrincipalCache::merge\n"
         << "Illegal attempt to merge lumi into cache\n"
         << "Run and lumi numbers are inconsistent with the ones already in the cache\n"
         << "Contact a Framework Developer\n";
     }
     bool lumiOK = lumiPrincipal_->adjustToNewProductRegistry(*reg);
     assert(lumiOK);
     lumiPrincipal_->mergeAuxiliary(*aux);
   }

RunPrincipal & edm::PrincipalCache::runPrincipal	(	ProcessHistoryID const &	phid,
		RunNumber_t	run
	)		const

Definition at line 26 of file PrincipalCache.cc.

References reducedInputProcessHistoryID_, run_, runPrincipal_, and throwRunMissing().

Referenced by edm::EventProcessor::beginRun(), edm::EventProcessor::endRun(), edm::SubProcess::writeRun(), and edm::EventProcessor::writeRun().

                                                                                   {
     if (phid != reducedInputProcessHistoryID_ ||
         run != run_ ||
         runPrincipal_.get() == nullptr) {
       throwRunMissing();
     }
     return *runPrincipal_.get();
   }

RunPrincipal & edm::PrincipalCache::runPrincipal ( ) const

Definition at line 46 of file PrincipalCache.cc.

References runPrincipal_, and throwRunMissing().

                                      {
     if (runPrincipal_.get() == nullptr) {
       throwRunMissing();
     }
     return *runPrincipal_.get();
   }

std::shared_ptr< RunPrincipal > const & edm::PrincipalCache::runPrincipalPtr	(	ProcessHistoryID const &	phid,
		RunNumber_t	run
	)		const

Definition at line 36 of file PrincipalCache.cc.

References reducedInputProcessHistoryID_, run_, runPrincipal_, and throwRunMissing().

Referenced by edm::SubProcess::doBeginLuminosityBlockAsync(), edm::SubProcess::doBeginRunAsync(), edm::SubProcess::doEndRunAsync(), edm::SubProcess::doStreamBeginRunAsync(), edm::SubProcess::doStreamEndRunAsync(), edm::EventProcessor::readAndMergeRun(), and edm::EventProcessor::readLuminosityBlock().

                                                                                      {
     if (phid != reducedInputProcessHistoryID_ ||
         run != run_ ||
         runPrincipal_.get() == nullptr) {
       throwRunMissing();
     }
     return runPrincipal_;
   }

std::shared_ptr< RunPrincipal > const & edm::PrincipalCache::runPrincipalPtr ( ) const

Definition at line 54 of file PrincipalCache.cc.

References runPrincipal_, and throwRunMissing().

                                         {
     if (runPrincipal_.get() == nullptr) {
       throwRunMissing();
     }
     return runPrincipal_;
   }

void edm::PrincipalCache::setNumberOfConcurrentPrincipals ( PreallocationConfiguration const & iConfig )

Definition at line 20 of file PrincipalCache.cc.

References eventPrincipals_, and edm::PreallocationConfiguration::numberOfStreams().

Referenced by eventPrincipal(), edm::EventProcessor::init(), and edm::SubProcess::SubProcess().

   {
     eventPrincipals_.resize(iConfig.numberOfStreams());
   }

void edm::PrincipalCache::setProcessHistoryRegistry ( ProcessHistoryRegistry const & phr )

inline

Definition at line 80 of file PrincipalCache.h.

References processHistoryRegistry_, throwLumiMissing(), and throwRunMissing().

Referenced by edm::EventProcessor::init(), and edm::SubProcess::SubProcess().

80 {processHistoryRegistry_ = &phr;}

edm::PrincipalCache::processHistoryRegistry_

ProcessHistoryRegistry const * processHistoryRegistry_

Definition: PrincipalCache.h:94

void edm::PrincipalCache::throwLumiMissing ( ) const

private

Definition at line 283 of file PrincipalCache.cc.

References Exception, and edm::errors::LogicError.

Referenced by lumiPrincipal(), lumiPrincipalPtr(), and setProcessHistoryRegistry().

                                          {
     throw edm::Exception(edm::errors::LogicError)
       << "PrincipalCache::lumiPrincipal or PrincipalCache::lumiPrincipalPtr\n"
       << "Requested a luminosity block that is not in the cache (should never happen)\n"
       << "Contact a Framework Developer\n";
   }

void edm::PrincipalCache::throwRunMissing ( ) const

private

Definition at line 275 of file PrincipalCache.cc.

References Exception, and edm::errors::LogicError.

Referenced by runPrincipal(), runPrincipalPtr(), and setProcessHistoryRegistry().

                                         {
     throw edm::Exception(edm::errors::LogicError)
       << "PrincipalCache::runPrincipal\n"
       << "Requested a run that is not in the cache (should never happen)\n"
       << "Contact a Framework Developer\n";
   }