#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)

const_iterator	begin () const

iterator	begin ()

BranchType const &	branchType () const

CacheIdentifier_t	cacheIdentifier () const

void	clearPrincipal ()

void	deleteProduct (BranchID const &id) const

const_iterator	end () const

iterator	end ()

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	addTransformProduct (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.

References addAliasedProduct(), addDelayedReaderInputProduct(), addParentProcessProduct(), addPutOnReadInputProduct(), addScheduledProduct(), addSourceProduct(), addSwitchAliasProduct(), addSwitchProducerProduct(), addTransformProduct(), 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.

       : 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);
                 if (bd.isTransform()) {
                   addTransformProduct(cbd);
                 } else {
                   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;
       }
     }
   }

◆ ~Principal()

edm::Principal::~Principal ( )

override

Definition at line 302 of file Principal.cc.

302 {}

Member Function Documentation

◆ addAliasedProduct()

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

private

Definition at line 361 of file Principal.cc.

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

Referenced by Principal().

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

◆ addDelayedReaderInputProduct()

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

private

Definition at line 345 of file Principal.cc.

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

Referenced by adjustIndexesAfterProductRegistryAddition(), and Principal().

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

◆ addParentProcessProduct()

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

private

Definition at line 385 of file Principal.cc.

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

Referenced by Principal().

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

◆ addProduct_()

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

protected

Definition at line 537 of file Principal.cc.

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

Referenced by addProductOrThrow().

                                                                                 {
     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;
   }

◆ addProductOrThrow()

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

protected

Definition at line 550 of file Principal.cc.

References addProduct_(), Exception, getExistingProduct(), edm::errors::InsertFailure, and eostools::move().

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

                                                                                       {
     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));
   }

◆ addPutOnReadInputProduct()

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

private

Definition at line 349 of file Principal.cc.

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

Referenced by adjustIndexesAfterProductRegistryAddition(), and Principal().

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

◆ addScheduledProduct()

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

private

Definition at line 335 of file Principal.cc.

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

Referenced by Principal().

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

◆ addSourceProduct()

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

private

Definition at line 340 of file Principal.cc.

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

Referenced by Principal().

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

◆ addSwitchAliasProduct()

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

private

Definition at line 377 of file Principal.cc.

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

Referenced by Principal().

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

◆ addSwitchProducerProduct()

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

private

Definition at line 369 of file Principal.cc.

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

Referenced by Principal().

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

◆ addTransformProduct()

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

private

Definition at line 357 of file Principal.cc.

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

Referenced by Principal().

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

◆ addUnscheduledProduct()

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

private

Definition at line 353 of file Principal.cc.

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

Referenced by Principal().

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

◆ adjustIndexesAfterProductRegistryAddition()

void edm::Principal::adjustIndexesAfterProductRegistryAddition ( )

Definition at line 975 of file Principal.cc.

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

                                                             {
     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());
   }

◆ adjustToNewProductRegistry()

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

Definition at line 319 of file Principal.cc.

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

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

                                                                        {
     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;
   }

◆ applyToResolvers()

template<typename F >

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

inlineprotected

Definition at line 217 of file Principal.h.

References productResolvers_.

Referenced by setupUnscheduled().

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

◆ begin() [1/2]

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

inline

Definition at line 160 of file Principal.h.

References productResolvers_.

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

◆ begin() [2/2]

iterator edm::Principal::begin ( void )

inline

Definition at line 167 of file Principal.h.

References productResolvers_.

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

◆ branchType()

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

inline

Definition at line 181 of file Principal.h.

References branchType_.

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

181 { return branchType_; }

edm::Principal::branchType_

BranchType branchType_

Definition: Principal.h:294

◆ cacheIdentifier()

CacheIdentifier_t edm::Principal::cacheIdentifier ( ) const

inline

Definition at line 185 of file Principal.h.

References cacheIdentifier_.

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

185 { return cacheIdentifier_; }

edm::Principal::cacheIdentifier_

CacheIdentifier_t cacheIdentifier_

Definition: Principal.h:301

◆ changedIndexes_()

virtual void edm::Principal::changedIndexes_ ( )

inlineprivatevirtual

Reimplemented in edm::EventPrincipal.

Definition at line 225 of file Principal.h.

Referenced by adjustIndexesAfterProductRegistryAddition().

225 {}

◆ clearPrincipal()

void edm::Principal::clearPrincipal ( )

Definition at line 390 of file Principal.cc.

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_().

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

◆ deleteProduct()

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

Definition at line 400 of file Principal.cc.

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

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

◆ end() [1/2]

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

inline

Definition at line 163 of file Principal.h.

References productResolvers_.

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

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

◆ end() [2/2]

iterator edm::Principal::end ( void )

inline

Definition at line 170 of file Principal.h.

