#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, ProductResolverCollection::const_iterator >	const_iterator

typedef ProductResolverBase const *	ConstProductResolverPtr

typedef boost::filter_iterator< FilledProductPtr, ProductResolverCollection::iterator >	iterator

typedef std::string	ProcessName

typedef ProcessHistory::const_iterator	ProcessNameConstIterator

typedef std::vector< propagate_const< std::shared_ptr< ProductResolverBase > > >	ProductResolverCollection

typedef std::shared_ptr< ProductResolverBase >	SharedProductPtr

typedef ProductResolverCollection::size_type	size_type

Public Member Functions
void	adjustIndexesAfterProductRegistryAddition ()

bool	adjustToNewProductRegistry (ProductRegistry const &reg)

iterator	begin ()

const_iterator	begin () const

BranchType const &	branchType () const

CacheIdentifier_t	cacheIdentifier () const

void	clearPrincipal ()

void	deleteProduct (BranchID const &id) const

iterator	end ()

const_iterator	end () const

void	fillPrincipal (ProcessHistoryID const &hist, ProcessHistory 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

void	getAllStableProvenance (std::vector< StableProvenance 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, ProductResolverIndex index, bool skipCurrentProcess, bool &ambiguous, SharedResourcesAcquirer sra, ModuleCallingContext const mcc) const

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

ProductResolverBase *	getModifiableProductResolver (BranchID const &oid)

ConstProductResolverPtr	getProductResolver (BranchID const &oid) const

ConstProductResolverPtr	getProductResolverByIndex (ProductResolverIndex const &oid) const

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

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

void	prefetchAsync (WaitingTask waitTask, ProductResolverIndex index, bool skipCurrentProcess, ServiceToken const &token, ModuleCallingContext const mcc) const

	Principal (std::shared_ptr< ProductRegistry const > reg, std::shared_ptr< ProductResolverIndexHelper const > productLookup, ProcessConfiguration const &pc, BranchType bt, HistoryAppender *historyAppender, bool isForPrimaryProcess=true)

ProcessConfiguration const &	processConfiguration () const

ProcessHistory const &	processHistory () const

ProcessHistoryID const &	processHistoryID () const

EDProductGetter const *	prodGetter () const

ProductResolverIndexHelper const &	productLookup () const

ProductRegistry const &	productRegistry () const

void	readAllFromSourceAndMergeImmediately (MergeableRunProductMetadata const *mergeableRunProductMetadata=nullptr)

DelayedReader *	reader () const

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

void	setupUnscheduled (UnscheduledConfigurator const &)

size_t	size () const

	~Principal () override

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::unique_ptr< ProductResolverBase > phb)

void	addProductOrThrow (std::unique_ptr< ProductResolverBase > phb)

template<typename F >
void	applyToResolvers (F iFunc)

ProductResolverBase *	getExistingProduct (BranchID const &branchID)

ProductResolverBase const *	getExistingProduct (BranchID const &branchID) const

ProductResolverBase const *	getExistingProduct (ProductResolverBase const &phb) const

void	putOrMerge (BranchDescription const &bd, std::unique_ptr< WrapperBase > edp) const

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

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

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

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

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

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

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

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

virtual void	changedIndexes_ ()

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< ProductResolverBase const * > const &holders, TypeID const &typeID, BasicHandleVec &results, SharedResourcesAcquirer sra, ModuleCallingContext const mcc) const

WrapperBase const *	getIt (ProductID const &) const override

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

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

void	putOrMerge (std::unique_ptr< WrapperBase > prod, ProductResolverBase const *productResolver) const

Private Attributes
BranchType	branchType_

CacheIdentifier_t	cacheIdentifier_

edm::propagate_const< HistoryAppender * >	historyAppender_

std::vector< unsigned int >	lookupProcessOrder_

ProcessHistoryID	orderProcessHistoryID_

std::shared_ptr< ProductRegistry const >	preg_

ProcessConfiguration const *	processConfiguration_

ProcessHistoryID	processHistoryID_

ProcessHistoryID	processHistoryIDBeforeConfig_

std::shared_ptr< ProcessHistory const >	processHistoryPtr_

std::shared_ptr< ProductResolverIndexHelper const >	productLookup_

ProductResolverCollection	productResolvers_

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 57 of file Principal.h.

Member Typedef Documentation

◆ BasicHandleVec

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

Definition at line 64 of file Principal.h.

◆ CacheIdentifier_t

typedef unsigned long edm::Principal::CacheIdentifier_t

Definition at line 182 of file Principal.h.

◆ const_iterator

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

Definition at line 60 of file Principal.h.

◆ ConstProductResolverPtr

typedef ProductResolverBase const* edm::Principal::ConstProductResolverPtr

Definition at line 63 of file Principal.h.

◆ iterator

typedef boost::filter_iterator<FilledProductPtr, ProductResolverCollection::iterator> edm::Principal::iterator

Definition at line 61 of file Principal.h.

◆ ProcessName

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

Definition at line 68 of file Principal.h.

◆ ProcessNameConstIterator

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

Definition at line 62 of file Principal.h.

◆ ProductResolverCollection

typedef std::vector<propagate_const<std::shared_ptr<ProductResolverBase> > > edm::Principal::ProductResolverCollection

Definition at line 59 of file Principal.h.

◆ SharedProductPtr

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

Definition at line 67 of file Principal.h.

◆ size_type

typedef ProductResolverCollection::size_type edm::Principal::size_type

Definition at line 65 of file Principal.h.

Constructor & Destructor Documentation

◆ Principal()

edm::Principal::Principal	(	std::shared_ptr< ProductRegistry const >	reg,
		std::shared_ptr< ProductResolverIndexHelper const >	productLookup,
		ProcessConfiguration const &	pc,
		BranchType	bt,
		HistoryAppender *	historyAppender,
		bool	isForPrimaryProcess = `true`
	)

