#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 < std::shared_ptr < ProductHolderBase > >	ProductHolderCollection

typedef std::shared_ptr < ProductHolderBase >	SharedProductPtr

typedef ProductHolderCollection::size_type	size_type

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

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

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

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

void	addUnscheduledProduct (std::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, SharedResourcesAcquirer sra, 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, SharedResourcesAcquirer sra, ModuleCallingContext const *mcc) const

BasicHandle	getByToken (KindOfType kindOfType, TypeID const &typeID, ProductHolderIndex index, bool skipCurrentProcess, bool &ambiguous, SharedResourcesAcquirer sra, 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, SharedResourcesAcquirer sra, 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 (std::shared_ptr< ProductRegistry const > reg, std::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, SharedResourcesAcquirer sra, ModuleCallingContext const mcc) const =0

virtual	~Principal ()

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

	EDProductGetter (EDProductGetter const &)=delete

EDProductGetter const &	operator= (EDProductGetter const &)=delete

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 (WrapperBase const prod, ProductHolderBase const productHolder) const

ProductHolderBase *	getExistingProduct (BranchID const &branchID)

ProductHolderBase *	getExistingProduct (ProductHolderBase const &phb)

void	putOrMerge (std::unique_ptr< WrapperBase > prod, ProductHolderBase const *productHolder) const

void	putOrMerge (std::unique_ptr< WrapperBase > prod, ProductProvenance &prov, ProductHolderBase *productHolder)

Private Member Functions
ProductData const *	findProductByLabel (KindOfType kindOfType, TypeID const &typeID, InputTag const &inputTag, EDConsumerBase const consumer, SharedResourcesAcquirer sra, 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, SharedResourcesAcquirer sra, ModuleCallingContext const *mcc) const

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

virtual WrapperBase const *	getIt (ProductID const &) const override

virtual WrapperBase const *	getThinnedProduct (ProductID const &, unsigned int &) const override

virtual void	getThinnedProducts (ProductID const &, std::vector< WrapperBase const * > &, std::vector< unsigned int > &) const override

virtual bool	isComplete_ () const

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

Private Attributes
BranchType	branchType_

CacheIdentifier_t	cacheIdentifier_

HistoryAppender *	historyAppender_

std::vector< unsigned int >	lookupProcessOrder_

ProcessHistoryID	orderProcessHistoryID_

std::shared_ptr < ProductRegistry const >	preg_

ProcessConfiguration const *	processConfiguration_

ProcessHistoryID	processHistoryID_

std::shared_ptr < ProcessHistory const >	processHistoryPtr_

ProductHolderCollection	productHolders_

std::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 54 of file Principal.h.

Member Typedef Documentation

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

Definition at line 60 of file Principal.h.

typedef unsigned long edm::Principal::CacheIdentifier_t

Definition at line 173 of file Principal.h.

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

Definition at line 57 of file Principal.h.

typedef ProductHolderBase const* edm::Principal::ConstProductHolderPtr

Definition at line 59 of file Principal.h.

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

Definition at line 64 of file Principal.h.

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

Definition at line 58 of file Principal.h.

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

Definition at line 56 of file Principal.h.

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

Definition at line 63 of file Principal.h.

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

Definition at line 61 of file Principal.h.

Constructor & Destructor Documentation

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

Definition at line 140 of file Principal.cc.

References addAliasedProduct(), addInputProduct(), addScheduledProduct(), addSourceProduct(), addUnscheduledProduct(), assert(), edm::ProductHolderIndexHelper::Range::begin(), edm::BranchDescription::branchType(), branchType_, edm::ProductHolderIndexHelper::Range::end(), spr::find(), i, edm::ProductHolderIndexHelper::IndexAndNames::index(), edm::InEvent, edm::BranchDescription::isAlias(), relval_steps::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 {
           auto cbd = std::make_shared<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_) {
           auto cbd = std::make_shared<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) {
               std::shared_ptr<ProductHolderBase> newHolder = std::make_shared<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;
             }
           }
         }
       }
       std::shared_ptr<ProductHolderBase> newHolder = std::make_shared<NoProcessProductHolder>(matchingHolders, ambiguous, this);
       productHolders_.at(productHolderIndex) = newHolder;
     }
   }

edm::Principal::~Principal ( )

virtual

Definition at line 246 of file Principal.cc.

246 {

247 }

Member Function Documentation

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

Definition at line 309 of file Principal.cc.

References addProductOrThrow(), assert(), cmsHarvester::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 ( std::shared_ptr< BranchDescription const > bd )

