#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 (DelayedReader *reader)

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

void	fillPrincipal (std::string const &processNameOfBlock, 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 const &	getProvenance (BranchID const &bid) const

StableProvenance const &	getStableProvenance (BranchID const &bid) const

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

void	prefetchAsync (WaitingTaskHolder 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)

virtual unsigned int	processBlockIndex (std::string const &processName) const

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	put_ (BranchDescription const &bd, std::unique_ptr< WrapperBase > edp) const

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

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

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

void	addPutOnReadInputProduct (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

OptionalThinnedKey	getThinnedKeyFrom (ProductID const &parent, unsigned int key, ProductID const &thinned) const override

std::optional< std::tuple< WrapperBase const *, unsigned int > >	getThinnedProduct (ProductID const &, unsigned int) const override

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

void	put_ (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 56 of file Principal.h.

Member Typedef Documentation

◆ BasicHandleVec

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

Definition at line 63 of file Principal.h.

◆ CacheIdentifier_t

typedef unsigned long edm::Principal::CacheIdentifier_t

Definition at line 184 of file Principal.h.

◆ const_iterator

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

Definition at line 59 of file Principal.h.

◆ ConstProductResolverPtr

typedef ProductResolverBase const* edm::Principal::ConstProductResolverPtr

Definition at line 62 of file Principal.h.

◆ iterator

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

Definition at line 60 of file Principal.h.

◆ ProcessName

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

Definition at line 67 of file Principal.h.

◆ ProcessNameConstIterator

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

Definition at line 61 of file Principal.h.

◆ ProductResolverCollection

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

Definition at line 58 of file Principal.h.

◆ SharedProductPtr

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

Definition at line 66 of file Principal.h.

◆ size_type

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

Definition at line 64 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 122 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 {
               if (bd.onDemand()) {
                 addDelayedReaderInputProduct(cbd);
               } else {
                 addPutOnReadInputProduct(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(), addDelayedReaderInputProduct(), addParentProcessProduct(), addPutOnReadInputProduct(), addScheduledProduct(), addSourceProduct(), addSwitchAliasProduct(), addSwitchProducerProduct(), addUnscheduledProduct(), cms::cuda::assert(), branchType_, spr::find(), mps_fire::i, edm::ProductResolverIndexHelper::IndexAndNames::index(), edm::InEvent, dqmiolumiharvest::j, dqmdumpme::k, or, LaserDQM_cfg::process, edm::ProcessConfiguration::processName(), dumpMFGeometry_cfg::prod, 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 298 of file Principal.cc.

298 {}

Member Function Documentation

◆ addAliasedProduct()

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

private

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

◆ addDelayedReaderInputProduct()

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

private

Definition at line 341 of file Principal.cc.

                                                                                         {
     addProductOrThrow(std::make_unique<DelayedReaderInputProductResolver>(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 377 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 529 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(), preg_, edm::ProductResolverIndexInvalid, and productResolvers_.

Referenced by addProductOrThrow().

◆ addProductOrThrow()

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

protected

Definition at line 542 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, getExistingProduct(), edm::errors::InsertFailure, and eostools::move().

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

◆ addPutOnReadInputProduct()

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

private

Definition at line 345 of file Principal.cc.

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

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

Referenced by adjustIndexesAfterProductRegistryAddition(), and Principal().

◆ addScheduledProduct()

void edm::Principal::addScheduledProduct ( 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().

◆ addSourceProduct()

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

private

Definition at line 336 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 369 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 361 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 349 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 939 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);
             if (bd.onDemand()) {
               addDelayedReaderInputProduct(cbd);
             } else {
               addPutOnReadInputProduct(cbd);
             }
             changed = true;
           }
         }
       }
       if (changed) {
         changedIndexes_();
       }
     }
     assert(preg_->getNextIndexValue(branchType_) == productResolvers_.size());
   }

References addDelayedReaderInputProduct(), addPutOnReadInputProduct(), cms::cuda::assert(), branchType_, changedIndexes_(), preg_, dumpMFGeometry_cfg::prod, edm::ProductResolverIndexInvalid, and productResolvers_.

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

◆ adjustToNewProductRegistry()

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

Definition at line 315 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 branchType_, getExistingProduct(), dumpMFGeometry_cfg::prod, 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 217 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 167 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 160 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 181 of file Principal.h.

181 { return branchType_; }

References branchType_.

Referenced by edm::PrincipalGetAdapter::branchType(), edm::EDLooperBase::edPrefetchAsync(), edm::Worker::edPrefetchAsync(), findProductByLabel(), getManyByType(), edm::Worker::prefetchAsync(), edm::ParentProcessProductResolver::prefetchAsync_(), edm::DelayedReaderInputProductResolver::resolveProduct_(), and edm::ParentProcessProductResolver::resolveProduct_().

◆ cacheIdentifier()

CacheIdentifier_t edm::Principal::cacheIdentifier ( ) const

inline

Definition at line 185 of file Principal.h.

185 { return cacheIdentifier_; }

References cacheIdentifier_.

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

◆ changedIndexes_()

virtual void edm::Principal::changedIndexes_ ( )

inlineprivatevirtual

Reimplemented in edm::EventPrincipal.

Definition at line 225 of file Principal.h.

225 {}

Referenced by adjustIndexesAfterProductRegistryAddition().

◆ clearPrincipal()

void edm::Principal::clearPrincipal ( )

Definition at line 382 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(), edm::SubProcess::clearProcessBlockPrincipal(), edm::SubProcess::doEndProcessBlockAsync(), edm::EventProcessor::endProcessBlock(), edm::EventProcessor::inputProcessBlocks(), and edm::PoolSource::readEvent_().

◆ deleteProduct()

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

Definition at line 392 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 170 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 163 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() [1/3]

void edm::Principal::fillPrincipal ( DelayedReader * reader )

Definition at line 402 of file Principal.cc.

                                                      {
     //increment identifier here since clearPrincipal isn't called for Run/Lumi
     cacheIdentifier_ = nextIdentifier();
     if (reader) {
       reader_ = reader;
     }
   }

References cacheIdentifier_, edm::nextIdentifier(), reader(), and reader_.

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

◆ fillPrincipal() [2/3]

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

Definition at line 411 of file Principal.cc.

                                                        {
     fillPrincipal(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 Exception, fillPrincipal(), spr::find(), gpuVertexFinder::hist, historyAppender_, dqmdumpme::k, edm::errors::LogicError, lookupProcessOrder_, orderProcessHistoryID_, processConfiguration_, processHistory(), processHistoryID_, processHistoryIDBeforeConfig_, processHistoryPtr_, edm::ProcessConfiguration::processName(), productLookup_, productRegistry(), reader(), and edm::s_emptyProcessHistory.

◆ fillPrincipal() [3/3]

void edm::Principal::fillPrincipal	(	std::string const &	processNameOfBlock,
		DelayedReader *	reader
	)

Definition at line 488 of file Principal.cc.

                                                                                           {
     fillPrincipal(reader);
  
     std::vector<std::string> const& lookupProcessNames = productLookup_->lookupProcessNames();
     lookupProcessOrder_.assign(lookupProcessNames.size(), 0);
     if (!lookupProcessOrder_.empty()) {
       auto iter = std::find(lookupProcessNames.begin(), lookupProcessNames.end(), processNameOfBlock);
       if (iter != lookupProcessNames.end()) {
         lookupProcessOrder_[0] = iter - lookupProcessNames.begin();
       }
     }
   }

References fillPrincipal(), spr::find(), lookupProcessOrder_, productLookup_, and reader().

◆ 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 744 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 797 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 827 of file Principal.cc.

                                                                                         {
     // Not implemented for ProcessBlocks
     assert(branchType_ != InProcess);
  
     ProductData const* productData = findProductByLabel(PRODUCT_TYPE, typeID, tag, nullptr, nullptr, mcc);
     return productData;
   }

References cms::cuda::assert(), branchType_, findProductByLabel(), edm::InProcess, edm::PRODUCT_TYPE, and makeGlobalPositionRcd_cfg::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 719 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 LaserDQM_cfg::process, processHistoryPtr_, 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 862 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 879 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 571 of file Principal.cc.

                                                                            {
     // Not implemented for ProcessBlocks, it might work though, not tested
     // The other getByLabel function is used for ProcessBlocks by TestProcessor
     assert(branchType_ != InProcess);
  
     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(), cms::cuda::assert(), branchType_, OfflineOutput_cfi::consumer, findProductByLabel(), edm::InProcess, SimL1EmulatorRepack_Full_cff::inputTag, edm::makeHandleExceptionFactory(), edm::makeNotFoundException(), processConfiguration_, edm::ProcessConfiguration::processName(), and mps_fire::result.

Referenced by edm::test::ProcessBlock::get(), 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 596 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 613 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 501 of file Principal.cc.

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

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

◆ getExistingProduct() [2/3]

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

protected

Definition at line 505 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 511 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 901 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 649 of file Principal.cc.

                                                                        {
     // Not implemented for ProcessBlocks
     assert(branchType_ != InProcess);
  
     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(), branchType_, OfflineOutput_cfi::consumer, findProducts(), mps_fire::i, edm::InProcess, oniaPATMuonsWithTrigger_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 153 of file Principal.h.

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

References getProductResolver().

Referenced by edm::SubProcess::parentProducedProductIsKept(), and edm::SubProcess::propagateProducts().

◆ getProductResolver()

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

Definition at line 554 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(), getStableProvenance(), edm::EventPrincipal::getThinnedAssociation(), edm::SubProcess::parentProducedProductIsKept(), and edm::SubProcess::propagateProducts().

◆ getProductResolverByIndex()

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

Definition at line 562 of file Principal.cc.

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

References productResolvers_.

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

◆ getProvenance()

Provenance const & edm::Principal::getProvenance ( BranchID const & bid ) const

Definition at line 837 of file Principal.cc.

                                                                       {
     ConstProductResolverPtr const phb = getProductResolver(bid);
     if (phb == nullptr) {
       throwProductNotFoundException("getProvenance", errors::ProductNotFound, bid);
     }
  
     if (phb->unscheduledWasNotRun()) {
       throw edm::Exception(errors::UnimplementedFeature)
           << "Requesting provenance from unrun EDProducer. The requested branch ID was: " << bid;
     }
     return *phb->provenance();
   }

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

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

◆ getStableProvenance()

StableProvenance const & edm::Principal::getStableProvenance ( BranchID const & bid ) const

Definition at line 850 of file Principal.cc.

                                                                                   {
     ConstProductResolverPtr const phb = getProductResolver(bid);
     if (phb == nullptr) {
       throwProductNotFoundException("getStableProvenance", errors::ProductNotFound, bid);
     }
     //NOTE: in all implementations, this never returns a nullptr
     return *phb->stableProvenance();
   }

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

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

◆ getThinnedKeyFrom()

OptionalThinnedKey edm::Principal::getThinnedKeyFrom	(	ProductID const &	parent,
		unsigned int	key,
		ProductID const &	thinned
	)		const

overrideprivatevirtual

Implements edm::EDProductGetter.

Definition at line 918 of file Principal.cc.

                                                                                                         {
     assert(false);
     return std::monostate{};
   }

References cms::cuda::assert().

◆ getThinnedProduct()

std::optional< std::tuple< WrapperBase const *, unsigned int > > edm::Principal::getThinnedProduct	(	ProductID const &	,
		unsigned int
	)		const

overrideprivatevirtual

Implements edm::EDProductGetter.

Definition at line 906 of file Principal.cc.

                                                                                                                {
     assert(false);
     return std::nullopt;
   }

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

                                                                      {
     assert(false);
   }

References cms::cuda::assert().

◆ lookupProcessOrder()

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

inline

Definition at line 197 of file Principal.h.

197 { return lookupProcessOrder_; }

References lookupProcessOrder_.

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

◆ prefetchAsync()

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

Definition at line 639 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::EDLooperBase::edPrefetchAsync(), edm::Worker::edPrefetchAsync(), and edm::Worker::prePrefetchSelectionAsync().

◆ processBlockIndex()

unsigned int edm::Principal::processBlockIndex ( std::string const & processName ) const

virtual

Reimplemented in edm::EventPrincipal.

Definition at line 567 of file Principal.cc.

                                                                   {
     throw Exception(errors::LogicError) << "Principal::processBlockIndex not implemented for this type of Principal";
   }

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

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

◆ processConfiguration()

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

inline

Definition at line 144 of file Principal.h.

144 { return *processConfiguration_; }

References processConfiguration_.

◆ processHistory()

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

inline

Definition at line 140 of file Principal.h.

140 { 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 142 of file Principal.h.

142 { 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 92 of file Principal.h.

92 { return this; }

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

◆ productLookup()

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

inline

Definition at line 148 of file Principal.h.

148 { return *productLookup_; }

References productLookup_.

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

◆ productRegistry()

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

inline

Definition at line 146 of file Principal.h.

146 { return *preg_; }

References preg_.

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

◆ put_() [1/2]

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

protected

Definition at line 927 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
     put_(std::move(edp), phb);
   }

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

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

◆ put_() [2/2]

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

private

Definition at line 923 of file Principal.cc.

                                                                                             {
     dynamic_cast<ProductPutterBase const*>(phb)->putProduct(std::move(prod));
   }

References eostools::move(), and dumpMFGeometry_cfg::prod.

◆ readAllFromSourceAndMergeImmediately()

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

Definition at line 968 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

◆ recombine()

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

Definition at line 890 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 398 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 303 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 293 of file Principal.h.

Referenced by adjustIndexesAfterProductRegistryAddition(), adjustToNewProductRegistry(), branchType(), findProductByTag(), getByLabel(), getManyByType(), and Principal().

◆ cacheIdentifier_

CacheIdentifier_t edm::Principal::cacheIdentifier_

private

Definition at line 300 of file Principal.h.

Referenced by cacheIdentifier(), and fillPrincipal().

◆ historyAppender_

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

private

Definition at line 298 of file Principal.h.

Referenced by fillPrincipal().

◆ lookupProcessOrder_

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

private

Definition at line 286 of file Principal.h.

Referenced by fillPrincipal(), and lookupProcessOrder().

◆ orderProcessHistoryID_

ProcessHistoryID edm::Principal::orderProcessHistoryID_

private

Definition at line 287 of file Principal.h.

Referenced by fillPrincipal().

◆ preg_

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

private

Definition at line 283 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 276 of file Principal.h.

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

◆ processHistoryID_

ProcessHistoryID edm::Principal::processHistoryID_

private

Definition at line 273 of file Principal.h.

Referenced by fillPrincipal(), and processHistoryID().

◆ processHistoryIDBeforeConfig_

ProcessHistoryID edm::Principal::processHistoryIDBeforeConfig_

private

Definition at line 274 of file Principal.h.

Referenced by fillPrincipal().

◆ processHistoryPtr_

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

private

Definition at line 271 of file Principal.h.

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

◆ productLookup_

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

private

Definition at line 284 of file Principal.h.

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

◆ productResolvers_

ProductResolverCollection edm::Principal::productResolvers_

private

Definition at line 279 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 291 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()

◆ addDelayedReaderInputProduct()

◆ addParentProcessProduct()

◆ addProduct_()

◆ addProductOrThrow()

◆ addPutOnReadInputProduct()

◆ 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() [1/3]

◆ fillPrincipal() [2/3]

◆ fillPrincipal() [3/3]

◆ 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()

◆ getStableProvenance()

◆ getThinnedKeyFrom()

◆ getThinnedProduct()

◆ getThinnedProducts()

◆ lookupProcessOrder()

◆ prefetchAsync()

◆ processBlockIndex()

◆ processConfiguration()

◆ processHistory()

◆ processHistoryID()

◆ prodGetter()

◆ productLookup()

◆ productRegistry()

◆ put_() [1/2]