Definition at line 121 of file Principal.cc.

       : EDProductGetter(),
         processHistoryPtr_(),
         processHistoryID_(),
         processHistoryIDBeforeConfig_(),
         processConfiguration_(&pc),
         productResolvers_(),
         preg_(reg),
         productLookup_(productLookup),
         lookupProcessOrder_(productLookup->lookupProcessNames().size(), 0),
         reader_(),
         branchType_(bt),
         historyAppender_(historyAppender),
         cacheIdentifier_(nextIdentifier()) {
     productResolvers_.resize(reg->getNextIndexValue(bt));
     //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;
     bool hasSwitchAliases = false;
     for (auto const& prod : prodsList) {
       BranchDescription const& bd = prod.second;
       if (bd.branchType() == branchType_) {
         if (isForPrimaryProcess or bd.processName() == pc.processName()) {
           if (bd.isAlias()) {
             hasAliases = true;
           } else if (bd.isSwitchAlias()) {
             hasSwitchAliases = 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);
             }
           }
         } else {
           //We are in a SubProcess and this branch is from the parent
           auto cbd = std::make_shared<BranchDescription const>(bd);
           addParentProcessProduct(cbd);
         }
       }
     }
     // Now process any EDAliases
     if (hasAliases) {
       for (auto const& prod : prodsList) {
         BranchDescription const& bd = prod.second;
         if (bd.isAlias() && bd.branchType() == branchType_) {
           addAliasedProduct(std::make_shared<BranchDescription const>(bd));
         }
       }
     }
     // Finally process any SwitchProducer aliases
     if (hasSwitchAliases) {
       for (auto const& prod : prodsList) {
         BranchDescription const& bd = prod.second;
         if (bd.isSwitchAlias() && bd.branchType() == branchType_) {
           assert(branchType_ == InEvent);
           auto cbd = std::make_shared<BranchDescription const>(bd);
           // Need different implementation for SwitchProducers not
           // in any Path (onDemand) and for those in a Path in order
           // to prevent the switch-aliased-for EDProducers from
           // being run when the SwitchProducer is in a Path after a
           // failing EDFilter.
           if (bd.onDemand()) {
             addSwitchAliasProduct(cbd);
           } else {
             addSwitchProducerProduct(cbd);
           }
         }
       }
     }
  
     // Now create the ProductResolvers 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<ProductResolverIndex> matchingHolders(lookupProcessNames.size(), ProductResolverIndexInvalid);
     std::vector<bool> ambiguous(lookupProcessNames.size(), false);
     unsigned int beginElements = productLookup_->beginElements();
     std::vector<TypeID> const& sortedTypeIDs = productLookup_->sortedTypeIDs();
     std::vector<ProductResolverIndexHelper::Range> const& ranges = productLookup_->ranges();
     std::vector<ProductResolverIndexHelper::IndexAndNames> const& indexAndNames = productLookup_->indexAndNames();
     std::vector<char> const& processNamesCharArray = productLookup_->processNames();
  
     unsigned int numberOfMatches = 0;
     ProductResolverIndex lastMatchIndex = ProductResolverIndexInvalid;
     if (!sortedTypeIDs.empty()) {
       ProductResolverIndex productResolverIndex = ProductResolverIndexInvalid;
       for (unsigned int k = 0, kEnd = sortedTypeIDs.size(); k < kEnd; ++k) {
         ProductResolverIndexHelper::Range const& range = ranges.at(k);
         for (unsigned int i = range.begin(); i < range.end(); ++i) {
           ProductResolverIndexHelper::IndexAndNames const& product = indexAndNames.at(i);
           if (product.startInProcessNames() == 0) {
             if (productResolverIndex != ProductResolverIndexInvalid) {
               if ((numberOfMatches == 1) and (lastMatchIndex != ProductResolverIndexAmbiguous)) {
                 //only one choice so use a special resolver
                 productResolvers_.at(productResolverIndex) =
                     std::make_shared<SingleChoiceNoProcessProductResolver>(lastMatchIndex);
               } else {
                 bool productMadeAtEnd = false;
                 //Need to know if the product from this processes is added at end of transition
                 for (unsigned int j = 0; j < matchingHolders.size(); ++j) {
                   if ((not ambiguous[j]) and ProductResolverIndexInvalid != matchingHolders[j] and
                       productResolvers_[matchingHolders[j]]->branchDescription().availableOnlyAtEndTransition()) {
                     productMadeAtEnd = true;
                     break;
                   }
                 }
                 std::shared_ptr<ProductResolverBase> newHolder =
                     std::make_shared<NoProcessProductResolver>(matchingHolders, ambiguous, productMadeAtEnd);
                 productResolvers_.at(productResolverIndex) = newHolder;
               }
               matchingHolders.assign(lookupProcessNames.size(), ProductResolverIndexInvalid);
               ambiguous.assign(lookupProcessNames.size(), false);
               numberOfMatches = 0;
               lastMatchIndex = ProductResolverIndexInvalid;
             }
             productResolverIndex = product.index();
           } else {
             std::string process(&processNamesCharArray.at(product.startInProcessNames()));
             auto iter = std::find(lookupProcessNames.begin(), lookupProcessNames.end(), process);
             assert(iter != lookupProcessNames.end());
             ProductResolverIndex iMatchingIndex = product.index();
             lastMatchIndex = iMatchingIndex;
             assert(iMatchingIndex != ProductResolverIndexInvalid);
             ++numberOfMatches;
             if (iMatchingIndex == ProductResolverIndexAmbiguous) {
               assert(k >= beginElements);
               ambiguous.at(iter - lookupProcessNames.begin()) = true;
             } else {
               matchingHolders.at(iter - lookupProcessNames.begin()) = iMatchingIndex;
             }
           }
         }
       }
       //Need to know if the product from this processes is added at end of transition
       if ((numberOfMatches == 1) and (lastMatchIndex != ProductResolverIndexAmbiguous)) {
         //only one choice so use a special resolver
         productResolvers_.at(productResolverIndex) =
             std::make_shared<SingleChoiceNoProcessProductResolver>(lastMatchIndex);
       } else {
         bool productMadeAtEnd = false;
         for (unsigned int i = 0; i < matchingHolders.size(); ++i) {
           if ((not ambiguous[i]) and ProductResolverIndexInvalid != matchingHolders[i] and
               productResolvers_[matchingHolders[i]]->branchDescription().availableOnlyAtEndTransition()) {
             productMadeAtEnd = true;
             break;
           }
         }
         std::shared_ptr<ProductResolverBase> newHolder =
             std::make_shared<NoProcessProductResolver>(matchingHolders, ambiguous, productMadeAtEnd);
         productResolvers_.at(productResolverIndex) = newHolder;
       }
     }
   }