References productResolvers_.

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

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

◆ fillPrincipal() [1/3]

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

Definition at line 410 of file Principal.cc.

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

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

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

◆ fillPrincipal() [2/3]

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

Definition at line 419 of file Principal.cc.

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(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_;
     }
   }

◆ fillPrincipal() [3/3]

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

Definition at line 496 of file Principal.cc.

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

                                                                                           {
     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();
       }
     }
   }

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

References edm::appendCurrentProcessIfAlias(), branchType(), OfflineOutput_cfi::consumer, edm::ProductResolverIndexHelper::index(), SimL1EmulatorRepack_Full_cff::inputTag, B2GTnPMonitor_cfi::item, edm::InputTag::kCurrentProcess, or, preg_, 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().

                                                                                           {
     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) {
         // can occur because of missing consumes if nothing else in the process consumes the product
         for (auto const& item : preg_->productList()) {
           auto const& bd = item.second;
           if (bd.present() and bd.unwrappedTypeID() == typeID and bd.moduleLabel() == inputTag.label() and
               bd.productInstanceName() == inputTag.instance()) {
             bool const inCurrentProcess = bd.processName() == processConfiguration_->processName();
             if (inputTag.process().empty() or bd.processName() == inputTag.process() or
                 (skipCurrentProcess and not inCurrentProcess) or
                 (inputTag.process() == InputTag::kCurrentProcess and inCurrentProcess)) {
               failedToRegisterConsumes(
                   kindOfType,
                   typeID,
                   inputTag.label(),
                   inputTag.instance(),
                   appendCurrentProcessIfAlias(inputTag.process(), processConfiguration_->processName()));
             }
           }
         }
         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();
   }

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

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

                                                                                           {
     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) {
       // can occur because of missing consumes if nothing else in the process consumes the product
       for (auto const& item : preg_->productList()) {
         auto const& bd = item.second;
         if (bd.present() and bd.unwrappedTypeID() == typeID and bd.moduleLabel() == label and
             bd.productInstanceName() == instance) {
           if (process.empty() or bd.processName() == process) {
             failedToRegisterConsumes(kindOfType, typeID, label, instance, process);
           }
         }
       }
       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();
   }

◆ findProductByTag()

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

Definition at line 863 of file Principal.cc.

References cms::cuda::assert(), branchType_, findProductByLabel(), edm::InProcess, edm::PRODUCT_TYPE, and makeGlobalPositionRcd_cfg::tag.

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

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

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

Referenced by getManyByType().

                                                                       {
     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()));
           }
         }
       }
     }
   }

◆ getAllProvenance()

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

Definition at line 898 of file Principal.cc.

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

                                                                                   {
     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());
         }
       }
     }
   }

◆ getAllStableProvenance()

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

Definition at line 915 of file Principal.cc.

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

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

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

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_().

                                                                            {
     // 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()));
   }

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

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

                                                                            {
     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()));
   }

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

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

Referenced by edm::EventForTransformer::get(), and edm::PrincipalGetAdapter::getByToken_().

                                                                            {
     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()));
   }

◆ getExistingProduct() [1/3]

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

protected

Definition at line 509 of file Principal.cc.

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

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

◆ getExistingProduct() [2/3]

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

protected

Definition at line 513 of file Principal.cc.

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

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

◆ getExistingProduct() [3/3]

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

protected

Definition at line 519 of file Principal.cc.

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

                                                                                                            {
     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;
   }

◆ getIt()

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

overrideprivatevirtual

Implements edm::EDProductGetter.

Definition at line 937 of file Principal.cc.

References cms::cuda::assert().

                                                             {
     assert(false);
     return nullptr;
   }

◆ getManyByType()

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

Definition at line 657 of file Principal.cc.

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_().

                                                                        {
     // 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;
   }

◆ getModifiableProductResolver()

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

inline

Definition at line 153 of file Principal.h.

References getProductResolver().

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

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

◆ getProductResolver()

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

Definition at line 562 of file Principal.cc.

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

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

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

◆ getProductResolverByIndex()

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

Definition at line 570 of file Principal.cc.

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

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

◆ getProvenance()

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

Definition at line 873 of file Principal.cc.

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

                                                                       {
     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();
   }

◆ getStableProvenance()

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

Definition at line 886 of file Principal.cc.

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

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

                                                                                   {
     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();
   }

◆ getThinnedKeyFrom()

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

overrideprivatevirtual

Implements edm::EDProductGetter.

Definition at line 954 of file Principal.cc.

References cms::cuda::assert().

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

◆ getThinnedProduct()

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

overrideprivatevirtual

Implements edm::EDProductGetter.

Definition at line 942 of file Principal.cc.

References cms::cuda::assert().

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

◆ getThinnedProducts()

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

overrideprivatevirtual

Implements edm::EDProductGetter.

