#include <Principal.h>

Inheritance diagram for edm::Principal:

Public Types
typedef std::vector< BasicHandle >	BasicHandleVec

typedef unsigned long	CacheIdentifier_t

typedef boost::filter_iterator < FilledProductPtr, ProductHolderCollection::const_iterator >	const_iterator

typedef ProductHolderBase const *	ConstProductHolderPtr

typedef std::string	ProcessName

typedef ProcessHistory::const_iterator	ProcessNameConstIterator

typedef std::vector < boost::shared_ptr < ProductHolderBase > >	ProductHolderCollection

typedef boost::shared_ptr < ProductHolderBase >	SharedProductPtr

typedef ProductHolderCollection::size_type	size_type

Public Member Functions
void	addAliasedProduct (boost::shared_ptr< BranchDescription const > bd)

void	addInputProduct (boost::shared_ptr< BranchDescription const > bd)

void	addScheduledProduct (boost::shared_ptr< BranchDescription const > bd)

void	addSourceProduct (boost::shared_ptr< BranchDescription const > bd)

void	addUnscheduledProduct (boost::shared_ptr< BranchDescription const > bd)

void	adjustIndexesAfterProductRegistryAddition ()

bool	adjustToNewProductRegistry (ProductRegistry const &reg)

const_iterator	begin () const

BranchType const &	branchType () const

CacheIdentifier_t	cacheIdentifier () const

void	clearPrincipal ()

void	deleteProduct (BranchID const &id)

const_iterator	end () const

void	fillPrincipal (ProcessHistoryID const &hist, ProcessHistoryRegistry const &phr, DelayedReader *reader)

ProductData const *	findProductByTag (TypeID const &typeID, InputTag const &tag, ModuleCallingContext const *mcc) const

void	getAllProvenance (std::vector< Provenance const * > &provenances) const

BasicHandle	getByLabel (KindOfType kindOfType, TypeID const &typeID, InputTag const &inputTag, EDConsumerBase const consumes, ModuleCallingContext const mcc) const

BasicHandle	getByLabel (KindOfType kindOfType, TypeID const &typeID, std::string const &label, std::string const &instance, std::string const &process, EDConsumerBase const consumes, ModuleCallingContext const mcc) const

BasicHandle	getByToken (KindOfType kindOfType, TypeID const &typeID, ProductHolderIndex index, bool skipCurrentProcess, bool &ambiguous, ModuleCallingContext const *mcc) const

OutputHandle	getForOutput (BranchID const &bid, bool getProd, ModuleCallingContext const *mcc) const

void	getManyByType (TypeID const &typeID, BasicHandleVec &results, EDConsumerBase const consumes, ModuleCallingContext const mcc) const

ConstProductHolderPtr	getProductHolder (BranchID const &oid) const

ConstProductHolderPtr	getProductHolderByIndex (ProductHolderIndex const &oid) const

Provenance	getProvenance (BranchID const &bid, ModuleCallingContext const *mcc) const

bool	isComplete () const

std::vector< unsigned int > const &	lookupProcessOrder () const

void	prefetch (ProductHolderIndex index, bool skipCurrentProcess, ModuleCallingContext const *mcc) const

	Principal (boost::shared_ptr< ProductRegistry const > reg, boost::shared_ptr< ProductHolderIndexHelper const > productLookup, ProcessConfiguration const &pc, BranchType bt, HistoryAppender *historyAppender)

ProcessConfiguration const &	processConfiguration () const

ProcessHistory const &	processHistory () const

ProcessHistoryID const &	processHistoryID () const

EDProductGetter const *	prodGetter () const

ProductHolderIndexHelper const &	productLookup () const

ProductRegistry const &	productRegistry () const

DelayedReader *	reader () const

void	readFromSource (ProductHolderBase const &phb, ModuleCallingContext const *mcc) const

void	recombine (Principal &other, std::vector< BranchID > const &bids)

size_t	size () const

virtual bool	unscheduledFill (std::string const &moduleLabel, ModuleCallingContext const *mcc) const =0

virtual	~Principal ()

Public Member Functions inherited from edm::EDProductGetter
	EDProductGetter ()

unsigned int	transitionIndex () const

virtual	~EDProductGetter ()

Protected Member Functions
void	addProduct_ (std::auto_ptr< ProductHolderBase > phb)

void	addProductOrThrow (std::auto_ptr< ProductHolderBase > phb)

void	checkUniquenessAndType (WrapperOwningHolder const &prod, ProductHolderBase const *productHolder) const

ProductHolderBase *	getExistingProduct (BranchID const &branchID)

ProductHolderBase *	getExistingProduct (ProductHolderBase const &phb)

void	putOrMerge (WrapperOwningHolder const &prod, ProductHolderBase const *productHolder) const

void	putOrMerge (WrapperOwningHolder const &prod, ProductProvenance &prov, ProductHolderBase *productHolder)

Private Member Functions
ProductData const *	findProductByLabel (KindOfType kindOfType, TypeID const &typeID, InputTag const &inputTag, EDConsumerBase const consumer, ModuleCallingContext const mcc) const

ProductData const *	findProductByLabel (KindOfType kindOfType, TypeID const &typeID, std::string const &label, std::string const &instance, std::string const &process, EDConsumerBase const consumer, ModuleCallingContext const mcc) const

void	findProducts (std::vector< ProductHolderBase const * > const &holders, TypeID const &typeID, BasicHandleVec &results, ModuleCallingContext const *mcc) const

virtual WrapperHolder	getIt (ProductID const &) const

virtual bool	isComplete_ () const

virtual void	readFromSource_ (ProductHolderBase const &phb, ModuleCallingContext const *mcc) const

Private Attributes
BranchType	branchType_

CacheIdentifier_t	cacheIdentifier_

HistoryAppender *	historyAppender_

std::vector< unsigned int >	lookupProcessOrder_

ProcessHistoryID	orderProcessHistoryID_

boost::shared_ptr < ProductRegistry const >	preg_

ProcessConfiguration const *	processConfiguration_

ProcessHistoryID	processHistoryID_

boost::shared_ptr < ProcessHistory const >	processHistoryPtr_

ProductHolderCollection	productHolders_

boost::shared_ptr < ProductHolderIndexHelper const >	productLookup_

std::set< void const * >	productPtrs_

DelayedReader *	reader_

Additional Inherited Members
Static Public Member Functions inherited from edm::EDProductGetter
static void	assignEDProductGetter (EDProductGetter const *&)

static EDProductGetter const *	switchProductGetter (EDProductGetter const *)
	These can only be used internally by the framework. More...

Detailed Description

Definition at line 55 of file Principal.h.

Member Typedef Documentation

typedef std::vector<BasicHandle> edm::Principal::BasicHandleVec

Definition at line 61 of file Principal.h.

typedef unsigned long edm::Principal::CacheIdentifier_t

Definition at line 170 of file Principal.h.

typedef boost::filter_iterator<FilledProductPtr, ProductHolderCollection::const_iterator> edm::Principal::const_iterator