References addAliasedProduct(), addInputProduct(), addParentProcessProduct(), addScheduledProduct(), addSourceProduct(), addSwitchAliasProduct(), addSwitchProducerProduct(), addUnscheduledProduct(), cms::cuda::assert(), edm::BranchDescription::branchType(), branchType_, spr::find(), mps_fire::i, edm::ProductResolverIndexHelper::IndexAndNames::index(), edm::InEvent, edm::BranchDescription::isAlias(), edm::BranchDescription::isSwitchAlias(), dqmiolumiharvest::j, dqmdumpme::k, edm::BranchDescription::moduleLabel(), edm::BranchDescription::onDemand(), or, LaserDQM_cfg::process, edm::ProcessConfiguration::processName(), edm::BranchDescription::processName(), dumpMFGeometry_cfg::prod, edm::BranchDescription::produced(), productLookup_, edm::ProductResolverIndexAmbiguous, edm::ProductResolverIndexInvalid, productResolvers_, FastTimerService_cff::range, diffTwoXMLs::ranges, edm::source(), edm::ProductResolverIndexHelper::IndexAndNames::startInProcessNames(), and AlCaHLTBitMon_QueryRunRegistry::string.

◆ ~Principal()

edm::Principal::~Principal ( )

override

Definition at line 293 of file Principal.cc.

293 {}

Member Function Documentation

◆ addAliasedProduct()

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

private

Definition at line 344 of file Principal.cc.

                                                                              {
     ProductResolverIndex index = preg_->indexFrom(bd->originalBranchID());
     assert(index != ProductResolverIndexInvalid);
  
     addProductOrThrow(std::make_unique<AliasProductResolver>(
         std::move(bd), dynamic_cast<DataManagingOrAliasProductResolver&>(*productResolvers_[index])));
   }

References addProductOrThrow(), cms::cuda::assert(), eostools::move(), preg_, edm::ProductResolverIndexInvalid, and productResolvers_.

Referenced by Principal().

◆ addInputProduct()

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

private

Definition at line 336 of file Principal.cc.

                                                                            {
     addProductOrThrow(std::make_unique<InputProductResolver>(std::move(bd)));
   }

References addProductOrThrow(), and eostools::move().

Referenced by adjustIndexesAfterProductRegistryAddition(), and Principal().

◆ addParentProcessProduct()

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

private

Definition at line 368 of file Principal.cc.

                                                                                    {
     addProductOrThrow(std::make_unique<ParentProcessProductResolver>(std::move(bd)));
   }

References addProductOrThrow(), and eostools::move().

Referenced by Principal().

◆ addProduct_()

void edm::Principal::addProduct_ ( std::unique_ptr< ProductResolverBase > phb )

protected

Definition at line 502 of file Principal.cc.

                                                                                 {
     BranchDescription const& bd = productResolver->branchDescription();
     assert(!bd.className().empty());
     assert(!bd.friendlyClassName().empty());
     assert(!bd.moduleLabel().empty());
     assert(!bd.processName().empty());
     SharedProductPtr phb(productResolver.release());
  
     ProductResolverIndex index = preg_->indexFrom(bd.branchID());
     assert(index != ProductResolverIndexInvalid);
     productResolvers_[index] = phb;
   }

References cms::cuda::assert(), edm::BranchDescription::branchID(), edm::BranchDescription::className(), edm::BranchDescription::friendlyClassName(), edm::BranchDescription::moduleLabel(), preg_, edm::BranchDescription::processName(), edm::ProductResolverIndexInvalid, and productResolvers_.

Referenced by addProductOrThrow().

◆ addProductOrThrow()

void edm::Principal::addProductOrThrow ( std::unique_ptr< ProductResolverBase > phb )

protected

Definition at line 515 of file Principal.cc.

                                                                                       {
     ProductResolverBase const* phb = getExistingProduct(*productResolver);
     if (phb != nullptr) {
       BranchDescription const& bd = productResolver->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_(std::move(productResolver));
   }

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

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

◆ addScheduledProduct()

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

private

Definition at line 326 of file Principal.cc.

                                                                                {
     auto phb = std::make_unique<PuttableProductResolver>(std::move(bd));
     addProductOrThrow(std::move(phb));
   }

References addProductOrThrow(), and eostools::move().

Referenced by Principal().

◆ addSourceProduct()

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

private

Definition at line 331 of file Principal.cc.

                                                                             {
     auto phb = std::make_unique<PuttableProductResolver>(std::move(bd));
     addProductOrThrow(std::move(phb));
   }

References addProductOrThrow(), and eostools::move().

Referenced by Principal().

◆ addSwitchAliasProduct()

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

private

Definition at line 360 of file Principal.cc.

                                                                                  {
     ProductResolverIndex index = preg_->indexFrom(bd->switchAliasForBranchID());
     assert(index != ProductResolverIndexInvalid);
  
     addProductOrThrow(std::make_unique<SwitchAliasProductResolver>(
         std::move(bd), dynamic_cast<DataManagingOrAliasProductResolver&>(*productResolvers_[index])));
   }

References addProductOrThrow(), cms::cuda::assert(), eostools::move(), preg_, edm::ProductResolverIndexInvalid, and productResolvers_.

Referenced by Principal().

◆ addSwitchProducerProduct()

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

private

Definition at line 352 of file Principal.cc.

                                                                                     {
     ProductResolverIndex index = preg_->indexFrom(bd->switchAliasForBranchID());
     assert(index != ProductResolverIndexInvalid);
  
     addProductOrThrow(std::make_unique<SwitchProducerProductResolver>(
         std::move(bd), dynamic_cast<DataManagingOrAliasProductResolver&>(*productResolvers_[index])));
   }

References addProductOrThrow(), cms::cuda::assert(), eostools::move(), preg_, edm::ProductResolverIndexInvalid, and productResolvers_.

Referenced by Principal().

◆ addUnscheduledProduct()

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

private

Definition at line 340 of file Principal.cc.

                                                                                  {
     addProductOrThrow(std::make_unique<UnscheduledProductResolver>(std::move(bd)));
   }

References addProductOrThrow(), and eostools::move().

Referenced by Principal().

◆ adjustIndexesAfterProductRegistryAddition()

void edm::Principal::adjustIndexesAfterProductRegistryAddition ( )

Definition at line 884 of file Principal.cc.

                                                             {
     if (preg_->getNextIndexValue(branchType_) != productResolvers_.size()) {
       bool changed = false;
       productResolvers_.resize(preg_->getNextIndexValue(branchType_));
       for (auto const& prod : preg_->productList()) {
         BranchDescription const& bd = prod.second;
         if (bd.branchType() == branchType_) {
           ProductResolverIndex index = preg_->indexFrom(bd.branchID());
           assert(index != ProductResolverIndexInvalid);
           if (!productResolvers_[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);
             changed = true;
           }
         }
       }
       if (changed) {
         changedIndexes_();
       }
     }
     assert(preg_->getNextIndexValue(branchType_) == productResolvers_.size());
   }

References addInputProduct(), cms::cuda::assert(), edm::BranchDescription::branchID(), edm::BranchDescription::branchType(), branchType_, changedIndexes_(), preg_, dumpMFGeometry_cfg::prod, edm::BranchDescription::produced(), edm::ProductResolverIndexInvalid, and productResolvers_.

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

◆ adjustToNewProductRegistry()

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

Definition at line 310 of file Principal.cc.

                                                                        {
     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);
         auto phb = getExistingProduct(cbd->branchID());
         if (phb == nullptr || phb->branchDescription().branchName() != cbd->branchName()) {
           return false;
         }
         phb->resetBranchDescription(cbd);
       }
     }
     return true;
   }