Definition at line 297 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 423 of file Principal.cc.

References assert(), edm::BranchDescription::branchID(), edm::BranchDescription::className(), edm::BranchDescription::friendlyClassName(), cmsHarvester::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.release());
 
     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 437 of file Principal.cc.

References addProduct_(), 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 ( std::shared_ptr< BranchDescription const > bd )

Definition at line 285 of file Principal.cc.

References addProductOrThrow().

Referenced by Principal().

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

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

Definition at line 291 of file Principal.cc.

References addProductOrThrow().

Referenced by Principal().

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

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

Definition at line 303 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 876 of file Principal.cc.

References addInputProduct(), assert(), edm::BranchDescription::branchID(), edm::BranchDescription::branchType(), branchType_, cmsHarvester::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());
             auto cbd = std::make_shared<BranchDescription const>(bd);
             addInputProduct(cbd);
           }
         }
       }
     }
     assert(preg_->getNextIndexValue(branchType_) == productHolders_.size());
   }

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

Definition at line 268 of file Principal.cc.

References 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_)) {
         auto cbd = std::make_shared<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 162 of file Principal.h.

References productHolders_.

Referenced by edm::check(), edm::PoolOutputModule::updateBranchParents(), and edm::ProvenanceCheckerOutputModule::write().

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

edm::Principal::productHolders_

ProductHolderCollection productHolders_

Definition: Principal.h:259

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

inline

Definition at line 170 of file Principal.h.

References branchType_.

Referenced by edm::PrincipalGetAdapter::branchType(), findProductByLabel(), and getManyByType().

170 {return branchType_;}

edm::Principal::branchType_

BranchType branchType_

Definition: Principal.h:276

CacheIdentifier_t edm::Principal::cacheIdentifier ( ) const

inline

Definition at line 174 of file Principal.h.

References cacheIdentifier_.

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

174 {return cacheIdentifier_;}

edm::Principal::cacheIdentifier_

CacheIdentifier_t cacheIdentifier_

Definition: Principal.h:283

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

protected

Definition at line 838 of file Principal.cc.

References edm::ProductHolderBase::branchDescription(), edm::BranchDescription::branchName(), edm::ProductHolderBase::checkType(), productPtrs_, and edm::throwCorruptionException().

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

                                                                                                {
     if(prod == nullptr) 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).second;
     if(alreadyPresent) {
       phb->checkType(*prod);
       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 319 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 330 of file Principal.cc.

References assert(), 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());
     if(itFound != productPtrs_.end()) {
       productPtrs_.erase(itFound);
     } 
     phb->deleteProduct();
   }

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

inline

Definition at line 163 of file Principal.h.

References productHolders_.

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

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

edm::Principal::productHolders_

ProductHolderCollection productHolders_

Definition: Principal.h:259

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

Definition at line 342 of file Principal.cc.

References edm::HistoryAppender::appendToProcessHistory(), cacheIdentifier_, Exception, spr::find(), edm::ProcessHistoryRegistry::getMapped(), estimatePileup::hist, historyAppender_, edm::Hash< I >::isValid(), relval_steps::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 {
       std::shared_ptr<ProcessHistory const> inputProcessHistory;
       if (hist.isValid()) {
         //does not own the pointer
         auto noDel =[](void const*){};
         inputProcessHistory =
         std::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 = std::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,
		SharedResourcesAcquirer *	sra,
		ModuleCallingContext const *	mcc
	)		const

private

Definition at line 642 of file Principal.cc.

References edm::ProductHolderBase::Ambiguous, branchType(), edm::ELEMENT_TYPE, edm::ProductHolderIndexHelper::index(), cmsHarvester::index, edm::InputTag::indexFor(), edm::InputTag::instance(), edm::InputTag::label(), matches, edm::maybeThrowMissingDictionaryException(), edm::ProductHolderIndexHelper::Matches::numberOfMatches(), preg_, edm::InputTag::process(), FSQHLTOfflineSource_cfi::processName, 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());
     }
 
     
     std::shared_ptr<ProductHolderBase> const& productHolder = productHolders_[index];
 
     ProductHolderBase::ResolveStatus resolveStatus;
     ProductData const* productData = productHolder->resolveProduct(resolveStatus, skipCurrentProcess, sra, 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,
		SharedResourcesAcquirer *	sra,
		ModuleCallingContext const *	mcc
	)		const

private

Definition at line 695 of file Principal.cc.

