#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 (ProcessHistoryID const &hist, ProcessHistoryRegistry const &phr, DelayedReader *reader)

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

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

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

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

BasicHandle	getByLabel (KindOfType kindOfType, TypeID const &typeID, std::string const &label, std::string const &instance, std::string const &process, EDConsumerBase const consumes, SharedResourcesAcquirer sra, ModuleCallingContext const *mcc) const

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

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

ProductResolverBase *	getModifiableProductResolver (BranchID const &oid)

ConstProductResolverPtr	getProductResolver (BranchID const &oid) const

ConstProductResolverPtr	getProductResolverByIndex (ProductResolverIndex const &oid) const

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

bool	isComplete () const

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

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

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

ProcessConfiguration const &	processConfiguration () const

ProcessHistory const &	processHistory () const

ProcessHistoryID const &	processHistoryID () const

EDProductGetter const *	prodGetter () const

ProductResolverIndexHelper const &	productLookup () const

ProductRegistry const &	productRegistry () const

void	readAllFromSourceAndMergeImmediately ()

DelayedReader *	reader () const

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

void	resetFailedFromThisProcess ()

size_t	size () const

virtual	~Principal ()

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

	EDProductGetter (EDProductGetter const &)=delete

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

unsigned int	transitionIndex () const

virtual	~EDProductGetter ()

Protected Member Functions
void	addProduct_ (std::unique_ptr< ProductResolverBase > phb)

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

template<typename F >
void	applyToResolvers (F iFunc)

ProductResolverBase *	getExistingProduct (BranchID const &branchID)

ProductResolverBase const *	getExistingProduct (BranchID const &branchID) const

ProductResolverBase const *	getExistingProduct (ProductResolverBase const &phb) const

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

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

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

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

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

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

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

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

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

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

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

virtual bool	isComplete_ () const

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

Private Attributes
BranchType	branchType_

CacheIdentifier_t	cacheIdentifier_

edm::propagate_const< HistoryAppender * >	historyAppender_

std::vector< unsigned int >	lookupProcessOrder_

ProcessHistoryID	orderProcessHistoryID_

std::shared_ptr< ProductRegistry const >	preg_

ProcessConfiguration const *	processConfiguration_

ProcessHistoryID	processHistoryID_

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

References addAliasedProduct(), addInputProduct(), addParentProcessProduct(), addScheduledProduct(), addSourceProduct(), addUnscheduledProduct(), 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(), gen::k, edm::BranchDescription::moduleLabel(), edm::BranchDescription::onDemand(), or, LaserDQM_cfg::process, edm::ProcessConfiguration::processName(), edm::BranchDescription::processName(), parseEventContent::prod, edm::BranchDescription::produced(), productLookup_, edm::ProductResolverIndexAmbiguous, edm::ProductResolverIndexInvalid, productResolvers_, diffTwoXMLs::ranges, edm::source(), edm::ProductResolverIndexHelper::IndexAndNames::startInProcessNames(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                  :
     EDProductGetter(),
     processHistoryPtr_(),
     processHistoryID_(),
     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;
     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 {
             auto cbd = std::make_shared<BranchDescription const>(bd);
             if(bd.produced()) {
               if(bd.moduleLabel() == source) {
                 addSourceProduct(cbd);
               } else if(bd.onDemand()) {
                 assert(branchType_ == InEvent);
                 addUnscheduledProduct(cbd);
               } else {
                 addScheduledProduct(cbd);
               }
             } else {
               addInputProduct(cbd);
             }
           }
         } else {
           //We are in a SubProcess and this branch is from the parent
           auto cbd =std::make_shared<BranchDescription const>(bd);
           addParentProcessProduct(cbd);
         }
       }
     }
     // Now process any EDAliases
     if(hasAliases) {
       for(auto const& prod : prodsList) {
         BranchDescription const& bd = prod.second;
         if(bd.isAlias() && bd.branchType() == branchType_) {
           auto cbd = std::make_shared<BranchDescription const>(bd);
           addAliasedProduct(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 {
                 std::shared_ptr<ProductResolverBase> newHolder = std::make_shared<NoProcessProductResolver>(matchingHolders, ambiguous);
                 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;
             }
           }
         }
       }
       std::shared_ptr<ProductResolverBase> newHolder = std::make_shared<NoProcessProductResolver>(matchingHolders, ambiguous);
       productResolvers_.at(productResolverIndex) = newHolder;
     }
   }

edm::Principal::~Principal ( )

virtual

Definition at line 224 of file Principal.cc.