References edm::BranchDescription::branchType(), branchType_, getExistingProduct(), dumpMFGeometry_cfg::prod, edm::BranchDescription::produced(), edm::ProductRegistry::productList(), and edm::ProductResolverBase::resetBranchDescription().

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

◆ applyToResolvers()

template<typename F >

void edm::Principal::applyToResolvers ( F iFunc )

inlineprotected

Definition at line 213 of file Principal.h.

                                    {
       for (auto& resolver : productResolvers_) {
         iFunc(resolver.get());
       }
     }

References productResolvers_.

Referenced by setupUnscheduled().

◆ begin() [1/2]

iterator edm::Principal::begin ( void )

inline

Definition at line 166 of file Principal.h.

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

References productResolvers_.

◆ begin() [2/2]

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

inline

Definition at line 159 of file Principal.h.

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

References productResolvers_.

◆ branchType()

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

inline

Definition at line 179 of file Principal.h.

179 { return branchType_; }

References branchType_.

Referenced by edm::PrincipalGetAdapter::branchType(), findProductByLabel(), getManyByType(), edm::Worker::prefetchAsync(), and edm::InputProductResolver::resolveProduct_().

◆ cacheIdentifier()

CacheIdentifier_t edm::Principal::cacheIdentifier ( ) const

inline

Definition at line 183 of file Principal.h.

183 { return cacheIdentifier_; }

References cacheIdentifier_.

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

◆ changedIndexes_()

virtual void edm::Principal::changedIndexes_ ( )

inlineprivatevirtual

Reimplemented in edm::EventPrincipal.

Definition at line 221 of file Principal.h.

221 {}

Referenced by adjustIndexesAfterProductRegistryAddition().

◆ clearPrincipal()

void edm::Principal::clearPrincipal ( )

Definition at line 373 of file Principal.cc.

                                  {
     //We do not clear the product history information
     // because it rarely changes and recalculating takes
     // time.
     reader_ = nullptr;
     for (auto& prod : *this) {
       prod->resetProductData();
     }
   }

References dumpMFGeometry_cfg::prod, and reader_.

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

◆ deleteProduct()

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

Definition at line 383 of file Principal.cc.

                                                         {
     auto phb = getExistingProduct(id);
     assert(nullptr != phb);
     phb->unsafe_deleteProduct();
   }

References cms::cuda::assert(), and getExistingProduct().

◆ end() [1/2]

iterator edm::Principal::end ( void )

inline

Definition at line 169 of file Principal.h.

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

References productResolvers_.

Referenced by Types.LuminosityBlockRange::cppID(), and Types.EventRange::cppID().

◆ end() [2/2]

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

inline

Definition at line 162 of file Principal.h.

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

References productResolvers_.

Referenced by Types.LuminosityBlockRange::cppID(), Types.EventRange::cppID(), and edm::EventPrincipal::wasBranchListIndexesChangedFromInput().

◆ fillPrincipal()

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

Definition at line 394 of file Principal.cc.

                                                        {
     //increment identifier here since clearPrincipal isn't called for Run/Lumi
     cacheIdentifier_ = nextIdentifier();
     if (reader) {
       reader_ = reader;
     }
  
     if (historyAppender_ && productRegistry().anyProductProduced()) {
       if ((not processHistoryPtr_) || (processHistoryIDBeforeConfig_ != hist)) {
         processHistoryPtr_ = historyAppender_->appendToProcessHistory(hist, processHistory, *processConfiguration_);
         processHistoryID_ = processHistoryPtr_->id();
         processHistoryIDBeforeConfig_ = hist;
       }
     } else {
       std::shared_ptr<ProcessHistory const> inputProcessHistory;
       if ((not processHistoryPtr_) || (processHistoryIDBeforeConfig_ != hist)) {
         if (hist.isValid()) {
           //does not own the pointer
           auto noDel = [](void const*) {};
           inputProcessHistory = std::shared_ptr<ProcessHistory const>(processHistory, 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*) {});
           //no need to do any ordering since it is empty
           orderProcessHistoryID_ = hist;
         }
         processHistoryID_ = hist;
         processHistoryPtr_ = inputProcessHistory;
         processHistoryIDBeforeConfig_ = hist;
       }
     }
  
     if (orderProcessHistoryID_ != processHistoryID_) {
       std::vector<std::string> const& lookupProcessNames = productLookup_->lookupProcessNames();
       lookupProcessOrder_.assign(lookupProcessNames.size(), 0);
       unsigned int k = 0;
  
       // We loop over processes in reverse order of the ProcessHistory.
       // If any entries in the product lookup tables are associated with
       // the process we add it to the vector of processes in the order
       // the lookup should be performed. There is one exception though,
       // We start with the current process even if it is not in the ProcessHistory.
       // The current process might be needed but not be in the process
       // history if all the products produced in the current process are
       // transient.
       {
         auto nameIterCurrentProcess =
             std::find(lookupProcessNames.begin(), lookupProcessNames.end(), processConfiguration_->processName());
         if (nameIterCurrentProcess != lookupProcessNames.end()) {
           lookupProcessOrder_.at(k) = nameIterCurrentProcess - lookupProcessNames.begin();
           ++k;
         }
       }
  
       // We just looked for the current process so skip it if
       // it is in the ProcessHistory.
       auto iter = processHistoryPtr_->rbegin();
       if (iter->processName() == processConfiguration_->processName()) {
         ++iter;
       }
  
       for (auto 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_;
     }
   }