References edm::ProductHolderBase::Ambiguous, branchType(), edm::ELEMENT_TYPE, edm::ProductHolderIndexHelper::index(), cmsHarvester::index, matches, 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);
     }
     
     std::shared_ptr<ProductHolderBase> const& productHolder = productHolders_[index];
 
     ProductHolderBase::ResolveStatus resolveStatus;
     ProductData const* productData = productHolder->resolveProduct(resolveStatus, false, sra, 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 737 of file Principal.cc.

References findProductByLabel(), and edm::PRODUCT_TYPE.

Referenced by edm::getProductByTag().

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

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

private

Definition at line 611 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, sra, 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 792 of file Principal.cc.

Referenced by edm::LuminosityBlock::getAllProvenance(), edm::Run::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,
		SharedResourcesAcquirer *	sra,
		ModuleCallingContext const *	mcc
	)		const

Definition at line 470 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(), PileUpEventPrincipal::getByLabel(), edm::PrincipalGetAdapter::getByLabel_(), edm::PrincipalGetAdapter::getMatchingSequenceByLabel_(), and edm::detail::TriggerResultsBasedEventSelector::wantEvent().

                                                                {
 
     ProductData const* result = findProductByLabel(kindOfType, typeID, inputTag, consumer, sra, 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,
		SharedResourcesAcquirer *	sra,
		ModuleCallingContext const *	mcc
	)		const

Definition at line 487 of file Principal.cc.

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

                                                                {
 
     ProductData const* result = findProductByLabel(kindOfType, typeID, label, instance, process,consumer, sra, 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,
		SharedResourcesAcquirer *	sra,
		ModuleCallingContext const *	mcc
	)		const

Definition at line 506 of file Principal.cc.

References edm::ProductHolderBase::Ambiguous, assert(), cmsHarvester::index, edm::ProductHolderIndexInvalid, and productHolders_.

Referenced by edm::PrincipalGetAdapter::getByToken_().

                                                                {
     assert(index !=ProductHolderIndexInvalid);
     std::shared_ptr<ProductHolderBase> const& productHolder = productHolders_[index];
     assert(0!=productHolder.get());
     ProductHolderBase::ResolveStatus resolveStatus;
     ProductData const* productData = productHolder->resolveProduct(resolveStatus, skipCurrentProcess, sra, 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 398 of file Principal.cc.

References assert(), cmsHarvester::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 406 of file Principal.cc.

References assert(), edm::ProductHolderBase::branchDescription(), edm::BranchDescription::branchID(), edm::BranchDescription::branchName(), Exception, dqmPostProcessing_online::existing, and getExistingProduct().

                                                                       {
     ProductHolderBase* phb = getExistingProduct(productHolder.branchDescription().branchID());
     if(nullptr != phb && BranchKey(productHolder.branchDescription()) != BranchKey(phb->branchDescription())) {
       BranchDescription const& newProduct = phb->branchDescription();
       BranchDescription const& existing = productHolder.branchDescription();
       if(newProduct.branchName() != existing.branchName() && newProduct.branchID() == existing.branchID()) {
         throw cms::Exception("HashCollision") << "Principal::getExistingProduct\n" <<
           " Branch " << newProduct.branchName() << " has same branch ID as branch " << existing.branchName() << "\n" <<
           "Workaround: change process name or product instance name of " << newProduct.branchName() << "\n";
       } else {
         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 749 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,nullptr, mcc);
     }
     if(!phb->provenance() || (!phb->product() && !phb->productProvenancePtr())) {
       return OutputHandle();
     }
     return OutputHandle(phb->product(), &phb->branchDescription(), phb->productProvenancePtr());
   }

WrapperBase const * edm::Principal::getIt ( ProductID const & ) const

overrideprivatevirtual

Implements edm::EDProductGetter.

Reimplemented in edm::EventPrincipal.

Definition at line 819 of file Principal.cc.

References assert().

                                          {
     assert(nullptr);
     return nullptr;
   }

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

Definition at line 539 of file Principal.cc.

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

Referenced by edm::PrincipalGetAdapter::getManyByType_().

                                                                   {
 
     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, sra, 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, sra, mcc);
     }
     return;
   }

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

Definition at line 454 of file Principal.cc.

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

Referenced by edm::EventPrincipal::getByProductID(), getForOutput(), getProvenance(), edm::EventPrincipal::getThinnedAssociation(), 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 463 of file Principal.cc.

References cmsHarvester::index, and productHolders_.

Referenced by edm::PrincipalGetAdapter::getBranchDescription(), 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 772 of file Principal.cc.

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

Referenced by edm::LuminosityBlock::getProvenance(), edm::Run::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, nullptr, mcc) ) {
         throwProductNotFoundException("getProvenance(onDemand)", errors::ProductNotFound, bid);
       }
     }
     return *phb->provenance();
   }