Definition at line 58 of file Principal.h.

typedef ProductHolderBase const* edm::Principal::ConstProductHolderPtr

Definition at line 60 of file Principal.h.

typedef std::string edm::Principal::ProcessName

Definition at line 65 of file Principal.h.

typedef ProcessHistory::const_iterator edm::Principal::ProcessNameConstIterator

Definition at line 59 of file Principal.h.

typedef std::vector<boost::shared_ptr<ProductHolderBase> > edm::Principal::ProductHolderCollection

Definition at line 57 of file Principal.h.

typedef boost::shared_ptr<ProductHolderBase> edm::Principal::SharedProductPtr

Definition at line 64 of file Principal.h.

typedef ProductHolderCollection::size_type edm::Principal::size_type

Definition at line 62 of file Principal.h.

Constructor & Destructor Documentation

edm::Principal::Principal	(	boost::shared_ptr< ProductRegistry const >	reg,
		boost::shared_ptr< ProductHolderIndexHelper const >	productLookup,
		ProcessConfiguration const &	pc,
		BranchType	bt,
		HistoryAppender *	historyAppender
	)

Definition at line 125 of file Principal.cc.

References addAliasedProduct(), addInputProduct(), addScheduledProduct(), addSourceProduct(), addUnscheduledProduct(), edm::ProductHolderIndexHelper::Range::begin(), edm::BranchDescription::branchType(), branchType_, edm::ProductHolderIndexHelper::Range::end(), spr::find(), i, edm::ProductHolderIndexHelper::IndexAndNames::index(), edm::InEvent, edm::BranchDescription::isAlias(), gen::k, edm::BranchDescription::moduleLabel(), edm::BranchDescription::onDemand(), LaserDQM_cfg::process, parseEventContent::prod, edm::BranchDescription::produced(), edm::ProductHolderIndexAmbiguous, edm::ProductHolderIndexInvalid, productHolders_, productLookup_, diffTwoXMLs::ranges, edm::source(), edm::ProductHolderIndexHelper::IndexAndNames::startInProcessNames(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                          :
     EDProductGetter(),
     processHistoryPtr_(),
     processHistoryID_(),
     processConfiguration_(&pc),
     productHolders_(reg->getNextIndexValue(bt), SharedProductPtr()),
     preg_(reg),
     productLookup_(productLookup),
     lookupProcessOrder_(productLookup->lookupProcessNames().size(), 0),
     reader_(),
     productPtrs_(),
     branchType_(bt),
     historyAppender_(historyAppender),
     cacheIdentifier_(nextIdentifier())
   {
 
     //Now that these have been set, we can create the list of Branches we need.
     std::string const source("source");
     ProductRegistry::ProductList const& prodsList = reg->productList();
     // The constructor of an alias product holder takes as an argument the product holder for which it is an alias.
     // So, the non-alias product holders must be created first.
     // Therefore, on this first pass, skip current EDAliases.
     bool hasAliases = false;
     for(auto const& prod : prodsList) {
       BranchDescription const& bd = prod.second;
       if(bd.branchType() == branchType_) {
         if(bd.isAlias()) {
           hasAliases = true;
         } else {
           boost::shared_ptr<BranchDescription const> cbd(new BranchDescription const(bd));
           if(bd.produced()) {
             if(bd.moduleLabel() == source) {
               addSourceProduct(cbd);
             } else if(bd.onDemand()) {
               assert(branchType_ == InEvent);
               addUnscheduledProduct(cbd);
             } else {
               addScheduledProduct(cbd);
             }
           } else {
             addInputProduct(cbd);
           }
         }
       }
     }
     // Now process any EDAliases
     if(hasAliases) {
       for(auto const& prod : prodsList) {
         BranchDescription const& bd = prod.second;
         if(bd.isAlias() && bd.branchType() == branchType_) {
           boost::shared_ptr<BranchDescription const> cbd(new BranchDescription const(bd));
           addAliasedProduct(cbd);
         }
       }
     }
 
     // Now create the ProductHolders that search in reverse process
     // order and are used for queries where the process name is the
     // empty string
     std::vector<std::string> const& lookupProcessNames = productLookup_->lookupProcessNames();
     std::vector<ProductHolderIndex> matchingHolders(lookupProcessNames.size(), ProductHolderIndexInvalid);
     std::vector<bool> ambiguous(lookupProcessNames.size(), false);
     unsigned int beginElements = productLookup_->beginElements();
     std::vector<TypeID> const& sortedTypeIDs = productLookup_->sortedTypeIDs();
     std::vector<ProductHolderIndexHelper::Range> const& ranges = productLookup_->ranges();
     std::vector<ProductHolderIndexHelper::IndexAndNames> const& indexAndNames = productLookup_->indexAndNames();
     std::vector<char> const& processNamesCharArray = productLookup_->processNames();
 
     if (!sortedTypeIDs.empty()) {
       ProductHolderIndex productHolderIndex = ProductHolderIndexInvalid;
       for(unsigned int k = 0, kEnd = sortedTypeIDs.size(); k < kEnd; ++k) {
         ProductHolderIndexHelper::Range const& range = ranges.at(k);
         for (unsigned int i = range.begin(); i < range.end(); ++i) {
           ProductHolderIndexHelper::IndexAndNames const& product = indexAndNames.at(i);
           if (product.startInProcessNames() == 0) {
             if (productHolderIndex != ProductHolderIndexInvalid) {
               boost::shared_ptr<ProductHolderBase> newHolder(new NoProcessProductHolder(matchingHolders, ambiguous, this));
               productHolders_.at(productHolderIndex) = newHolder;
               matchingHolders.assign(lookupProcessNames.size(), ProductHolderIndexInvalid);
               ambiguous.assign(lookupProcessNames.size(), false);
             }
             productHolderIndex = product.index();
           } else {
             std::string process(&processNamesCharArray.at(product.startInProcessNames()));
             auto iter = std::find(lookupProcessNames.begin(), lookupProcessNames.end(), process);
             assert(iter != lookupProcessNames.end());
             ProductHolderIndex iMatchingIndex = product.index();
             assert(iMatchingIndex != ProductHolderIndexInvalid);
             if (iMatchingIndex == ProductHolderIndexAmbiguous) {
               assert(k >= beginElements);
               ambiguous.at(iter - lookupProcessNames.begin()) = true;
             } else {
               matchingHolders.at(iter - lookupProcessNames.begin()) = iMatchingIndex;
             }
           }
         }
       }
       boost::shared_ptr<ProductHolderBase> newHolder(new NoProcessProductHolder(matchingHolders, ambiguous, this));
       productHolders_.at(productHolderIndex) = newHolder;
     }
   }

edm::Principal::~Principal ( )

virtual

Definition at line 231 of file Principal.cc.

231 {

232 }

Member Function Documentation

void edm::Principal::addAliasedProduct ( boost::shared_ptr< BranchDescription const > bd )

Definition at line 294 of file Principal.cc.

References addProductOrThrow(), getHLTprescales::index, preg_, edm::ProductHolderIndexInvalid, and productHolders_.

Referenced by Principal().

                                                                           {
     ProductHolderIndex index = preg_->indexFrom(bd->originalBranchID());
     assert(index != ProductHolderIndexInvalid);
 
     std::auto_ptr<ProductHolderBase> phb(new AliasProductHolder(bd, dynamic_cast<ProducedProductHolder&>(*productHolders_[index])));
     addProductOrThrow(phb);
   }

void edm::Principal::addInputProduct ( boost::shared_ptr< BranchDescription const > bd )

Definition at line 282 of file Principal.cc.

References addProductOrThrow().

Referenced by adjustIndexesAfterProductRegistryAddition(), and Principal().

                                                                         {
     std::auto_ptr<ProductHolderBase> phb(new InputProductHolder(bd, this));
     addProductOrThrow(phb);
   }

void edm::Principal::addProduct_ ( std::auto_ptr< ProductHolderBase > phb )

protected

Definition at line 398 of file Principal.cc.

References edm::BranchDescription::branchID(), edm::BranchDescription::className(), edm::BranchDescription::friendlyClassName(), getHLTprescales::index, edm::BranchDescription::moduleLabel(), preg_, edm::BranchDescription::processName(), edm::ProductHolderIndexInvalid, and productHolders_.

Referenced by addProductOrThrow().

                                                                      {
     BranchDescription const& bd = productHolder->branchDescription();
     assert (!bd.className().empty());
     assert (!bd.friendlyClassName().empty());
     assert (!bd.moduleLabel().empty());
     assert (!bd.processName().empty());
     SharedProductPtr phb(productHolder);
 
     ProductHolderIndex index = preg_->indexFrom(bd.branchID());
     assert(index != ProductHolderIndexInvalid);
     productHolders_[index] = phb;
   }

void edm::Principal::addProductOrThrow ( std::auto_ptr< ProductHolderBase > phb )

protected

Definition at line 412 of file Principal.cc.

References addProduct_(), edm::hlt::Exception, edm::BranchDescription::friendlyClassName(), getExistingProduct(), edm::errors::InsertFailure, edm::BranchDescription::moduleLabel(), edm::BranchDescription::processName(), and edm::BranchDescription::productInstanceName().

Referenced by addAliasedProduct(), addInputProduct(), addScheduledProduct(), addSourceProduct(), and addUnscheduledProduct().

                                                                            {
     ProductHolderBase const* phb = getExistingProduct(*productHolder);
     if(phb != nullptr) {
       BranchDescription const& bd = productHolder->branchDescription();
       throw Exception(errors::InsertFailure, "AlreadyPresent")
           << "addProductOrThrow: Problem found while adding product, "
           << "product already exists for ("
           << bd.friendlyClassName() << ","
           << bd.moduleLabel() << ","
           << bd.productInstanceName() << ","
           << bd.processName()
           << ")\n";
     }
     addProduct_(productHolder);
   }

void edm::Principal::addScheduledProduct ( boost::shared_ptr< BranchDescription const > bd )

Definition at line 270 of file Principal.cc.

References addProductOrThrow().

Referenced by Principal().

                                                                             {
     std::auto_ptr<ProductHolderBase> phb(new ScheduledProductHolder(bd));
     addProductOrThrow(phb);
   }

void edm::Principal::addSourceProduct ( boost::shared_ptr< BranchDescription const > bd )

Definition at line 276 of file Principal.cc.

References addProductOrThrow().

Referenced by Principal().

                                                                          {
     std::auto_ptr<ProductHolderBase> phb(new SourceProductHolder(bd));
     addProductOrThrow(phb);
   }

void edm::Principal::addUnscheduledProduct ( boost::shared_ptr< BranchDescription const > bd )

Definition at line 288 of file Principal.cc.

References addProductOrThrow().

Referenced by Principal().

                                                                               {
     std::auto_ptr<ProductHolderBase> phb(new UnscheduledProductHolder(bd, this));
     addProductOrThrow(phb);
   }

void edm::Principal::adjustIndexesAfterProductRegistryAddition ( )

Definition at line 831 of file Principal.cc.

References addInputProduct(), edm::BranchDescription::branchID(), edm::BranchDescription::branchType(), branchType_, getHLTprescales::index, preg_, parseEventContent::prod, edm::BranchDescription::produced(), edm::ProductHolderIndexInvalid, and productHolders_.

Referenced by edm::PrincipalCache::adjustEventsToNewProductRegistry(), and edm::StreamerInputSource::read().

                                                        {
     if(preg_->getNextIndexValue(branchType_) != productHolders_.size()) {
       productHolders_.resize(preg_->getNextIndexValue(branchType_));
       for(auto const& prod : preg_->productList()) {
         BranchDescription const& bd = prod.second;
         if(bd.branchType() == branchType_) {
           ProductHolderIndex index = preg_->indexFrom(bd.branchID());
           assert(index != ProductHolderIndexInvalid);
           if(!productHolders_[index]) {
             // no product holder.  Must add one. The new entry must be an input product holder.
             assert(!bd.produced());
             boost::shared_ptr<BranchDescription const> cbd(new BranchDescription const(bd));
             addInputProduct(cbd);
           }
         }
       }
     }
     assert(preg_->getNextIndexValue(branchType_) == productHolders_.size());
   }

bool edm::Principal::adjustToNewProductRegistry ( ProductRegistry const & reg )

Definition at line 253 of file Principal.cc.

References edm::ProductHolderBase::branchDescription(), edm::BranchDescription::branchName(), edm::BranchDescription::branchType(), branchType_, getExistingProduct(), parseEventContent::prod, edm::BranchDescription::produced(), edm::ProductRegistry::productList(), and edm::ProductHolderBase::resetBranchDescription().

Referenced by edm::PrincipalCache::adjustEventsToNewProductRegistry(), and edm::StreamerInputSource::read().

                                                                   {
     ProductRegistry::ProductList const& prodsList = reg.productList();
     for(auto const& prod : prodsList) {
       BranchDescription const& bd = prod.second;
       if(!bd.produced() && (bd.branchType() == branchType_)) {
         boost::shared_ptr<BranchDescription const> cbd(new BranchDescription const(bd));
         ProductHolderBase* phb = getExistingProduct(cbd->branchID());
         if(phb == nullptr || phb->branchDescription().branchName() != cbd->branchName()) {
             return false;
         }
         phb->resetBranchDescription(cbd);
       }
     }
     return true;
   }

const_iterator edm::Principal::begin ( void ) const

inline

Definition at line 159 of file Principal.h.

References productHolders_.

Referenced by edm::check(), edm::OutputModule::updateBranchParents(), edm::one::OutputModuleBase::updateBranchParents(), and edm::ProvenanceCheckerOutputModule::write().

159 {return boost::make_filter_iterator<FilledProductPtr>(productHolders_.begin(), productHolders_.end());}

edm::Principal::productHolders_

ProductHolderCollection productHolders_

Definition: Principal.h:247

BranchType const& edm::Principal::branchType ( ) const

inline

Definition at line 167 of file Principal.h.

References branchType_.

Referenced by findProductByLabel(), and getManyByType().

167 {return branchType_;}

edm::Principal::branchType_

BranchType branchType_

Definition: Principal.h:264

CacheIdentifier_t edm::Principal::cacheIdentifier ( ) const

inline

Definition at line 171 of file Principal.h.

References cacheIdentifier_.

Referenced by edm::LuminosityBlock::cacheIdentifier(), edm::Run::cacheIdentifier(), and edm::Event::cacheIdentifier().

171 {return cacheIdentifier_;}

edm::Principal::cacheIdentifier_

CacheIdentifier_t cacheIdentifier_

Definition: Principal.h:271

void edm::Principal::checkUniquenessAndType	(	WrapperOwningHolder const &	prod,
		ProductHolderBase const *	productHolder
	)		const

protected

Definition at line 792 of file Principal.cc.

References edm::ProductHolderBase::branchDescription(), edm::BranchDescription::branchName(), edm::ProductHolderBase::checkType(), edm::WrapperHolder::isValid(), parseEventContent::prod, productPtrs_, reset(), edm::second(), edm::throwCorruptionException(), and edm::WrapperHolder::wrapper().

Referenced by edm::EventPrincipal::put(), edm::EventPrincipal::putOnRead(), putOrMerge(), and edm::EventPrincipal::readFromSource_().

                                                                                                        {
     if(!prod.isValid()) return;
     // These are defensive checks against things that should never happen, but have.
     // Checks that the same physical product has not already been put into the event.
     bool alreadyPresent = !productPtrs_.insert(prod.wrapper()).second;
     if(alreadyPresent) {
       phb->checkType(prod);
       const_cast<WrapperOwningHolder&>(prod).reset();
       throwCorruptionException("checkUniquenessAndType", phb->branchDescription().branchName());
     }
     // Checks that the real type of the product matches the branch.
     phb->checkType(prod);
   }

void edm::Principal::clearPrincipal ( )

Definition at line 304 of file Principal.cc.

References processHistoryID_, processHistoryPtr_, parseEventContent::prod, productPtrs_, and reader_.

Referenced by edm::EventPrincipal::clearEventPrincipal(), and edm::PoolSource::readEvent_().

                             {
     processHistoryPtr_.reset();
     processHistoryID_ = ProcessHistoryID();
     reader_ = nullptr;
     for(auto const& prod : *this) {
       prod->resetProductData();
     }
     productPtrs_.clear();
   }

void edm::Principal::deleteProduct ( BranchID const & id )

Definition at line 315 of file Principal.cc.

References edm::ProductHolderBase::deleteProduct(), getExistingProduct(), edm::ProductHolderBase::product(), and productPtrs_.

Referenced by edm::EarlyDeleteHelper::moduleRan().

                                              {
     ProductHolderBase* phb = getExistingProduct(id);
     assert(nullptr != phb);
     auto itFound = productPtrs_.find(phb->product().get());
     if(itFound != productPtrs_.end()) {
       productPtrs_.erase(itFound);
     } 
     phb->deleteProduct();
   }

const_iterator edm::Principal::end ( void ) const

inline

Definition at line 160 of file Principal.h.

References productHolders_.

Referenced by edm::check(), Types.LuminosityBlockRange::cppID(), Types.EventRange::cppID(), edm::OutputModule::updateBranchParents(), edm::one::OutputModuleBase::updateBranchParents(), and edm::ProvenanceCheckerOutputModule::write().

160 {return boost::make_filter_iterator<FilledProductPtr>(productHolders_.end(), productHolders_.end());}

edm::Principal::productHolders_

ProductHolderCollection productHolders_

Definition: Principal.h:247

void edm::Principal::fillPrincipal	(	ProcessHistoryID const &	hist,
		ProcessHistoryRegistry const &	phr,
		DelayedReader *	reader
	)

Definition at line 327 of file Principal.cc.

References edm::HistoryAppender::appendToProcessHistory(), cacheIdentifier_, edm::hlt::Exception, spr::find(), edm::ProcessHistoryRegistry::getMapped(), estimatePileup::hist, historyAppender_, edm::Hash< I >::isValid(), gen::k, edm::errors::LogicError, lookupProcessOrder_, edm::nextIdentifier(), orderProcessHistoryID_, processConfiguration_, processHistoryID_, processHistoryPtr_, productLookup_, productRegistry(), reader(), reader_, and edm::s_emptyProcessHistory.

Referenced by edm::EventPrincipal::fillEventPrincipal(), edm::LuminosityBlockPrincipal::fillLuminosityBlockPrincipal(), and edm::RunPrincipal::fillRunPrincipal().

                                                   {
     //increment identifier here since clearPrincipal isn't called for Run/Lumi
     cacheIdentifier_=nextIdentifier();
     if(reader) {
       reader_ = reader;
     }
 
     if (historyAppender_ && productRegistry().anyProductProduced()) {
       processHistoryPtr_ =
         historyAppender_->appendToProcessHistory(hist,
                                                  processHistoryRegistry.getMapped(hist),
                                                  *processConfiguration_);
       processHistoryID_ = processHistoryPtr_->id();
     }
     else {
       boost::shared_ptr<ProcessHistory const> inputProcessHistory;
       if (hist.isValid()) {
         //does not own the pointer
         auto noDel =[](void const*){};
         inputProcessHistory =
         boost::shared_ptr<ProcessHistory const>(processHistoryRegistry.getMapped(hist),noDel);
         if (inputProcessHistory.get() == nullptr) {
           throw Exception(errors::LogicError)
             << "Principal::fillPrincipal\n"
             << "Input ProcessHistory not found in registry\n"
             << "Contact a Framework developer\n";
         }
       } else {
         //Since this is static we don't want it deleted
         inputProcessHistory = boost::shared_ptr<ProcessHistory const>(&s_emptyProcessHistory,[](void const*){});
       }
       processHistoryID_ = hist;
       processHistoryPtr_ = inputProcessHistory;        
     }
 
     if (orderProcessHistoryID_ != processHistoryID_) {
       std::vector<std::string> const& lookupProcessNames = productLookup_->lookupProcessNames();
       lookupProcessOrder_.assign(lookupProcessNames.size(), 0);
       unsigned int k = 0;
       for (auto iter = processHistoryPtr_->rbegin(),
                 iEnd = processHistoryPtr_->rend();
            iter != iEnd; ++iter) {
         auto nameIter = std::find(lookupProcessNames.begin(), lookupProcessNames.end(), iter->processName());
         if (nameIter == lookupProcessNames.end()) {
           continue;
         }
         lookupProcessOrder_.at(k) = nameIter - lookupProcessNames.begin();
         ++k;
       }
       orderProcessHistoryID_ = processHistoryID_;
     }
   }

ProductData const * edm::Principal::findProductByLabel	(	KindOfType	kindOfType,
		TypeID const &	typeID,
		InputTag const &	inputTag,
		EDConsumerBase const *	consumer,
		ModuleCallingContext const *	mcc
	)		const

private

Definition at line 612 of file Principal.cc.

References edm::ProductHolderBase::Ambiguous, branchType(), edm::ELEMENT_TYPE, getHLTprescales::index, edm::ProductHolderIndexHelper::index(), edm::InputTag::indexFor(), edm::InputTag::instance(), edm::InputTag::label(), edm::maybeThrowMissingDictionaryException(), edm::ProductHolderIndexHelper::Matches::numberOfMatches(), preg_, edm::InputTag::process(), edm::ProductHolderIndexAmbiguous, edm::ProductHolderIndexInvalid, productHolders_, productLookup(), productRegistry(), edm::EDConsumerBase::registeredToConsume(), edm::ProductHolderIndexHelper::relatedIndexes(), edm::throwAmbiguousException(), edm::InputTag::tryToCacheIndex(), unlikely, and edm::InputTag::willSkipCurrentProcess().

Referenced by findProductByTag(), and getByLabel().

                                                                        {
 
     bool skipCurrentProcess = inputTag.willSkipCurrentProcess();
 
     ProductHolderIndex index = inputTag.indexFor(typeID, branchType(), &productRegistry());
 
     if (index == ProductHolderIndexInvalid) {
 
       char const* processName = inputTag.process().c_str();
       if (skipCurrentProcess) {
         processName = "\0";
       }
 
       index = productLookup().index(kindOfType,
                                     typeID,
                                     inputTag.label().c_str(),
                                     inputTag.instance().c_str(),
                                     processName);
 
       if(index == ProductHolderIndexAmbiguous) {
         throwAmbiguousException("findProductByLabel", typeID, inputTag.label(), inputTag.instance(), inputTag.process());
       } else if (index == ProductHolderIndexInvalid) {
         ProductHolderIndexHelper::Matches matches =
           productLookup().relatedIndexes(kindOfType, typeID);
 
         if (matches.numberOfMatches() == 0) {
           maybeThrowMissingDictionaryException(typeID, kindOfType == ELEMENT_TYPE, preg_->missingDictionaries());
         }
         return 0;
       }
       inputTag.tryToCacheIndex(index, typeID, branchType(), &productRegistry());
     }
     if(unlikely( consumer and (not consumer->registeredToConsume(index, skipCurrentProcess, branchType())))) {
       failedToRegisterConsumes(kindOfType,typeID,inputTag.label(),inputTag.instance(),inputTag.process());
     }
 
     
     boost::shared_ptr<ProductHolderBase> const& productHolder = productHolders_[index];
 
     ProductHolderBase::ResolveStatus resolveStatus;
     ProductData const* productData = productHolder->resolveProduct(resolveStatus, skipCurrentProcess, mcc);
     if(resolveStatus == ProductHolderBase::Ambiguous) {
       throwAmbiguousException("findProductByLabel", typeID, inputTag.label(), inputTag.instance(), inputTag.process());
     }
     return productData;
   }

ProductData const * edm::Principal::findProductByLabel	(	KindOfType	kindOfType,
		TypeID const &	typeID,
		std::string const &	label,
		std::string const &	instance,
		std::string const &	process,
		EDConsumerBase const *	consumer,
		ModuleCallingContext const *	mcc
	)		const

private

Definition at line 664 of file Principal.cc.

References edm::ProductHolderBase::Ambiguous, branchType(), edm::ELEMENT_TYPE, getHLTprescales::index, edm::ProductHolderIndexHelper::index(), edm::maybeThrowMissingDictionaryException(), edm::ProductHolderIndexHelper::Matches::numberOfMatches(), preg_, edm::ProductHolderIndexAmbiguous, edm::ProductHolderIndexInvalid, productHolders_, productLookup(), edm::EDConsumerBase::registeredToConsume(), edm::ProductHolderIndexHelper::relatedIndexes(), edm::throwAmbiguousException(), and unlikely.

                                                                        {
 
     ProductHolderIndex index = productLookup().index(kindOfType,
                                                      typeID,
                                                      label.c_str(),
                                                      instance.c_str(),
                                                      process.c_str());
    
     if(index == ProductHolderIndexAmbiguous) {
       throwAmbiguousException("findProductByLabel", typeID, label, instance, process);
     } else if (index == ProductHolderIndexInvalid) {
       ProductHolderIndexHelper::Matches matches =
         productLookup().relatedIndexes(kindOfType, typeID);
 
       if (matches.numberOfMatches() == 0) {
         maybeThrowMissingDictionaryException(typeID, kindOfType == ELEMENT_TYPE, preg_->missingDictionaries());
       }
       return 0;
     }
     
     if(unlikely( consumer and (not consumer->registeredToConsume(index, false, branchType())))) {
       failedToRegisterConsumes(kindOfType,typeID,label,instance,process);
     }
     
     boost::shared_ptr<ProductHolderBase> const& productHolder = productHolders_[index];
 
     ProductHolderBase::ResolveStatus resolveStatus;
     ProductData const* productData = productHolder->resolveProduct(resolveStatus, false, mcc);
     if(resolveStatus == ProductHolderBase::Ambiguous) {
       throwAmbiguousException("findProductByLabel", typeID, label, instance, process);
     }
     return productData;
   }

ProductData const * edm::Principal::findProductByTag	(	TypeID const &	typeID,
		InputTag const &	tag,
		ModuleCallingContext const *	mcc
	)		const

Definition at line 705 of file Principal.cc.

References findProductByLabel(), and edm::PRODUCT_TYPE.

Referenced by edm::getProductByTag().

                                                                                                               {
     ProductData const* productData =
       findProductByLabel(PRODUCT_TYPE,
                          typeID,
                          tag,
                          nullptr,
                          mcc);
     return productData;
   }

void edm::Principal::findProducts	(	std::vector< ProductHolderBase const * > const &	holders,
		TypeID const &	typeID,
		BasicHandleVec &	results,
		ModuleCallingContext const *	mcc
	)		const

private

Definition at line 582 of file Principal.cc.

References edm::BranchDescription::isAlias(), LaserDQM_cfg::process, processHistoryPtr_, edm::BranchDescription::processName(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by getManyByType().

                                                                  {
 
     for (auto iter = processHistoryPtr_->rbegin(),
               iEnd = processHistoryPtr_->rend();
          iter != iEnd; ++iter) {
       std::string const& process = iter->processName();
       for (auto productHolder : holders) {
         BranchDescription const& bd = productHolder->branchDescription();
         if (process == bd.processName()) {
 
           // Ignore aliases to avoid matching the same product multiple times.
           if(bd.isAlias()) {
             continue;
           }
 
           ProductHolderBase::ResolveStatus resolveStatus;
           ProductData const* productData = productHolder->resolveProduct(resolveStatus, false, mcc);
           if(productData) {
             // Skip product if not available.
             results.emplace_back(*productData);
           }
         }
       }
     }
   }

void edm::Principal::getAllProvenance ( std::vector< Provenance const * > & provenances ) const

Definition at line 759 of file Principal.cc.

Referenced by edm::Run::getAllProvenance(), edm::LuminosityBlock::getAllProvenance(), edm::Event::getAllProvenance(), and edm::AsciiOutputModule::write().

                                                                              {
     provenances.clear();
     for(auto const& productHolder : *this) {
       if(productHolder->singleProduct() && productHolder->provenanceAvailable() && !productHolder->branchDescription().isAlias()) {
         // We do not attempt to get the event/lumi/run status from the provenance,
         // because the per event provenance may have been dropped.
         if(productHolder->provenance()->product().present()) {
            provenances.push_back(productHolder->provenance());
         }
       }
     }
   }

BasicHandle edm::Principal::getByLabel	(	KindOfType	kindOfType,
		TypeID const &	typeID,
		InputTag const &	inputTag,
		EDConsumerBase const *	consumes,
		ModuleCallingContext const *	mcc
	)		const

Definition at line 445 of file Principal.cc.

References findProductByLabel(), edm::InputTag::instance(), edm::InputTag::label(), edm::makeHandleExceptionFactory(), edm::makeNotFoundException(), edm::InputTag::process(), and query::result.

Referenced by edm::check(), edm::detail::NamedEventSelector::fill(), PileUpEventPrincipal::getByLabel(), and FRDEventOutputModule< Consumer >::write().

                                                                {
 
     ProductData const* result = findProductByLabel(kindOfType, typeID, inputTag, consumer, mcc);
     if(result == 0) {
       return BasicHandle(makeHandleExceptionFactory([=]()->std::shared_ptr<cms::Exception> {
         return makeNotFoundException("getByLabel", kindOfType, typeID, inputTag.label(), inputTag.instance(), inputTag.process());
       }));
     }
     return BasicHandle(*result);
   }

BasicHandle edm::Principal::getByLabel	(	KindOfType	kindOfType,
		TypeID const &	typeID,
		std::string const &	label,
		std::string const &	instance,
		std::string const &	process,
		EDConsumerBase const *	consumes,
		ModuleCallingContext const *	mcc
	)		const

Definition at line 461 of file Principal.cc.

References findProductByLabel(), edm::makeHandleExceptionFactory(), edm::makeNotFoundException(), and query::result.

                                                                {
 
     ProductData const* result = findProductByLabel(kindOfType, typeID, label, instance, process,consumer, mcc);
     if(result == 0) {
       return BasicHandle(makeHandleExceptionFactory([=]()->std::shared_ptr<cms::Exception> {
         return makeNotFoundException("getByLabel", kindOfType, typeID, label, instance, process);
       }));
     }
     return BasicHandle(*result);
   }

BasicHandle edm::Principal::getByToken	(	KindOfType	kindOfType,
		TypeID const &	typeID,
		ProductHolderIndex	index,
		bool	skipCurrentProcess,
		bool &	ambiguous,
		ModuleCallingContext const *	mcc
	)		const

Definition at line 479 of file Principal.cc.

References edm::ProductHolderBase::Ambiguous, getHLTprescales::index, edm::ProductHolderIndexInvalid, and productHolders_.

                                                                {
     assert(index !=ProductHolderIndexInvalid);
     boost::shared_ptr<ProductHolderBase> const& productHolder = productHolders_[index];
     assert(0!=productHolder.get());
     ProductHolderBase::ResolveStatus resolveStatus;
     ProductData const* productData = productHolder->resolveProduct(resolveStatus, skipCurrentProcess, mcc);
     if(resolveStatus == ProductHolderBase::Ambiguous) {
       ambiguous = true;
       return BasicHandle();
     }
     if(productData == 0) {
       return BasicHandle();
     }
     return BasicHandle(*productData);    
   }

ProductHolderBase * edm::Principal::getExistingProduct ( BranchID const & branchID )

protected

Definition at line 383 of file Principal.cc.

References getHLTprescales::index, preg_, edm::ProductHolderIndexInvalid, and productHolders_.

Referenced by addProductOrThrow(), adjustToNewProductRegistry(), deleteProduct(), getExistingProduct(), edm::RunPrincipal::put(), edm::LuminosityBlockPrincipal::put(), edm::EventPrincipal::put(), and edm::EventPrincipal::putOnRead().

                                                         {
     ProductHolderIndex index = preg_->indexFrom(branchID);
     assert(index != ProductHolderIndexInvalid);
     SharedProductPtr ptr = productHolders_.at(index);
     return ptr.get();
   }

ProductHolderBase * edm::Principal::getExistingProduct ( ProductHolderBase const & phb )

protected

Definition at line 391 of file Principal.cc.

References edm::ProductHolderBase::branchDescription(), edm::BranchDescription::branchID(), and getExistingProduct().

                                                                       {
     ProductHolderBase* phb = getExistingProduct(productHolder.branchDescription().branchID());
     assert(nullptr == phb || BranchKey(productHolder.branchDescription()) == BranchKey(phb->branchDescription()));
     return phb;
   }

OutputHandle edm::Principal::getForOutput	(	BranchID const &	bid,
		bool	getProd,
		ModuleCallingContext const *	mcc
	)		const

Definition at line 716 of file Principal.cc.

References getProductHolder(), edm::errors::LogicError, ntuplemaker::status, edm::throwProductDeletedException(), and edm::throwProductNotFoundException().

Referenced by edm::check(), edm::RootOutputFile::fillBranches(), edm::StreamSerializer::serializeEvent(), and edm::ProvenanceCheckerOutputModule::write().

                                                                  {
     ConstProductHolderPtr const phb = getProductHolder(bid);
     if(phb == nullptr) {
       throwProductNotFoundException("getForOutput", errors::LogicError, bid);
     }
     if (phb->productWasDeleted()) {
       throwProductDeletedException("getForOutput",phb->productType(),
                                    phb->moduleLabel(),
                                    phb->productInstanceName(),
                                    phb->processName());
     }
     if(getProd) {
       ProductHolderBase::ResolveStatus status;
       phb->resolveProduct(status,false,mcc);
     }
     if(!phb->provenance() || (!phb->product() && !phb->productProvenancePtr())) {
       return OutputHandle();
     }
     return OutputHandle(WrapperHolder(phb->product().get(), phb->productData().getInterface()), &phb->branchDescription(), phb->productProvenancePtr());
   }

WrapperHolder edm::Principal::getIt ( ProductID const & ) const

privatevirtual

Implements edm::EDProductGetter.

Reimplemented in edm::EventPrincipal.

Definition at line 786 of file Principal.cc.

                                          {
     assert(nullptr);
     return WrapperHolder();
   }

void edm::Principal::getManyByType	(	TypeID const &	typeID,
		BasicHandleVec &	results,
		EDConsumerBase const *	consumes,
		ModuleCallingContext const *	mcc
	)		const

Definition at line 511 of file Principal.cc.

References branchType(), findProducts(), i, getHLTprescales::index, edm::ProductHolderIndexHelper::Matches::index(), edm::ProductHolderIndexHelper::Matches::isFullyResolved(), edm::maybeThrowMissingDictionaryException(), edm::ProductHolderIndexHelper::Matches::numberOfMatches(), preg_, edm::PRODUCT_TYPE, productHolders_, productLookup(), edm::EDConsumerBase::registeredToConsumeMany(), edm::ProductHolderIndexHelper::relatedIndexes(), and unlikely.

                                                                   {
 
     assert(results.empty());
 
     if(unlikely(consumer and (not consumer->registeredToConsumeMany(typeID,branchType())))) {
       failedToRegisterConsumesMany(typeID);
     }
 
     // This finds the indexes to all the ProductHolder's matching the type
     ProductHolderIndexHelper::Matches matches =
       productLookup().relatedIndexes(PRODUCT_TYPE, typeID);
 
     if (matches.numberOfMatches() == 0) {
       maybeThrowMissingDictionaryException(typeID, false, preg_->missingDictionaries());
       return;
     }
 
     results.reserve(matches.numberOfMatches());
 
     // Loop over the ProductHolders. Add the products that are actually
     // present into the results. This will also trigger delayed reading,
     // on demand production, and check for deleted products as appropriate.
 
     // Over the years the code that uses getManyByType has grown to depend
     // on the ordering of the results. The order originally was just an
     // accident of how previous versions of the code were written, but
     // here we have to go through some extra effort to preserve that ordering.
 
     // We build a list of holders that match a particular label and instance.
     // When that list is complete we call findProducts, which loops over
     // that list in reverse order of the ProcessHistory (starts with the
     // most recent).  Then we clear the list and repeat this until all the
     // matching label and instance subsets have been dealt with.
 
     // Note that the function isFullyResolved returns true for the ProductHolders
     // that are associated with an empty process name. Those are the ones that
     // know how to search for the most recent process name matching
     // a label and instance. We do not need these for getManyByType and
     // skip them. In addition to skipping them, we make use of the fact
     // that they mark the beginning of each subset of holders with the same
     // label and instance. They tell us when to call findProducts. 
 
     std::vector<ProductHolderBase const*> holders;
 
     for(unsigned int i = 0; i < matches.numberOfMatches(); ++i) {
 
       ProductHolderIndex index = matches.index(i);
 
       if(!matches.isFullyResolved(i)) {
         if(!holders.empty()) {
           // Process the ones with a particular module label and instance
           findProducts(holders, typeID, results, mcc);
           holders.clear();
         }
       } else {
         ProductHolderBase const* productHolder = productHolders_.at(index).get();
         assert(productHolder);
         holders.push_back(productHolder);
       }
     }
     // Do not miss the last subset of products
     if(!holders.empty()) {
       findProducts(holders, typeID, results, mcc);
     }
     return;
   }

Principal::ConstProductHolderPtr edm::Principal::getProductHolder ( BranchID const & oid ) const

Definition at line 429 of file Principal.cc.

References getProductHolderByIndex(), getHLTprescales::index, preg_, and edm::ProductHolderIndexInvalid.

Referenced by edm::EventPrincipal::getByProductID(), getForOutput(), getProvenance(), and edm::SubProcess::propagateProducts().

                                                        {
     ProductHolderIndex index = preg_->indexFrom(bid);
     if(index == ProductHolderIndexInvalid){
        return ConstProductHolderPtr();
     }
     return getProductHolderByIndex(index);
   }

Principal::ConstProductHolderPtr edm::Principal::getProductHolderByIndex ( ProductHolderIndex const & oid ) const

Definition at line 438 of file Principal.cc.

References getHLTprescales::index, and productHolders_.

Referenced by getProductHolder(), and edm::NoProcessProductHolder::resolveProduct_().

                                                                           {
 
     ConstProductHolderPtr const phb = productHolders_[index].get();
     return phb;
   }

Provenance edm::Principal::getProvenance	(	BranchID const &	bid,
		ModuleCallingContext const *	mcc
	)		const

Definition at line 739 of file Principal.cc.

References getProductHolder(), edm::errors::ProductNotFound, ntuplemaker::status, and edm::throwProductNotFoundException().

Referenced by edm::Run::getProvenance(), edm::LuminosityBlock::getProvenance(), and edm::Event::getProvenance().

                                                                   {
     ConstProductHolderPtr const phb = getProductHolder(bid);
     if(phb == nullptr) {
       throwProductNotFoundException("getProvenance", errors::ProductNotFound, bid);
     }
 
     if(phb->onDemand()) {
       ProductHolderBase::ResolveStatus status;
       if(not phb->resolveProduct(status,false,mcc) ) {
         throwProductNotFoundException("getProvenance(onDemand)", errors::ProductNotFound, bid);
       }
     }
     return *phb->provenance();
   }

bool edm::Principal::isComplete ( ) const

inline

Definition at line 195 of file Principal.h.

References isComplete_().

195 {return isComplete_();}

edm::Principal::isComplete_

virtual bool isComplete_() const

Definition: Principal.h:238

virtual bool edm::Principal::isComplete_ ( ) const

inlineprivatevirtual

Reimplemented in edm::LuminosityBlockPrincipal, and edm::RunPrincipal.

Definition at line 238 of file Principal.h.

Referenced by isComplete().

238 {return true;}

std::vector<unsigned int> const& edm::Principal::lookupProcessOrder ( ) const

inline

Definition at line 191 of file Principal.h.

References lookupProcessOrder_.

Referenced by edm::NoProcessProductHolder::resolveProduct_().

191 { return lookupProcessOrder_; }

edm::Principal::lookupProcessOrder_

std::vector< unsigned int > lookupProcessOrder_

Definition: Principal.h:254

void edm::Principal::prefetch	(	ProductHolderIndex	index,
		bool	skipCurrentProcess,
		ModuleCallingContext const *	mcc
	)		const

Definition at line 501 of file Principal.cc.

References productHolders_.

                                                              {
     boost::shared_ptr<ProductHolderBase> const& productHolder = productHolders_.at(index);
     assert(0!=productHolder.get());
     ProductHolderBase::ResolveStatus resolveStatus;
     productHolder->resolveProduct(resolveStatus, skipCurrentProcess, mcc);
   }

ProcessConfiguration const& edm::Principal::processConfiguration ( ) const

inline

Definition at line 147 of file Principal.h.

References processConfiguration_.

147 {return *processConfiguration_;}

edm::Principal::processConfiguration_

ProcessConfiguration const * processConfiguration_

Definition: Principal.h:244

ProcessHistory const& edm::Principal::processHistory ( ) const

inline

Definition at line 139 of file Principal.h.

References processHistoryPtr_.

Referenced by edm::SubProcess::beginLuminosityBlock(), edm::SubProcess::beginRun(), edm::EventPrincipal::fillEventPrincipal(), edm::LuminosityBlockPrincipal::fillLuminosityBlockPrincipal(), edm::RunPrincipal::fillRunPrincipal(), edm::SubProcess::process(), edm::StreamSerializer::serializeEvent(), edm::AsciiOutputModule::write(), edm::RootOutputFile::writeLuminosityBlock(), DQMRootOutputModule::writeLuminosityBlock(), edm::RootOutputFile::writeOne(), edm::RootOutputFile::writeRun(), and DQMRootOutputModule::writeRun().

                                                  {
       return *processHistoryPtr_;
     }

ProcessHistoryID const& edm::Principal::processHistoryID ( ) const

inline

Definition at line 143 of file Principal.h.

References processHistoryID_.

Referenced by edm::SubProcess::beginLuminosityBlock(), edm::SubProcess::beginRun(), edm::EventPrincipal::fillEventPrincipal(), edm::SubProcess::process(), edm::Event::processHistoryID(), edm::LuminosityBlock::processHistoryID(), edm::Run::processHistoryID(), edm::RootOutputFile::writeLuminosityBlock(), DQMRootOutputModule::writeLuminosityBlock(), edm::RootOutputFile::writeOne(), edm::RootOutputFile::writeRun(), and DQMRootOutputModule::writeRun().

                                                      {
       return processHistoryID_;
     }

EDProductGetter const* edm::Principal::prodGetter ( ) const

inline

Definition at line 95 of file Principal.h.

95 {return this;}

ProductHolderIndexHelper const& edm::Principal::productLookup ( ) const

inline

Definition at line 151 of file Principal.h.

References productLookup_.

Referenced by findProductByLabel(), and getManyByType().

151 {return *productLookup_;}

edm::Principal::productLookup_

boost::shared_ptr< ProductHolderIndexHelper const > productLookup_

Definition: Principal.h:252

ProductRegistry const& edm::Principal::productRegistry ( ) const

inline

Definition at line 149 of file Principal.h.

References preg_.

Referenced by fillPrincipal(), findProductByLabel(), edm::SubProcess::process(), and edm::ProvenanceCheckerOutputModule::write().

149 {return *preg_;}

edm::Principal::preg_

boost::shared_ptr< ProductRegistry const > preg_

Definition: Principal.h:251

void edm::Principal::putOrMerge	(	WrapperOwningHolder const &	prod,
		ProductHolderBase const *	productHolder
	)		const

protected

Definition at line 807 of file Principal.cc.

References edm::ProductHolderBase::checkType(), checkUniquenessAndType(), edm::ProductHolderBase::mergeProduct(), edm::ProductHolderBase::putOrMergeProduct(), and edm::ProductHolderBase::putProduct().

Referenced by edm::RunPrincipal::put(), edm::LuminosityBlockPrincipal::put(), edm::RunPrincipal::resolveProductImmediate(), and edm::LuminosityBlockPrincipal::resolveProductImmediate().

                                                                                            {
     bool willBePut = phb->putOrMergeProduct();
     if(willBePut) {
       checkUniquenessAndType(prod, phb);
       phb->putProduct(prod);
     } else {
       phb->checkType(prod);
       phb->mergeProduct(prod);
     }
   }

void edm::Principal::putOrMerge	(	WrapperOwningHolder const &	prod,
		ProductProvenance &	prov,
		ProductHolderBase *	productHolder
	)

protected

Definition at line 819 of file Principal.cc.

References edm::ProductHolderBase::checkType(), checkUniquenessAndType(), edm::ProductHolderBase::mergeProduct(), edm::ProductHolderBase::putOrMergeProduct(), and edm::ProductHolderBase::putProduct().

                                                                                                         {
     bool willBePut = phb->putOrMergeProduct();
     if(willBePut) {
       checkUniquenessAndType(prod, phb);
       phb->putProduct(prod, prov);
     } else {
       phb->checkType(prod);
       phb->mergeProduct(prod, prov);
     }
   }

DelayedReader* edm::Principal::reader ( ) const

inline

Definition at line 173 of file Principal.h.

References reader_.

Referenced by edm::SubProcess::beginLuminosityBlock(), edm::SubProcess::beginRun(), edm::EventPrincipal::fillEventPrincipal(), edm::LuminosityBlockPrincipal::fillLuminosityBlockPrincipal(), fillPrincipal(), edm::RunPrincipal::fillRunPrincipal(), edm::SubProcess::process(), edm::EventPrincipal::readFromSource_(), recombine(), edm::RunPrincipal::resolveProductImmediate(), and edm::LuminosityBlockPrincipal::resolveProductImmediate().

173 {return reader_;}

edm::Principal::reader_

DelayedReader * reader_

Definition: Principal.h:259

void edm::Principal::readFromSource	(	ProductHolderBase const &	phb,
		ModuleCallingContext const *	mcc
	)		const

inline

Definition at line 184 of file Principal.h.

References readFromSource_().

Referenced by edm::InputProductHolder::resolveProduct_().

                                                                                              {
       readFromSource_(phb, mcc);
     }

virtual void edm::Principal::readFromSource_	(	ProductHolderBase const &	phb,
		ModuleCallingContext const *	mcc
	)		const

inlineprivatevirtual

Reimplemented in edm::EventPrincipal.

Definition at line 236 of file Principal.h.

Referenced by readFromSource().

236 {}

void edm::Principal::recombine	(	Principal &	other,
		std::vector< BranchID > const &	bids
	)

Definition at line 773 of file Principal.cc.

References getHLTprescales::index, edm::DelayedReader::mergeReaders(), preg_, parseEventContent::prod, edm::ProductHolderIndexInvalid, productHolders_, reader(), and reader_.

Referenced by edm::PoolSource::readEvent_(), edm::PoolSource::readLuminosityBlock_(), and edm::PoolSource::readRun_().

                                                                         {
     for(auto const& prod : bids) {
       ProductHolderIndex index= preg_->indexFrom(prod);
       assert(index!=ProductHolderIndexInvalid);
       ProductHolderIndex indexO = other.preg_->indexFrom(prod);
       assert(indexO!=ProductHolderIndexInvalid);
       productHolders_[index].swap(other.productHolders_[indexO]);
       productHolders_[index]->setPrincipal(this);
     }
     reader_->mergeReaders(other.reader());
   }

size_t edm::Principal::size ( void ) const

Definition at line 238 of file Principal.cc.

References parseEventContent::prod.

Referenced by edm::SecSourceAnalyzer::getBranches(), edm::StreamerInputSource::read(), and edm::Event::size().

                         {
     size_t size = 0U;
     for(auto const& prod : *this) {
       if(prod->singleProduct() && // Not a NoProcessProductHolder
          !prod->productUnavailable() &&
          !prod->onDemand() &&
          !prod->branchDescription().dropped()) {
         ++size;
       }
     }
     return size;
   }