References cacheIdentifier_, Exception, spr::find(), compare::hist, historyAppender_, dqmdumpme::k, edm::errors::LogicError, lookupProcessOrder_, edm::nextIdentifier(), orderProcessHistoryID_, processConfiguration_, processHistory(), processHistoryID_, processHistoryIDBeforeConfig_, processHistoryPtr_, edm::ProcessConfiguration::processName(), productLookup_, productRegistry(), reader(), reader_, and edm::s_emptyProcessHistory.

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

◆ findProductByLabel() [1/2]

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 706 of file Principal.cc.

                                                                                           {
     bool skipCurrentProcess = inputTag.willSkipCurrentProcess();
  
     ProductResolverIndex index = inputTag.indexFor(typeID, branchType(), &productRegistry());
  
     if (index == ProductResolverIndexInvalid) {
       char const* processName = inputTag.process().c_str();
       if (skipCurrentProcess) {
         processName = "\0";
       } else if (inputTag.process() == InputTag::kCurrentProcess) {
         processName = processConfiguration_->processName().c_str();
       }
  
       index =
           productLookup().index(kindOfType, typeID, inputTag.label().c_str(), inputTag.instance().c_str(), processName);
  
       if (index == ProductResolverIndexAmbiguous) {
         throwAmbiguousException("findProductByLabel",
                                 typeID,
                                 inputTag.label(),
                                 inputTag.instance(),
                                 appendCurrentProcessIfAlias(inputTag.process(), processConfiguration_->processName()));
       } else if (index == ProductResolverIndexInvalid) {
         return nullptr;
       }
       inputTag.tryToCacheIndex(index, typeID, branchType(), &productRegistry());
     }
     if (UNLIKELY(consumer and (not consumer->registeredToConsume(index, skipCurrentProcess, branchType())))) {
       failedToRegisterConsumes(kindOfType,
                                typeID,
                                inputTag.label(),
                                inputTag.instance(),
                                appendCurrentProcessIfAlias(inputTag.process(), processConfiguration_->processName()));
     }
  
     auto const& productResolver = productResolvers_[index];
  
     auto resolution = productResolver->resolveProduct(*this, skipCurrentProcess, sra, mcc);
     if (resolution.isAmbiguous()) {
       throwAmbiguousException("findProductByLabel",
                               typeID,
                               inputTag.label(),
                               inputTag.instance(),
                               appendCurrentProcessIfAlias(inputTag.process(), processConfiguration_->processName()));
     }
     return resolution.data();
   }

References edm::appendCurrentProcessIfAlias(), branchType(), OfflineOutput_cfi::consumer, edm::ProductResolverIndexHelper::index(), SimL1EmulatorRepack_Full_cff::inputTag, edm::InputTag::kCurrentProcess, processConfiguration_, SimL1EmulatorRepack_CalouGT_cff::processName, edm::ProcessConfiguration::processName(), productLookup(), productRegistry(), edm::ProductResolverIndexAmbiguous, edm::ProductResolverIndexInvalid, productResolvers_, L1TObjectsTimingClient_cff::resolution, edm::throwAmbiguousException(), and UNLIKELY.

Referenced by findProductByTag(), and getByLabel().

◆ findProductByLabel() [2/2]

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 759 of file Principal.cc.

                                                                                           {
     ProductResolverIndex index =
         productLookup().index(kindOfType, typeID, label.c_str(), instance.c_str(), process.c_str());
  
     if (index == ProductResolverIndexAmbiguous) {
       throwAmbiguousException("findProductByLabel", typeID, label, instance, process);
     } else if (index == ProductResolverIndexInvalid) {
       return nullptr;
     }
  
     if (UNLIKELY(consumer and (not consumer->registeredToConsume(index, false, branchType())))) {
       failedToRegisterConsumes(kindOfType, typeID, label, instance, process);
     }
  
     auto const& productResolver = productResolvers_[index];
  
     auto resolution = productResolver->resolveProduct(*this, false, sra, mcc);
     if (resolution.isAmbiguous()) {
       throwAmbiguousException("findProductByLabel", typeID, label, instance, process);
     }
     return resolution.data();
   }

References branchType(), OfflineOutput_cfi::consumer, edm::ProductResolverIndexHelper::index(), instance, label, LaserDQM_cfg::process, productLookup(), edm::ProductResolverIndexAmbiguous, edm::ProductResolverIndexInvalid, productResolvers_, L1TObjectsTimingClient_cff::resolution, edm::throwAmbiguousException(), and UNLIKELY.

◆ findProductByTag()

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

Definition at line 789 of file Principal.cc.

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

References findProductByLabel(), edm::PRODUCT_TYPE, and GlobalPosition_Frontier_DevDB_cff::tag.

◆ findProducts()

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

private

Definition at line 681 of file Principal.cc.

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

References edm::BranchDescription::isAnyAlias(), LaserDQM_cfg::process, processHistoryPtr_, edm::BranchDescription::processName(), edm::ProductData::provenance(), bookConverter::results, AlCaHLTBitMon_QueryRunRegistry::string, and edm::ProductData::wrapper().

Referenced by getManyByType().

◆ getAllProvenance()

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

Definition at line 813 of file Principal.cc.

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

Referenced by edm::OccurrenceForOutput::getAllProvenance(), and edm::Event::getAllProvenance().

◆ getAllStableProvenance()

void edm::Principal::getAllStableProvenance ( std::vector< StableProvenance const * > & provenances ) const

Definition at line 830 of file Principal.cc.

                                                                                               {
     provenances.clear();
     for (auto const& productResolver : *this) {
       if (productResolver->singleProduct() && !productResolver->branchDescription().isAnyAlias()) {
         if (productResolver->stableProvenance()->branchDescription().present()) {
           provenances.push_back(productResolver->stableProvenance());
         }
       }
     }
   }

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

◆ getByLabel() [1/2]

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

Definition at line 540 of file Principal.cc.

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

References edm::appendCurrentProcessIfAlias(), OfflineOutput_cfi::consumer, findProductByLabel(), SimL1EmulatorRepack_Full_cff::inputTag, edm::makeHandleExceptionFactory(), edm::makeNotFoundException(), processConfiguration_, edm::ProcessConfiguration::processName(), and mps_fire::result.

Referenced by edm::test::Event::get(), PileUpEventPrincipal::getByLabel(), edm::PrincipalGetAdapter::getByLabel_(), and edm::PrincipalGetAdapter::getMatchingSequenceByLabel_().

◆ getByLabel() [2/2]

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 561 of file Principal.cc.

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

References OfflineOutput_cfi::consumer, findProductByLabel(), instance, label, edm::makeHandleExceptionFactory(), edm::makeNotFoundException(), LaserDQM_cfg::process, and mps_fire::result.