WrapperBase const * edm::Principal::getThinnedProduct	(	ProductID const &	,
		unsigned int &
	)		const

overrideprivatevirtual

Implements edm::EDProductGetter.

Reimplemented in edm::EventPrincipal.

Definition at line 825 of file Principal.cc.

References assert().

                                                                     {
     assert(nullptr);
     return nullptr;
   }

void edm::Principal::getThinnedProducts	(	ProductID const &	,
		std::vector< WrapperBase const * > &	,
		std::vector< unsigned int > &
	)		const

overrideprivatevirtual

Implements edm::EDProductGetter.

Reimplemented in edm::EventPrincipal.

Definition at line 831 of file Principal.cc.

References assert().

                                                                   {
     assert(nullptr);
   }

bool edm::Principal::isComplete ( ) const

inline

Definition at line 199 of file Principal.h.

References isComplete_().

Referenced by edm::PrincipalGetAdapter::isComplete().

199 {return isComplete_();}

edm::Principal::isComplete_

virtual bool isComplete_() const

Definition: Principal.h:250

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

inlineprivatevirtual

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

Definition at line 250 of file Principal.h.

Referenced by isComplete().

250 {return true;}

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

inline

Definition at line 195 of file Principal.h.

References lookupProcessOrder_.

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

195 { return lookupProcessOrder_; }

edm::Principal::lookupProcessOrder_

std::vector< unsigned int > lookupProcessOrder_

Definition: Principal.h:266

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

Definition at line 529 of file Principal.cc.

References assert(), and productHolders_.

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

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

inline

Definition at line 150 of file Principal.h.

References processConfiguration_.

150 {return *processConfiguration_;}

edm::Principal::processConfiguration_

ProcessConfiguration const * processConfiguration_

Definition: Principal.h:256

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

inline

Definition at line 142 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::PrincipalGetAdapter::processHistory(), 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 146 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 94 of file Principal.h.

Referenced by edm::PrincipalGetAdapter::prodGetter().

94 {return this;}

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

inline

Definition at line 154 of file Principal.h.

References productLookup_.

Referenced by findProductByLabel(), edm::PrincipalGetAdapter::getBranchDescription(), and getManyByType().

154 {return *productLookup_;}

edm::Principal::productLookup_

std::shared_ptr< ProductHolderIndexHelper const > productLookup_

Definition: Principal.h:264

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

inline

Definition at line 152 of file Principal.h.

References preg_.

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

152 {return *preg_;}

edm::Principal::preg_

std::shared_ptr< ProductRegistry const > preg_

Definition: Principal.h:263

void edm::Principal::putOrMerge	(	std::unique_ptr< WrapperBase >	prod,
		ProductHolderBase const *	productHolder
	)		const

protected

Definition at line 852 of file Principal.cc.

References edm::ProductHolderBase::checkType(), checkUniquenessAndType(), edm::ProductHolderBase::mergeProduct(), eostools::move(), 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.get(), phb);
       phb->putProduct(std::move(prod));
     } else {
       phb->checkType(*prod);
       phb->mergeProduct(std::move(prod));
     }
   }

void edm::Principal::putOrMerge	(	std::unique_ptr< WrapperBase >	prod,
		ProductProvenance &	prov,
		ProductHolderBase *	productHolder
	)

protected

Definition at line 864 of file Principal.cc.

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

                                                                                                         {
     bool willBePut = phb->putOrMergeProduct();
     if(willBePut) {
       checkUniquenessAndType(prod.get(), phb);
       phb->putProduct(std::move(prod), prov);
     } else {
       phb->checkType(*prod);
       phb->mergeProduct(std::move(prod), prov);
     }
   }

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

inline

Definition at line 176 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().

176 {return reader_;}

edm::Principal::reader_

DelayedReader * reader_

Definition: Principal.h:271

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

inline

Definition at line 187 of file Principal.h.

References readFromSource_().

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

                                                                                              {
       readFromSource_(phb, mcc);
     }

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

inlineprivatevirtual

Reimplemented in edm::EventPrincipal.

Definition at line 248 of file Principal.h.

Referenced by readFromSource().

248 {}

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

Definition at line 806 of file Principal.cc.

References assert(), cmsHarvester::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 253 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;
   }