edm::Principal Class Reference

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

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

Definition at line 63 of file Principal.h.

typedef unsigned long edm::Principal::CacheIdentifier_t

Definition at line 184 of file Principal.h.

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

Definition at line 59 of file Principal.h.

typedef ProductResolverBase const* edm::Principal::ConstProductResolverPtr

Definition at line 62 of file Principal.h.

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

Definition at line 60 of file Principal.h.

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

Definition at line 67 of file Principal.h.

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

Definition at line 61 of file Principal.h.

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

Definition at line 58 of file Principal.h.

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

Definition at line 66 of file Principal.h.

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

Definition at line 64 of file Principal.h.

Constructor & Destructor Documentation

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(), addUnscheduledProduct(), cms::cuda::assert(), edm::ProductResolverIndexHelper::Range::begin(), edm::BranchDescription::branchType(), branchType_, edm::ProductResolverIndexHelper::Range::end(), spr::find(), mps_fire::i, edm::ProductResolverIndexHelper::IndexAndNames::index(), edm::InEvent, edm::BranchDescription::isAlias(), edm::BranchDescription::isSwitchAlias(), dqmiolumiharvest::j, isotrackApplyRegressor::k, edm::BranchDescription::moduleLabel(), edm::BranchDescription::onDemand(), or, LaserDQM_cfg::process, edm::ProcessConfiguration::processName(), edm::BranchDescription::processName(), edm::BranchDescription::produced(), productLookup_, edm::ProductResolverIndexAmbiguous, edm::ProductResolverIndexInvalid, productResolvers_, sistrip::SpyUtilities::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);
                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;
      }
    }
  }

edm::Principal::~Principal ( )

override

Definition at line 298 of file Principal.cc.

{}

Member Function Documentation

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

private

Definition at line 353 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])));
  }

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

private

Definition at line 341 of file Principal.cc.

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

Referenced by adjustIndexesAfterProductRegistryAddition(), and Principal().

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

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

private

Definition at line 377 of file Principal.cc.

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

Referenced by Principal().

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

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

protected

Definition at line 529 of file Principal.cc.

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

Referenced by addProductOrThrow().

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

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

protected

Definition at line 542 of file Principal.cc.

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

Referenced by addAliasedProduct(), addDelayedReaderInputProduct(), addParentProcessProduct(), addPutOnReadInputProduct(), addScheduledProduct(), addSourceProduct(), addSwitchAliasProduct(), addSwitchProducerProduct(), 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));
  }

void edm::Principal::addPutOnReadInputProduct ( 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<PutOnReadInputProductResolver>(std::move(bd)));
  }

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

private

Definition at line 331 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));
  }

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

private

Definition at line 336 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));
  }

void edm::Principal::addSwitchAliasProduct ( 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<SwitchAliasProductResolver>(
        std::move(bd), dynamic_cast<DataManagingOrAliasProductResolver&>(*productResolvers_[index])));
  }

void edm::Principal::addSwitchProducerProduct ( 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->switchAliasForBranchID());
    assert(index != ProductResolverIndexInvalid);

    addProductOrThrow(std::make_unique<SwitchProducerProductResolver>(
        std::move(bd), dynamic_cast<DataManagingOrAliasProductResolver&>(*productResolvers_[index])));
  }

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

private

Definition at line 349 of file Principal.cc.

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

Referenced by Principal().

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

void edm::Principal::adjustIndexesAfterProductRegistryAddition

(

)

Definition at line 939 of file Principal.cc.

References addDelayedReaderInputProduct(), addPutOnReadInputProduct(), cms::cuda::assert(), edm::BranchDescription::branchID(), edm::BranchDescription::branchType(), branchType_, changedIndexes_(), edm::BranchDescription::onDemand(), preg_, edm::BranchDescription::produced(), 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());
  }

bool edm::Principal::adjustToNewProductRegistry

(

ProductRegistry const &

reg

)

Definition at line 315 of file Principal.cc.

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

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

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

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

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

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

{ return branchType_; }

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

{ return cacheIdentifier_; }

virtual void edm::Principal::changedIndexes_ ( )

inlineprivatevirtual

Reimplemented in edm::EventPrincipal.

Definition at line 225 of file Principal.h.

Referenced by adjustIndexesAfterProductRegistryAddition().

{}

void edm::Principal::clearPrincipal

(

)

Definition at line 382 of file Principal.cc.

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

void edm::Principal::deleteProduct

(

BranchID const &

id

)

const