◆ getByToken()

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

Definition at line 578 of file Principal.cc.

                                                                            {
     assert(index != ProductResolverIndexInvalid);
     auto& productResolver = productResolvers_[index];
     assert(nullptr != productResolver.get());
     auto resolution = productResolver->resolveProduct(*this, skipCurrentProcess, sra, mcc);
     if (resolution.isAmbiguous()) {
       ambiguous = true;
       //The caller is looking explicitly for this case
       // and uses the extra data at the caller to setup the exception
       return BasicHandle::makeInvalid();
     }
     auto productData = resolution.data();
     if (productData == nullptr) {
       //The caller is looking explicitly for this case
       // and uses the extra data at the caller to setup the exception
       return BasicHandle::makeInvalid();
     }
     return BasicHandle(productData->wrapper(), &(productData->provenance()));
   }

References cms::cuda::assert(), edm::BasicHandle::makeInvalid(), edm::ProductResolverIndexInvalid, productResolvers_, and L1TObjectsTimingClient_cff::resolution.

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

◆ getExistingProduct() [1/3]

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

protected

Definition at line 474 of file Principal.cc.

                                                                              {
     return const_cast<ProductResolverBase*>(const_cast<const Principal*>(this)->getExistingProduct(branchID));
   }

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

◆ getExistingProduct() [2/3]

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

protected

Definition at line 478 of file Principal.cc.

                                                                                          {
     ProductResolverIndex index = preg_->indexFrom(branchID);
     assert(index != ProductResolverIndexInvalid);
     return productResolvers_.at(index).get();
   }

References cms::cuda::assert(), preg_, edm::ProductResolverIndexInvalid, and productResolvers_.

◆ getExistingProduct() [3/3]

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

protected

Definition at line 484 of file Principal.cc.

                                                                                                            {
     auto phb = getExistingProduct(productResolver.branchDescription().branchID());
     if (nullptr != phb && BranchKey(productResolver.branchDescription()) != BranchKey(phb->branchDescription())) {
       BranchDescription const& newProduct = phb->branchDescription();
       BranchDescription const& existing = productResolver.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(productResolver.branchDescription()) == BranchKey(phb->branchDescription()));
       }
     }
     return phb;
   }

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

◆ getIt()

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

overrideprivatevirtual

Implements edm::EDProductGetter.

Definition at line 852 of file Principal.cc.

                                                             {
     assert(false);
     return nullptr;
   }

References cms::cuda::assert().

◆ getManyByType()

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

Definition at line 614 of file Principal.cc.

                                                                        {
     assert(results.empty());
  
     if (UNLIKELY(consumer and (not consumer->registeredToConsumeMany(typeID, branchType())))) {
       failedToRegisterConsumesMany(typeID);
     }
  
     // This finds the indexes to all the ProductResolver's matching the type
     ProductResolverIndexHelper::Matches matches = productLookup().relatedIndexes(PRODUCT_TYPE, typeID);
  
     if (matches.numberOfMatches() == 0) {
       return;
     }
  
     results.reserve(matches.numberOfMatches());
  
     // Loop over the ProductResolvers. 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 ProductResolvers
     // 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<ProductResolverBase const*> holders;
  
     for (unsigned int i = 0; i < matches.numberOfMatches(); ++i) {
       ProductResolverIndex 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 {
         ProductResolverBase const* productResolver = productResolvers_.at(index).get();
         assert(productResolver);
         holders.push_back(productResolver);
       }
     }
     // Do not miss the last subset of products
     if (!holders.empty()) {
       findProducts(holders, typeID, results, sra, mcc);
     }
     return;
   }

References cms::cuda::assert(), branchType(), OfflineOutput_cfi::consumer, findProducts(), mps_fire::i, patCandidatesForDimuonsSequences_cff::matches, edm::PRODUCT_TYPE, productLookup(), productResolvers_, edm::ProductResolverIndexHelper::relatedIndexes(), bookConverter::results, and UNLIKELY.

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

◆ getModifiableProductResolver()

ProductResolverBase* edm::Principal::getModifiableProductResolver ( BranchID const & oid )

inline

Definition at line 152 of file Principal.h.

                                                                            {
       return const_cast<ProductResolverBase*>(const_cast<const Principal*>(this)->getProductResolver(oid));
     }

References getProductResolver().

Referenced by edm::SubProcess::propagateProducts().

◆ getProductResolver()

Principal::ConstProductResolverPtr edm::Principal::getProductResolver ( BranchID const & oid ) const

Definition at line 527 of file Principal.cc.

                                                                                           {
     ProductResolverIndex index = preg_->indexFrom(bid);
     if (index == ProductResolverIndexInvalid) {
       return ConstProductResolverPtr();
     }
     return getProductResolverByIndex(index);
   }

References getProductResolverByIndex(), preg_, and edm::ProductResolverIndexInvalid.

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

◆ getProductResolverByIndex()

Principal::ConstProductResolverPtr edm::Principal::getProductResolverByIndex ( ProductResolverIndex const & oid ) const

Definition at line 535 of file Principal.cc.

                                                                                                                {
     ConstProductResolverPtr const phb = productResolvers_[index].get();
     return phb;
   }

References productResolvers_.

Referenced by edm::NoProcessProductResolver::dataValidFromResolver(), edm::PrincipalGetAdapter::getBranchDescription(), edm::PrincipalGetAdapter::getProductID(), getProductResolver(), edm::SingleChoiceNoProcessProductResolver::prefetchAsync_(), edm::LuminosityBlockPrincipal::put(), edm::RunPrincipal::put(), edm::EventPrincipal::put(), edm::SingleChoiceNoProcessProductResolver::resolveProduct_(), edm::NoProcessProductResolver::tryPrefetchResolverAsync(), and edm::NoProcessProductResolver::tryResolver().

◆ getProvenance()

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

Definition at line 796 of file Principal.cc.

                                                                                                 {
     ConstProductResolverPtr const phb = getProductResolver(bid);
     if (phb == nullptr) {
       throwProductNotFoundException("getProvenance", errors::ProductNotFound, bid);
     }
  
     if (phb->unscheduledWasNotRun()) {
       if (not phb->resolveProduct(*this, false, nullptr, mcc).data()) {
         throwProductNotFoundException("getProvenance(onDemand)", errors::ProductNotFound, bid);
       }
     }
     return *phb->provenance();
   }

References getProductResolver(), edm::errors::ProductNotFound, and edm::throwProductNotFoundException().

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