Definition at line 948 of file Principal.cc.

References cms::cuda::assert().

                                                                      {
     assert(false);
   }

◆ lookupProcessOrder()

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

inline

Definition at line 197 of file Principal.h.

References lookupProcessOrder_.

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

197 { return lookupProcessOrder_; }

edm::Principal::lookupProcessOrder_

std::vector< unsigned int > lookupProcessOrder_

Definition: Principal.h:287

◆ prefetchAsync()

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

Definition at line 647 of file Principal.cc.

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

Referenced by edm::Worker::doTransformAsync(), edm::EDLooperBase::edPrefetchAsync(), edm::Worker::edPrefetchAsync(), and edm::Worker::prePrefetchSelectionAsync().

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

◆ processBlockIndex()

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

virtual

Reimplemented in edm::EventPrincipal.

Definition at line 575 of file Principal.cc.

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

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

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

◆ processConfiguration()

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

inline

Definition at line 144 of file Principal.h.

References processConfiguration_.

144 { return *processConfiguration_; }

edm::Principal::processConfiguration_

ProcessConfiguration const * processConfiguration_

Definition: Principal.h:277

◆ processHistory()

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

inline

Definition at line 140 of file Principal.h.

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

140 { return *processHistoryPtr_; }

edm::Principal::processHistoryPtr_

std::shared_ptr< ProcessHistory const > processHistoryPtr_

Definition: Principal.h:272

◆ processHistoryID()

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

inline

Definition at line 142 of file Principal.h.

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

142 { return processHistoryID_; }

edm::Principal::processHistoryID_

ProcessHistoryID processHistoryID_

Definition: Principal.h:274

◆ prodGetter()

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

inline

Definition at line 92 of file Principal.h.

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

92 { return this; }

◆ productLookup()

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

inline

Definition at line 148 of file Principal.h.

References productLookup_.

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

148 { return *productLookup_; }

edm::Principal::productLookup_

std::shared_ptr< ProductResolverIndexHelper const > productLookup_

Definition: Principal.h:285

◆ productRegistry()

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

inline

Definition at line 146 of file Principal.h.

References preg_.

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

146 { return *preg_; }

edm::Principal::preg_

std::shared_ptr< ProductRegistry const > preg_

Definition: Principal.h:284

◆ put_() [1/2]

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

protected

Definition at line 963 of file Principal.cc.

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

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

                                                                                         {
     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);
   }

◆ put_() [2/2]

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

private

Definition at line 959 of file Principal.cc.

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

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

◆ readAllFromSourceAndMergeImmediately()

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

Definition at line 1004 of file Principal.cc.

References dumpMFGeometry_cfg::prod, and reader().

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

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

◆ reader()

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

inline

◆ recombine()

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

Definition at line 926 of file Principal.cc.

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_().

                                                                              {
     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());
   }

◆ setupUnscheduled()

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

Definition at line 406 of file Principal.cc.

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

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

◆ size()

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

Definition at line 307 of file Principal.cc.

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

                                {
     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;
   }

Member Data Documentation

◆ branchType_

BranchType edm::Principal::branchType_

private

Definition at line 294 of file Principal.h.

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

◆ cacheIdentifier_

CacheIdentifier_t edm::Principal::cacheIdentifier_

private

Definition at line 301 of file Principal.h.

Referenced by cacheIdentifier(), and fillPrincipal().

◆ historyAppender_

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

private

Definition at line 299 of file Principal.h.

Referenced by fillPrincipal().

◆ lookupProcessOrder_

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

private

Definition at line 287 of file Principal.h.

Referenced by fillPrincipal(), and lookupProcessOrder().

◆ orderProcessHistoryID_

ProcessHistoryID edm::Principal::orderProcessHistoryID_

private

Definition at line 288 of file Principal.h.

Referenced by fillPrincipal().

◆ preg_

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

private

Definition at line 284 of file Principal.h.

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

◆ processConfiguration_

ProcessConfiguration const* edm::Principal::processConfiguration_

private

Definition at line 277 of file Principal.h.

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

◆ processHistoryID_

ProcessHistoryID edm::Principal::processHistoryID_

private

Definition at line 274 of file Principal.h.

Referenced by fillPrincipal(), and processHistoryID().

◆ processHistoryIDBeforeConfig_

ProcessHistoryID edm::Principal::processHistoryIDBeforeConfig_

private

Definition at line 275 of file Principal.h.

Referenced by fillPrincipal().

◆ processHistoryPtr_

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

private

Definition at line 272 of file Principal.h.

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

◆ productLookup_

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

private

Definition at line 285 of file Principal.h.

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

◆ productResolvers_

ProductResolverCollection edm::Principal::productResolvers_

private

Definition at line 280 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 292 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()

◆ addTransformProduct()

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