Definition at line 392 of file Principal.cc.

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

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

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

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

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

void edm::Principal::fillPrincipal

(

DelayedReader *

reader

)

Definition at line 402 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;
    }
  }

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

Definition at line 411 of file Principal.cc.

References Exception, fillPrincipal(), spr::find(), gpuVertexFinder::hist, historyAppender_, edm::Hash< I >::isValid(), isotrackApplyRegressor::k, edm::errors::LogicError, lookupProcessOrder_, orderProcessHistoryID_, processConfiguration_, processHistory(), processHistoryID_, processHistoryIDBeforeConfig_, processHistoryPtr_, edm::ProcessConfiguration::processName(), productLookup_, productRegistry(), 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_;
    }
  }

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

Definition at line 488 of file Principal.cc.

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

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

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.

References edm::appendCurrentProcessIfAlias(), branchType(), edm::ProductResolverIndexHelper::index(), edm::InputTag::indexFor(), edm::InputTag::instance(), edm::InputTag::kCurrentProcess, edm::InputTag::label(), edm::InputTag::process(), processConfiguration_, edm::ProcessConfiguration::processName(), FSQHLTOfflineSource_cfi::processName, productLookup(), productRegistry(), edm::ProductResolverIndexAmbiguous, edm::ProductResolverIndexInvalid, productResolvers_, edm::EDConsumerBase::registeredToConsume(), dtDQMClient_cfg::resolution, edm::throwAmbiguousException(), edm::InputTag::tryToCacheIndex(), UNLIKELY, and edm::InputTag::willSkipCurrentProcess().

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

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.

References branchType(), edm::ProductResolverIndexHelper::index(), productLookup(), edm::ProductResolverIndexAmbiguous, edm::ProductResolverIndexInvalid, productResolvers_, edm::EDConsumerBase::registeredToConsume(), dtDQMClient_cfg::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) {
      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();
  }

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

Definition at line 827 of file Principal.cc.

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

Referenced by edm::getProductByTag().

                                                                                        {
    // Not implemented for ProcessBlocks
    assert(branchType_ != InProcess);

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

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.

References edm::BranchDescription::isAnyAlias(), LaserDQM_cfg::process, processHistoryPtr_, edm::BranchDescription::processName(), edm::ProductData::provenance(), 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()));
          }
        }
      }
    }
  }

void edm::Principal::getAllProvenance

(

std::vector< Provenance const * > &

provenances

)

const

Definition at line 862 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());
        }
      }
    }
  }

void edm::Principal::getAllStableProvenance

(

std::vector< StableProvenance const * > &

provenances

)

const

Definition at line 879 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());
        }
      }
    }
  }

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.

References edm::appendCurrentProcessIfAlias(), cms::cuda::assert(), branchType_, findProductByLabel(), edm::InProcess, edm::InputTag::instance(), edm::InputTag::label(), edm::makeHandleExceptionFactory(), edm::makeNotFoundException(), edm::InputTag::process(), processConfiguration_, edm::ProcessConfiguration::processName(), edm::ProductData::provenance(), mps_fire::result, and edm::ProductData::wrapper().

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

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.

References findProductByLabel(), edm::makeHandleExceptionFactory(), edm::makeNotFoundException(), edm::ProductData::provenance(), mps_fire::result, and edm::ProductData::wrapper().

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

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.

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

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

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

protected

Definition at line 501 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));
  }

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

protected

Definition at line 505 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();
  }

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

protected

Definition at line 511 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;
  }

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

overrideprivatevirtual

Implements edm::EDProductGetter.

Definition at line 901 of file Principal.cc.

References cms::cuda::assert().

                                                            {
    assert(false);
    return nullptr;
  }

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.

References cms::cuda::assert(), branchType(), branchType_, findProducts(), mps_fire::i, edm::ProductResolverIndexHelper::Matches::index(), edm::InProcess, edm::ProductResolverIndexHelper::Matches::isFullyResolved(), edm::ProductResolverIndexHelper::Matches::numberOfMatches(), edm::PRODUCT_TYPE, productLookup(), productResolvers_, edm::EDConsumerBase::registeredToConsumeMany(), edm::ProductResolverIndexHelper::relatedIndexes(), 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;
  }

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

Principal::ConstProductResolverPtr edm::Principal::getProductResolver

(

BranchID const &

oid

)

const

Definition at line 554 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);
  }

Principal::ConstProductResolverPtr edm::Principal::getProductResolverByIndex

(

ProductResolverIndex const &

oid

)