◆ getThinnedProduct()

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

overrideprivatevirtual

Implements edm::EDProductGetter.

Definition at line 857 of file Principal.cc.

                                                                                        {
     assert(false);
     return nullptr;
   }

References cms::cuda::assert().

◆ getThinnedProducts()

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

overrideprivatevirtual

Implements edm::EDProductGetter.

Definition at line 862 of file Principal.cc.

                                                                      {
     assert(false);
   }

References cms::cuda::assert().

◆ lookupProcessOrder()

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

inline

Definition at line 195 of file Principal.h.

195 { return lookupProcessOrder_; }

References lookupProcessOrder_.

Referenced by edm::NoProcessProductResolver::dataValidFromResolver(), edm::NoProcessProductResolver::prefetchFailed(), edm::NoProcessProductResolver::resolveProduct_(), and edm::NoProcessProductResolver::tryPrefetchResolverAsync().

◆ prefetchAsync()

void edm::Principal::prefetchAsync	(	WaitingTask *	waitTask,
		ProductResolverIndex	index,
		bool	skipCurrentProcess,
		ServiceToken const &	token,
		ModuleCallingContext const *	mcc
	)		const

Definition at line 604 of file Principal.cc.

                                                                        {
     auto const& productResolver = productResolvers_.at(index);
     assert(nullptr != productResolver.get());
     productResolver->prefetchAsync(task, *this, skipCurrentProcess, token, nullptr, mcc);
   }

References cms::cuda::assert(), productResolvers_, TrackValidation_cff::task, and unpackBuffers-CaloStage2::token.

Referenced by edm::Worker::prefetchAsync(), and edm::Worker::prePrefetchSelectionAsync().

◆ processConfiguration()

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

inline

Definition at line 143 of file Principal.h.

143 { return *processConfiguration_; }

References processConfiguration_.

◆ processHistory()

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

inline

Definition at line 139 of file Principal.h.

139 { return *processHistoryPtr_; }

References processHistoryPtr_.

Referenced by edm::EventPrincipal::commonFillEventPrincipal(), edm::SubProcess::doBeginLuminosityBlockAsync(), edm::SubProcess::doBeginRunAsync(), edm::EventPrincipal::fillEventPrincipal(), edm::LuminosityBlockPrincipal::fillLuminosityBlockPrincipal(), fillPrincipal(), edm::SubProcess::processAsync(), and edm::PrincipalGetAdapter::processHistory().

◆ processHistoryID()

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

inline

Definition at line 141 of file Principal.h.

141 { return processHistoryID_; }

References processHistoryID_.

Referenced by edm::EventPrincipal::commonFillEventPrincipal(), edm::SubProcess::doBeginLuminosityBlockAsync(), edm::SubProcess::doBeginRunAsync(), edm::SubProcess::processAsync(), edm::OccurrenceForOutput::processHistoryID(), edm::Event::processHistoryID(), edm::LuminosityBlock::processHistoryID(), and edm::Run::processHistoryID().

◆ prodGetter()

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

inline

Definition at line 91 of file Principal.h.

91 { return this; }

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

◆ productLookup()

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

inline

Definition at line 147 of file Principal.h.

147 { return *productLookup_; }

References productLookup_.

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

◆ productRegistry()

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

inline

Definition at line 145 of file Principal.h.

145 { return *preg_; }

References preg_.

Referenced by edm::EventPrincipal::changedIndexes_(), fillPrincipal(), findProductByLabel(), edm::SubProcess::processAsync(), and edm::PrincipalGetAdapter::throwUnregisteredPutException().

◆ putOrMerge() [1/2]

void edm::Principal::putOrMerge	(	BranchDescription const &	bd,
		std::unique_ptr< WrapperBase >	edp
	)		const

protected

Definition at line 872 of file Principal.cc.

                                                                                               {
     if (edp.get() == nullptr) {
       throw edm::Exception(edm::errors::InsertFailure, "Null Pointer")
           << "put: Cannot put because unique_ptr to product is null."
           << "\n";
     }
     auto phb = getExistingProduct(bd.branchID());
     assert(phb);
     // ProductResolver assumes ownership
     putOrMerge(std::move(edp), phb);
   }

References cms::cuda::assert(), edm::BranchDescription::branchID(), Exception, getExistingProduct(), edm::errors::InsertFailure, and eostools::move().

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

◆ putOrMerge() [2/2]

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

private

Definition at line 868 of file Principal.cc.

                                                                                                   {
     phb->putOrMergeProduct(std::move(prod));
   }

References eostools::move(), dumpMFGeometry_cfg::prod, and edm::ProductResolverBase::putOrMergeProduct().

◆ readAllFromSourceAndMergeImmediately()

void edm::Principal::readAllFromSourceAndMergeImmediately ( MergeableRunProductMetadata const * mergeableRunProductMetadata = nullptr )

Definition at line 909 of file Principal.cc.

                                                                                                                      {
     if (not reader()) {
       return;
     }
  
     for (auto& prod : *this) {
       prod->retrieveAndMerge(*this, mergeableRunProductMetadata);
     }
   }

References dumpMFGeometry_cfg::prod, and reader().

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

◆ reader()

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

inline

Definition at line 185 of file Principal.h.

185 { return reader_; }

References reader_.

Referenced by edm::EventPrincipal::commonFillEventPrincipal(), edm::SubProcess::doBeginLuminosityBlockAsync(), edm::SubProcess::doBeginRunAsync(), edm::EventPrincipal::fillEventPrincipal(), edm::LuminosityBlockPrincipal::fillLuminosityBlockPrincipal(), fillPrincipal(), edm::RunPrincipal::fillRunPrincipal(), edm::SubProcess::processAsync(), readAllFromSourceAndMergeImmediately(), edm::InputProductResolver::resolveProduct_(), and edm::InputProductResolver::retrieveAndMerge_().

◆ recombine()

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

Definition at line 841 of file Principal.cc.

                                                                              {
     for (auto& prod : bids) {
       ProductResolverIndex index = preg_->indexFrom(prod);
       assert(index != ProductResolverIndexInvalid);
       ProductResolverIndex indexO = other.preg_->indexFrom(prod);
       assert(indexO != ProductResolverIndexInvalid);
       get_underlying_safe(productResolvers_[index]).swap(get_underlying_safe(other.productResolvers_[indexO]));
     }
     reader_->mergeReaders(other.reader());
   }