224 {

225 }

Member Function Documentation

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

private

Definition at line 285 of file Principal.cc.

References addProductOrThrow(), diffTreeTool::index, 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<ProducedProductResolver&>(*productResolvers_[index])));
   }

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

private

Definition at line 275 of file Principal.cc.

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

Referenced by adjustIndexesAfterProductRegistryAddition(), and Principal().

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

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

private

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

References edm::BranchDescription::branchID(), edm::BranchDescription::className(), edm::BranchDescription::friendlyClassName(), diffTreeTool::index, 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 416 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(), addInputProduct(), addParentProcessProduct(), addScheduledProduct(), addSourceProduct(), 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::addScheduledProduct ( std::shared_ptr< BranchDescription const > bd )

private

Definition at line 263 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 269 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::addUnscheduledProduct ( std::shared_ptr< BranchDescription const > bd )

private

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

References addInputProduct(), edm::BranchDescription::branchID(), edm::BranchDescription::branchType(), branchType_, diffTreeTool::index, preg_, parseEventContent::prod, edm::BranchDescription::produced(), edm::ProductResolverIndexInvalid, and productResolvers_.

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

                                                        {
     if(preg_->getNextIndexValue(branchType_) != productResolvers_.size()) {
       productResolvers_.resize(preg_->getNextIndexValue(branchType_));
       for(auto const& prod : preg_->productList()) {
         BranchDescription const& bd = prod.second;
         if(bd.branchType() == branchType_) {
           ProductResolverIndex index = preg_->indexFrom(bd.branchID());
           assert(index != ProductResolverIndexInvalid);
           if(!productResolvers_[index]) {
             // no product holder.  Must add one. The new entry must be an input product holder.
             assert(!bd.produced());
             auto cbd = std::make_shared<BranchDescription const>(bd);
             addInputProduct(cbd);
           }
         }
       }
     }
     assert(preg_->getNextIndexValue(branchType_) == productResolvers_.size());
   }

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

Definition at line 246 of file Principal.cc.

References edm::BranchDescription::branchType(), branchType_, getExistingProduct(), parseEventContent::prod, 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 211 of file Principal.h.