const

Definition at line 562 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;
  }

Provenance const & edm::Principal::getProvenance

(

BranchID const &

bid

)

const

Definition at line 837 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();
  }

StableProvenance const & edm::Principal::getStableProvenance

(

BranchID const &

bid

)

const

Definition at line 850 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();
  }

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.

References cms::cuda::assert().

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

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.

References cms::cuda::assert().

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

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.

References cms::cuda::assert().

                                                                     {
    assert(false);
  }

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

{ return lookupProcessOrder_; }

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.

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

Referenced by 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);
  }

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

virtual

Reimplemented in edm::EventPrincipal.

Definition at line 567 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 const& edm::Principal::processConfiguration ( ) const

inline

Definition at line 144 of file Principal.h.

References processConfiguration_.

{ return *processConfiguration_; }

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::LuminosityBlockPrincipal::fillLuminosityBlockPrincipal(), fillPrincipal(), edm::SubProcess::processAsync(), and edm::PrincipalGetAdapter::processHistory().

{ return *processHistoryPtr_; }

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

{ return processHistoryID_; }

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

inline

Definition at line 92 of file Principal.h.

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

{ return this; }

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

{ return *productLookup_; }

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

{ return *preg_; }

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

protected

Definition at line 927 of file Principal.cc.

References cms::cuda::assert(), edm::BranchDescription::branchID(), 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);
  }

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

private

Definition at line 923 of file Principal.cc.

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

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

void edm::Principal::readAllFromSourceAndMergeImmediately

(

MergeableRunProductMetadata const *

mergeableRunProductMetadata = nullptr

)

Definition at line 968 of file Principal.cc.

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

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

inline

Definition at line 187 of file Principal.h.

References reader_.

Referenced by edm::RepeatingCachedRootSource::beginJob(), edm::EventPrincipal::commonFillEventPrincipal(), edm::SubProcess::doBeginLuminosityBlockAsync(), edm::SubProcess::doBeginProcessBlockAsync(), edm::SubProcess::doBeginRunAsync(), edm::SubProcess::doEndProcessBlockAsync(), edm::LuminosityBlockPrincipal::fillLuminosityBlockPrincipal(), fillPrincipal(), edm::RunPrincipal::fillRunPrincipal(), edm::SubProcess::processAsync(), readAllFromSourceAndMergeImmediately(), recombine(), and edm::DelayedReaderInputProductResolver::retrieveAndMerge_().

{ return reader_; }

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

Definition at line 890 of file Principal.cc.

References cms::cuda::assert(), edm::get_underlying_safe(), edm::DelayedReader::mergeReaders(), preg_, edm::ProductResolverIndexInvalid, productResolvers_, reader(), 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());
  }

void edm::Principal::setupUnscheduled

(

UnscheduledConfigurator const &

iConfigure

)

Definition at line 398 of file Principal.cc.

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

Referenced by edm::WorkerManager::setupResolvers().

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

size_t edm::Principal::size

(

void

)

const

Definition at line 303 of file Principal.cc.

Referenced by ntupleDataFormat._Collection::__iter__(), ntupleDataFormat._Collection::__len__(), edm::SecSourceAnalyzer::getBranches(), 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 edm::Principal::branchType_

private

Definition at line 293 of file Principal.h.

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

CacheIdentifier_t edm::Principal::cacheIdentifier_

private

Definition at line 300 of file Principal.h.

Referenced by cacheIdentifier(), and fillPrincipal().

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

private

Definition at line 298 of file Principal.h.

Referenced by fillPrincipal().

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

private

Definition at line 286 of file Principal.h.

Referenced by fillPrincipal(), and lookupProcessOrder().

ProcessHistoryID edm::Principal::orderProcessHistoryID_

private

Definition at line 287 of file Principal.h.

Referenced by fillPrincipal().

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 const* edm::Principal::processConfiguration_

private

Definition at line 276 of file Principal.h.

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

ProcessHistoryID edm::Principal::processHistoryID_

private

Definition at line 273 of file Principal.h.

Referenced by fillPrincipal(), and processHistoryID().

ProcessHistoryID edm::Principal::processHistoryIDBeforeConfig_

private

Definition at line 274 of file Principal.h.

Referenced by fillPrincipal().

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

private

Definition at line 271 of file Principal.h.

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

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

private

Definition at line 284 of file Principal.h.

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

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

DelayedReader* edm::Principal::reader_

private

Definition at line 291 of file Principal.h.

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