References cms::cuda::assert(), edm::get_underlying_safe(), edm::DelayedReader::mergeReaders(), trackingPlots::other, preg_, dumpMFGeometry_cfg::prod, edm::ProductResolverIndexInvalid, productResolvers_, and reader_.

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

◆ setupUnscheduled()

void edm::Principal::setupUnscheduled ( UnscheduledConfigurator const & iConfigure )

Definition at line 389 of file Principal.cc.

                                                                             {
     applyToResolvers([&iConfigure](ProductResolverBase* iResolver) { iResolver->setupUnscheduled(iConfigure); });
   }

References applyToResolvers(), and edm::ProductResolverBase::setupUnscheduled().

◆ size()

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

Definition at line 298 of file Principal.cc.

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

References dumpMFGeometry_cfg::prod, and mitigatedMETSequence_cff::U.

Referenced by ntupleDataFormat._Collection::__iter__(), ntupleDataFormat._Collection::__len__(), edm::StreamerInputSource::read(), edm::OccurrenceForOutput::size(), and edm::Event::size().

Member Data Documentation

◆ branchType_

BranchType edm::Principal::branchType_

private

Definition at line 284 of file Principal.h.

Referenced by adjustIndexesAfterProductRegistryAddition(), adjustToNewProductRegistry(), branchType(), and Principal().

◆ cacheIdentifier_

CacheIdentifier_t edm::Principal::cacheIdentifier_

private

Definition at line 291 of file Principal.h.

Referenced by cacheIdentifier(), and fillPrincipal().

◆ historyAppender_

edm::propagate_const<HistoryAppender*> edm::Principal::historyAppender_

private

Definition at line 289 of file Principal.h.

Referenced by fillPrincipal().

◆ lookupProcessOrder_

std::vector<unsigned int> edm::Principal::lookupProcessOrder_

private

Definition at line 277 of file Principal.h.

Referenced by fillPrincipal(), and lookupProcessOrder().

◆ orderProcessHistoryID_

ProcessHistoryID edm::Principal::orderProcessHistoryID_

private

Definition at line 278 of file Principal.h.

Referenced by fillPrincipal().

◆ preg_

std::shared_ptr<ProductRegistry const> edm::Principal::preg_

private

Definition at line 274 of file Principal.h.

Referenced by addAliasedProduct(), addProduct_(), addSwitchAliasProduct(), addSwitchProducerProduct(), adjustIndexesAfterProductRegistryAddition(), getExistingProduct(), getProductResolver(), productRegistry(), and recombine().

◆ processConfiguration_

ProcessConfiguration const* edm::Principal::processConfiguration_

private

Definition at line 267 of file Principal.h.

Referenced by fillPrincipal(), findProductByLabel(), getByLabel(), and processConfiguration().

◆ processHistoryID_

ProcessHistoryID edm::Principal::processHistoryID_

private

Definition at line 264 of file Principal.h.

Referenced by fillPrincipal(), and processHistoryID().

◆ processHistoryIDBeforeConfig_

ProcessHistoryID edm::Principal::processHistoryIDBeforeConfig_

private

Definition at line 265 of file Principal.h.

Referenced by fillPrincipal().

◆ processHistoryPtr_

std::shared_ptr<ProcessHistory const> edm::Principal::processHistoryPtr_

private

Definition at line 262 of file Principal.h.

Referenced by fillPrincipal(), findProducts(), and processHistory().

◆ productLookup_

std::shared_ptr<ProductResolverIndexHelper const> edm::Principal::productLookup_

private

Definition at line 275 of file Principal.h.

Referenced by fillPrincipal(), Principal(), and productLookup().

◆ productResolvers_

ProductResolverCollection edm::Principal::productResolvers_

private

Definition at line 270 of file Principal.h.

Referenced by addAliasedProduct(), addProduct_(), addSwitchAliasProduct(), addSwitchProducerProduct(), adjustIndexesAfterProductRegistryAddition(), applyToResolvers(), begin(), end(), findProductByLabel(), getByToken(), getExistingProduct(), getManyByType(), getProductResolverByIndex(), prefetchAsync(), Principal(), and recombine().

◆ reader_

DelayedReader* edm::Principal::reader_

private

Definition at line 282 of file Principal.h.

Referenced by clearPrincipal(), fillPrincipal(), reader(), and recombine().

Public Types

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ BasicHandleVec

◆ CacheIdentifier_t

◆ const_iterator

◆ ConstProductResolverPtr

◆ iterator

◆ ProcessName

◆ ProcessNameConstIterator

◆ ProductResolverCollection

◆ SharedProductPtr

◆ size_type

Constructor & Destructor Documentation

◆ Principal()

◆ ~Principal()

Member Function Documentation

◆ addAliasedProduct()

◆ addInputProduct()

◆ addParentProcessProduct()

◆ addProduct_()

◆ addProductOrThrow()

◆ addScheduledProduct()

◆ addSourceProduct()

◆ addSwitchAliasProduct()

◆ addSwitchProducerProduct()

◆ addUnscheduledProduct()

◆ adjustIndexesAfterProductRegistryAddition()

◆ adjustToNewProductRegistry()

◆ applyToResolvers()

◆ begin() [1/2]

◆ begin() [2/2]

◆ branchType()

◆ cacheIdentifier()

◆ changedIndexes_()

◆ clearPrincipal()

◆ deleteProduct()

◆ end() [1/2]

◆ end() [2/2]

◆ fillPrincipal()

◆ findProductByLabel() [1/2]

◆ findProductByLabel() [2/2]

◆ findProductByTag()

◆ findProducts()

◆ getAllProvenance()

◆ getAllStableProvenance()

◆ getByLabel() [1/2]

◆ getByLabel() [2/2]

◆ getByToken()

◆ getExistingProduct() [1/3]

◆ getExistingProduct() [2/3]

◆ getExistingProduct() [3/3]

◆ getIt()

◆ getManyByType()

◆ getModifiableProductResolver()

◆ getProductResolver()

◆ getProductResolverByIndex()

◆ getProvenance()

◆ getThinnedProduct()

◆ getThinnedProducts()

◆ lookupProcessOrder()

◆ prefetchAsync()

◆ processConfiguration()

◆ processHistory()

◆ processHistoryID()

◆ prodGetter()

◆ productLookup()

◆ productRegistry()

◆ putOrMerge() [1/2]

◆ putOrMerge() [2/2]

◆ readAllFromSourceAndMergeImmediately()

◆ reader()

◆ recombine()

◆ setupUnscheduled()

◆ size()