References edm::getThinnedProduct(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by edm::EventPrincipal::setupUnscheduled().

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

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

inline

Definition at line 159 of file Principal.h.

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

edm::Principal::productResolvers_

ProductResolverCollection productResolvers_

Definition: Principal.h:266

iterator edm::Principal::begin ( void )

inline

Definition at line 162 of file Principal.h.

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

edm::Principal::productResolvers_

ProductResolverCollection productResolvers_

Definition: Principal.h:266

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

inline

Definition at line 172 of file Principal.h.

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

172 {return branchType_;}

edm::Principal::branchType_

BranchType branchType_

Definition: Principal.h:280

CacheIdentifier_t edm::Principal::cacheIdentifier ( ) const

inline

Definition at line 176 of file Principal.h.

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

176 {return cacheIdentifier_;}

edm::Principal::cacheIdentifier_

CacheIdentifier_t cacheIdentifier_

Definition: Principal.h:287

void edm::Principal::clearPrincipal ( )

Definition at line 299 of file Principal.cc.

References processHistoryID_, processHistoryPtr_, parseEventContent::prod, and reader_.

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

                             {
     processHistoryPtr_.reset();
     processHistoryID_ = ProcessHistoryID();
     reader_ = nullptr;
     for(auto& prod : *this) {
       prod->resetProductData();
     }
   }

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

Definition at line 309 of file Principal.cc.

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

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

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

edm::Principal::productResolvers_

ProductResolverCollection productResolvers_

Definition: Principal.h:266

iterator edm::Principal::end ( void )

inline

Definition at line 163 of file Principal.h.

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

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

edm::Principal::productResolvers_

ProductResolverCollection productResolvers_

Definition: Principal.h:266

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

Definition at line 317 of file Principal.cc.

References cacheIdentifier_, Exception, spr::find(), edm::ProcessHistoryRegistry::getMapped(), create_public_lumi_plots::hist, historyAppender_, edm::Hash< I >::isValid(), gen::k, edm::errors::LogicError, lookupProcessOrder_, edm::nextIdentifier(), orderProcessHistoryID_, processConfiguration_, processHistoryID_, processHistoryPtr_, productLookup_, productRegistry(), reader(), reader_, and edm::s_emptyProcessHistory.

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

                                                   {
     //increment identifier here since clearPrincipal isn't called for Run/Lumi
     cacheIdentifier_=nextIdentifier();
     if(reader) {
       reader_ = reader;
     }
 
     if (historyAppender_ && productRegistry().anyProductProduced()) {
       processHistoryPtr_ =
         historyAppender_->appendToProcessHistory(hist,
                                                  processHistoryRegistry.getMapped(hist),
                                                  *processConfiguration_);
       processHistoryID_ = processHistoryPtr_->id();
     }
     else {
       std::shared_ptr<ProcessHistory const> inputProcessHistory;
       if (hist.isValid()) {
         //does not own the pointer
         auto noDel =[](void const*){};
         inputProcessHistory =
         std::shared_ptr<ProcessHistory const>(processHistoryRegistry.getMapped(hist),noDel);
         if (inputProcessHistory.get() == nullptr) {
           throw Exception(errors::LogicError)
             << "Principal::fillPrincipal\n"
             << "Input ProcessHistory not found in registry\n"
             << "Contact a Framework developer\n";
         }
       } else {
         //Since this is static we don't want it deleted
         inputProcessHistory = std::shared_ptr<ProcessHistory const>(&s_emptyProcessHistory,[](void const*){});
       }
       processHistoryID_ = hist;
       processHistoryPtr_ = inputProcessHistory;        
     }
 
     if (orderProcessHistoryID_ != processHistoryID_) {
       std::vector<std::string> const& lookupProcessNames = productLookup_->lookupProcessNames();
       lookupProcessOrder_.assign(lookupProcessNames.size(), 0);
       unsigned int k = 0;
       for (auto iter = processHistoryPtr_->rbegin(),
                 iEnd = processHistoryPtr_->rend();
            iter != iEnd; ++iter) {
         auto nameIter = std::find(lookupProcessNames.begin(), lookupProcessNames.end(), iter->processName());
         if (nameIter == lookupProcessNames.end()) {
           continue;
         }
         lookupProcessOrder_.at(k) = nameIter - lookupProcessNames.begin();
         ++k;
       }
       orderProcessHistoryID_ = processHistoryID_;
     }
   }

ProductData const * edm::Principal::findProductByLabel	(	KindOfType	kindOfType,
		TypeID const &	typeID,
		InputTag const &	inputTag,
		EDConsumerBase const *	consumer,
		SharedResourcesAcquirer *	sra,
		ModuleCallingContext const *	mcc
	)		const

private

Definition at line 619 of file Principal.cc.

References branchType(), edm::ProductResolverIndexHelper::index(), diffTreeTool::index, edm::InputTag::indexFor(), edm::InputTag::instance(), edm::InputTag::label(), edm::InputTag::process(), modifiedElectrons_cfi::processName, productLookup(), productRegistry(), edm::ProductResolverIndexAmbiguous, edm::ProductResolverIndexInvalid, productResolvers_, edm::EDConsumerBase::registeredToConsume(), ctppsDiamondLocalTracks_cfi::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";
       }
 
       index = productLookup().index(kindOfType,
                                     typeID,
                                     inputTag.label().c_str(),
                                     inputTag.instance().c_str(),
                                     processName);
 
       if(index == ProductResolverIndexAmbiguous) {
         throwAmbiguousException("findProductByLabel", typeID, inputTag.label(), inputTag.instance(), inputTag.process());
       } else if (index == ProductResolverIndexInvalid) {
         return 0;
       }
       inputTag.tryToCacheIndex(index, typeID, branchType(), &productRegistry());
     }
     if(unlikely( consumer and (not consumer->registeredToConsume(index, skipCurrentProcess, branchType())))) {
       failedToRegisterConsumes(kindOfType,typeID,inputTag.label(),inputTag.instance(),inputTag.process());
     }
 
     
     auto const& productResolver = productResolvers_[index];
 
     auto resolution = productResolver->resolveProduct(*this, skipCurrentProcess, sra, mcc);
     if(resolution.isAmbiguous()) {
       throwAmbiguousException("findProductByLabel", typeID, inputTag.label(), inputTag.instance(), inputTag.process());
     }
     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 665 of file Principal.cc.

References branchType(), edm::ProductResolverIndexHelper::index(), diffTreeTool::index, productLookup(), edm::ProductResolverIndexAmbiguous, edm::ProductResolverIndexInvalid, productResolvers_, edm::EDConsumerBase::registeredToConsume(), ctppsDiamondLocalTracks_cfi::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 0;
     }
     
     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 700 of file Principal.cc.

References findProductByLabel(), and edm::PRODUCT_TYPE.

Referenced by edm::getProductByTag().

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

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

private

Definition at line 589 of file Principal.cc.

References edm::BranchDescription::isAlias(), 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.isAlias()) {
             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 731 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().isAlias()) {
         // We do not attempt to get the event/lumi/run status from the provenance,
         // because the per event provenance may have been dropped.
         if(productResolver->provenance()->branchDescription().present()) {
            provenances.push_back(productResolver->provenance());
         }
       }
     }
   }

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

Definition at line 748 of file Principal.cc.

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

                                                                                          {
     provenances.clear();
     for(auto const& productResolver : *this) {
       if(productResolver->singleProduct() && !productResolver->branchDescription().isAlias()) {
         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 449 of file Principal.cc.

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

Referenced by edm::PrincipalGetAdapter::getByLabel_(), and edm::PrincipalGetAdapter::getMatchingSequenceByLabel_().

                                                                {
 
     ProductData const* result = findProductByLabel(kindOfType, typeID, inputTag, consumer, sra, mcc);
     if(result == 0) {
       return BasicHandle(makeHandleExceptionFactory([=]()->std::shared_ptr<cms::Exception> {
         return makeNotFoundException("getByLabel", kindOfType, typeID, inputTag.label(), inputTag.instance(), inputTag.process());
       }));
     }
     return BasicHandle(result->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 466 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 == 0) {
       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 485 of file Principal.cc.

References diffTreeTool::index, edm::ProductResolverIndexInvalid, productResolvers_, and ctppsDiamondLocalTracks_cfi::resolution.

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

                                                                {
     assert(index !=ProductResolverIndexInvalid);
     auto& productResolver = productResolvers_[index];
     assert(0!=productResolver.get());
     auto resolution = productResolver->resolveProduct(*this, skipCurrentProcess, sra, mcc);
     if(resolution.isAmbiguous()) {
       ambiguous = true;
       return BasicHandle();
     }
     auto productData = resolution.data();
     if(productData == nullptr) {
       return BasicHandle();
     }
     return BasicHandle(productData->wrapper(), &(productData->provenance()));
   }

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

protected

Definition at line 373 of file Principal.cc.

Referenced by addProductOrThrow(), adjustToNewProductRegistry(), deleteProduct(), getExistingProduct(), edm::EventPrincipal::put(), edm::EventPrincipal::putOnRead(), and 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 378 of file Principal.cc.

References diffTreeTool::index, 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 385 of file Principal.cc.

References edm::ProductResolverBase::branchDescription(), edm::BranchDescription::branchID(), edm::BranchDescription::branchName(), Exception, 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.

Reimplemented in edm::EventPrincipal.

Definition at line 772 of file Principal.cc.

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

References branchType(), findProducts(), mps_fire::i, edm::ProductResolverIndexHelper::Matches::index(), diffTreeTool::index, edm::ProductResolverIndexHelper::Matches::isFullyResolved(), patRefSel_triggerMatching_cfi::matches, edm::ProductResolverIndexHelper::Matches::numberOfMatches(), edm::PRODUCT_TYPE, productLookup(), productResolvers_, edm::EDConsumerBase::registeredToConsumeMany(), edm::ProductResolverIndexHelper::relatedIndexes(), and unlikely.

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

                                                                   {
 
     assert(results.empty());
 
     if(unlikely(consumer and (not consumer->registeredToConsumeMany(typeID,branchType())))) {
       failedToRegisterConsumesMany(typeID);
     }
 
     // This finds the indexes to all the 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 152 of file Principal.h.

References findQualityFiles::size.

Referenced by 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 433 of file Principal.cc.

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

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

References diffTreeTool::index, and productResolvers_.

Referenced by edm::NoProcessProductResolver::dataValidFromResolver(), edm::PrincipalGetAdapter::getBranchDescription(), getProductResolver(), edm::SingleChoiceNoProcessProductResolver::prefetchAsync_(), edm::SingleChoiceNoProcessProductResolver::resolveProduct_(), edm::NoProcessProductResolver::tryPrefetchResolverAsync(), and edm::NoProcessProductResolver::tryResolver().

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

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

Definition at line 712 of file Principal.cc.

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

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

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

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

overrideprivatevirtual

Implements edm::EDProductGetter.

Reimplemented in edm::EventPrincipal.

Definition at line 778 of file Principal.cc.

                                                                     {
     assert(false);
     return nullptr;
   }

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

overrideprivatevirtual

Implements edm::EDProductGetter.

Reimplemented in edm::EventPrincipal.

Definition at line 784 of file Principal.cc.

                                                                   {
     assert(false);
   }

bool edm::Principal::isComplete ( ) const

inline

Definition at line 194 of file Principal.h.

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

194 {return isComplete_();}

edm::Principal::isComplete_

virtual bool isComplete_() const

Definition: Principal.h:255

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

inlineprivatevirtual

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

Definition at line 255 of file Principal.h.

References parseEventContent::prod.

255 {return true;}

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

inline

Definition at line 190 of file Principal.h.

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

190 { return lookupProcessOrder_; }

edm::Principal::lookupProcessOrder_

std::vector< unsigned int > lookupProcessOrder_

Definition: Principal.h:273

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

Definition at line 508 of file Principal.cc.

References productResolvers_.

Referenced by edm::Worker::prefetchAsync().

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

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

inline

Definition at line 143 of file Principal.h.

143 {return *processConfiguration_;}

edm::Principal::processConfiguration_

ProcessConfiguration const * processConfiguration_

Definition: Principal.h:263

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

inline

Definition at line 135 of file Principal.h.

Referenced by edm::SubProcess::beginLuminosityBlock(), edm::SubProcess::beginRun(), edm::EventPrincipal::fillEventPrincipal(), edm::LuminosityBlockPrincipal::fillLuminosityBlockPrincipal(), edm::RunPrincipal::fillRunPrincipal(), edm::SubProcess::processAsync(), and edm::PrincipalGetAdapter::processHistory().

                                                  {
       return *processHistoryPtr_;
     }

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

inline

Definition at line 139 of file Principal.h.

Referenced by edm::SubProcess::beginLuminosityBlock(), edm::SubProcess::beginRun(), edm::EventPrincipal::fillEventPrincipal(), 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 88 of file Principal.h.

References diffTreeTool::index, HiClusterCompatibility_cfi::inputTag, instance, diffTwoXMLs::label, LaserDQM_cfg::process, mps_update::results, and AlCaHLTBitMon_QueryRunRegistry::string.

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

88 {return this;}

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

inline

Definition at line 147 of file Principal.h.

References trackingPlots::other.

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

147 {return *productLookup_;}

edm::Principal::productLookup_

std::shared_ptr< ProductResolverIndexHelper const > productLookup_

Definition: Principal.h:271

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

inline

Definition at line 145 of file Principal.h.

Referenced by fillPrincipal(), findProductByLabel(), edm::PrincipalGetAdapter::getBranchDescription(), and edm::SubProcess::processAsync().

145 {return *preg_;}

edm::Principal::preg_

std::shared_ptr< ProductRegistry const > preg_

Definition: Principal.h:270

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

protected

Definition at line 796 of file Principal.cc.

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

Referenced by edm::RunPrincipal::put(), and edm::LuminosityBlockPrincipal::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
     putOrMerge(std::move(edp), phb);
   }

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

private

Definition at line 791 of file Principal.cc.

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

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

void edm::Principal::readAllFromSourceAndMergeImmediately ( )

Definition at line 831 of file Principal.cc.

References parseEventContent::prod, and reader().

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

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

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

inline

Definition at line 178 of file Principal.h.

References GlobalPosition_Frontier_DevDB_cff::tag.

Referenced by edm::SubProcess::beginLuminosityBlock(), edm::SubProcess::beginRun(), edm::EventPrincipal::fillEventPrincipal(), edm::LuminosityBlockPrincipal::fillLuminosityBlockPrincipal(), fillPrincipal(), edm::RunPrincipal::fillRunPrincipal(), edm::SubProcess::processAsync(), readAllFromSourceAndMergeImmediately(), recombine(), edm::InputProductResolver::retrieveAndMerge_(), edm::EventPrincipal::~EventPrincipal(), edm::LuminosityBlockPrincipal::~LuminosityBlockPrincipal(), and edm::RunPrincipal::~RunPrincipal().

178 {return reader_;}

edm::Principal::reader_

DelayedReader * reader_

Definition: Principal.h:278

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

Definition at line 760 of file Principal.cc.

References edm::get_underlying_safe(), diffTreeTool::index, edm::DelayedReader::mergeReaders(), preg_, parseEventContent::prod, 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::resetFailedFromThisProcess ( )

Definition at line 840 of file Principal.cc.

References parseEventContent::prod.

                                         {
     for( auto & prod : *this) {
       prod->resetFailedFromThisProcess();
     }
   }

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

Definition at line 231 of file Principal.cc.

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

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