#include <ProductRegistry.h>

Inheritance diagram for edm::ProductRegistry:

Classes
struct	Transients

Public Types
typedef std::map< BranchKey, BranchDescription const >	ConstProductList

typedef std::map< BranchKey, BranchDescription >	ProductList

Public Member Functions
void	addLabelAlias (BranchDescription const &productdesc, std::string const &labelAlias, std::string const &instanceAlias)

void	addProduct (BranchDescription const &productdesc, bool iFromListener=false)

std::vector< std::string >	aliasToModules (KindOfType kindOfType, TypeID const &type, std::string_view moduleLabel, std::string_view productInstanceName) const

std::vector< BranchDescription const * >	allBranchDescriptions () const

std::vector< std::string >	allBranchNames () const

bool	anyProductProduced () const

bool	anyProducts (BranchType const brType) const

template<typename T >
void	callForEachBranch (T const &iFunc)

void	copyProduct (BranchDescription const &productdesc)

bool	frozen () const

ProductResolverIndex const &	getNextIndexValue (BranchType branchType) const

ProductResolverIndex	indexFrom (BranchID const &iID) const

void	initializeTransients ()

std::string	merge (ProductRegistry const &other, std::string const &fileName, BranchDescription::MatchMode branchesMustMatch=BranchDescription::Permissive)

void	print (std::ostream &os) const

ProductList const &	productList () const

ProductList &	productListUpdator ()

std::shared_ptr< ProductResolverIndexHelper >	productLookup (BranchType branchType)

std::shared_ptr< ProductResolverIndexHelper const >	productLookup (BranchType branchType) const

bool	productProduced (BranchType branchType) const

	ProductRegistry ()

	ProductRegistry (ProductList const &productList, bool toBeFrozen=true)

void	setFrozen (bool initializeLookupInfo=true)

void	setFrozen (std::set< TypeID > const &productTypesConsumed, std::set< TypeID > const &elementTypesConsumed, std::string const &processName)

void	setUnscheduledProducts (std::set< std::string > const &unscheduledLabels)

ProductList::size_type	size () const

void	updateFromInput (ProductList const &other)

void	updateFromInput (std::vector< BranchDescription > const &other)

virtual	~ProductRegistry ()

Private Member Functions
virtual void	addCalled (BranchDescription const &, bool iFromListener)

void	addElementTypesForAliases (std::set< TypeID > const *elementTypesConsumed, std::map< TypeID, TypeID > const &containedTypeMap, std::map< TypeID, std::vector< TypeWithDict >> const &containedTypeToBaseTypesMap)

void	checkDictionariesOfConsumedTypes (std::set< TypeID > const productTypesConsumed, std::set< TypeID > const elementTypesConsumed, std::map< TypeID, TypeID > const &containedTypeMap, std::map< TypeID, std::vector< TypeWithDict >> &containedTypeToBaseTypesMap)

void	checkForDuplicateProcessName (BranchDescription const &desc, std::string const *processName) const

void	freezeIt (bool frozen=true)

void	initializeLookupTables (std::set< TypeID > const productTypesConsumed, std::set< TypeID > const elementTypesConsumed, std::string const *processName)

ProductResolverIndex &	nextIndexValue (BranchType branchType)

void	setProductProduced (BranchType branchType)

void	throwIfFrozen () const

void	throwIfNotFrozen () const

Private Attributes
ProductList	productList_

Transients	transient_

Detailed Description

\original author Stefano ARGIRO \current author Bill Tanenbaum

Date: 19 Jul 2005

Definition at line 37 of file ProductRegistry.h.

Member Typedef Documentation

◆ ConstProductList

typedef std::map<BranchKey, BranchDescription const> edm::ProductRegistry::ConstProductList

Definition at line 50 of file ProductRegistry.h.

◆ ProductList

typedef std::map<BranchKey, BranchDescription> edm::ProductRegistry::ProductList

Definition at line 39 of file ProductRegistry.h.

Constructor & Destructor Documentation

◆ ProductRegistry() [1/2]

edm::ProductRegistry::ProductRegistry ( )

Definition at line 32 of file ProductRegistry.cc.

32 : productList_(), transient_() {}

◆ ProductRegistry() [2/2]

edm::ProductRegistry::ProductRegistry	(	ProductList const &	productList,
		bool	toBeFrozen = `true`
	)

explicit

Definition at line 63 of file ProductRegistry.cc.

       : productList_(productList), transient_() {
     freezeIt(toBeFrozen);
   }

References freezeIt().

◆ ~ProductRegistry()

virtual edm::ProductRegistry::~ProductRegistry ( )

inlinevirtual

Definition at line 48 of file ProductRegistry.h.

48 {}

Member Function Documentation

◆ addCalled()

void edm::ProductRegistry::addCalled	(	BranchDescription const &	,
		bool	iFromListener
	)

privatevirtual

Reimplemented in edm::SignallingProductRegistry.

Definition at line 187 of file ProductRegistry.cc.

187 {}

Referenced by addLabelAlias(), and addProduct().

◆ addElementTypesForAliases()

void edm::ProductRegistry::addElementTypesForAliases	(	std::set< TypeID > const *	elementTypesConsumed,
		std::map< TypeID, TypeID > const &	containedTypeMap,
		std::map< TypeID, std::vector< TypeWithDict >> const &	containedTypeToBaseTypesMap
	)

private

Definition at line 465 of file ProductRegistry.cc.

                                                                                   {
     Transients::AliasToOriginalVector elementAliases;
     for (auto& item : transient_.aliasToOriginal_) {
       auto iterContainedType = containedTypeMap.find(std::get<Transients::kType>(item));
       if (iterContainedType == containedTypeMap.end()) {
         edm::Exception ex(errors::LogicError);
         ex << "containedTypeMap did not contain " << std::get<Transients::kType>(item).className()
            << " that is used in EDAlias " << std::get<Transients::kModuleLabel>(item)
            << ".\nThis should not happen, contact framework developers";
         ex.addContext("Calling ProductRegistry::initializeLookupTables()");
         throw ex;
       }
       auto const& containedTypeID = iterContainedType->second;
       bool const hasContainedType = (containedTypeID != TypeID(typeid(void)) && containedTypeID != TypeID());
       if (not hasContainedType) {
         continue;
       }
  
       if (elementTypesConsumed->find(containedTypeID) != elementTypesConsumed->end()) {
         elementAliases.emplace_back(ELEMENT_TYPE,
                                     containedTypeID,
                                     std::get<Transients::kModuleLabel>(item),
                                     std::get<Transients::kProductInstanceName>(item),
                                     std::get<Transients::kAliasForModuleLabel>(item));
       }
  
       auto iterBaseTypes = containedTypeToBaseTypesMap.find(containedTypeID);
       if (iterBaseTypes == containedTypeToBaseTypesMap.end()) {
         continue;
       }
       for (TypeWithDict const& baseType : iterBaseTypes->second) {
         TypeID baseTypeID(baseType.typeInfo());
         if (elementTypesConsumed->find(baseTypeID) != elementTypesConsumed->end()) {
           elementAliases.emplace_back(ELEMENT_TYPE,
                                       baseTypeID,
                                       std::get<Transients::kModuleLabel>(item),
                                       std::get<Transients::kProductInstanceName>(item),
                                       std::get<Transients::kAliasForModuleLabel>(item));
         }
       }
     }
     transient_.aliasToOriginal_.insert(transient_.aliasToOriginal_.end(),
                                        std::make_move_iterator(elementAliases.begin()),
                                        std::make_move_iterator(elementAliases.end()));
   }

References cms::Exception::addContext(), edm::ProductRegistry::Transients::aliasToOriginal_, edm::ELEMENT_TYPE, B2GTnPMonitor_cfi::item, edm::errors::LogicError, transient_, and edm::TypeWithDict::typeInfo().

Referenced by initializeLookupTables().

◆ addLabelAlias()

void edm::ProductRegistry::addLabelAlias	(	BranchDescription const &	productdesc,
		std::string const &	labelAlias,
		std::string const &	instanceAlias
	)

Definition at line 108 of file ProductRegistry.cc.

                                                                       {
     assert(productDesc.produced());
     assert(productDesc.branchID().isValid());
     throwIfFrozen();
     BranchDescription bd(productDesc, labelAlias, instanceAlias);
     std::pair<ProductList::iterator, bool> ret = productList_.insert(std::make_pair(BranchKey(bd), bd));
     assert(ret.second);
     transient_.aliasToOriginal_.emplace_back(
         PRODUCT_TYPE, productDesc.unwrappedTypeID(), labelAlias, instanceAlias, productDesc.moduleLabel());
     addCalled(bd, false);
   }

References addCalled(), edm::ProductRegistry::Transients::aliasToOriginal_, cms::cuda::assert(), edm::BranchDescription::branchID(), edm::BranchID::isValid(), edm::BranchDescription::moduleLabel(), edm::BranchDescription::produced(), edm::PRODUCT_TYPE, productList_, runTheMatrix::ret, throwIfFrozen(), transient_, and edm::BranchDescription::unwrappedTypeID().

◆ addProduct()

void edm::ProductRegistry::addProduct	(	BranchDescription const &	productdesc,
		bool	iFromListener = `false`
	)

Definition at line 68 of file ProductRegistry.cc.

                                                                                           {
     assert(productDesc.produced());
     throwIfFrozen();
     std::pair<ProductList::iterator, bool> ret =
         productList_.insert(std::make_pair(BranchKey(productDesc), productDesc));
     if (!ret.second) {
       auto const& previous = *productList_.find(BranchKey(productDesc));
       if (previous.second.produced()) {
         // Duplicate registration in current process
         throw Exception(errors::LogicError, "Duplicate Product Identifier")
             << "\nThe Framework requires a unique branch name for each product\n"
             << "which consists of four parts: a friendly class name, module label,\n"
             << "product instance name, and process name. A product has been\n"
             << "registered with a duplicate branch name. The most common way\n"
             << "to fix this error is to modify the product instance name in\n"
             << "one of the offending 'produces' function calls. Another fix\n"
             << "would be to delete one of them if they are for the same product.\n\n"
             << "    friendly class name = " << previous.second.friendlyClassName() << "\n"
             << "    module label = " << previous.second.moduleLabel() << "\n"
             << "    product instance name = " << previous.second.productInstanceName() << "\n"
             << "    process name = " << previous.second.processName() << "\n\n"
             << "The following additional information is not used as part of\n"
             << "the unique branch identifier.\n\n"
             << "    branch types = " << previous.second.branchType() << "  " << productDesc.branchType() << "\n"
             << "    class name = " << previous.second.fullClassName() << "\n\n"
             << "Note that if the four parts of the branch name are the same,\n"
             << "then this error will occur even if the branch types differ!\n\n";
       } else {
         // Duplicate registration in previous process
         throw Exception(errors::Configuration, "Duplicate Process Name.\n")
             << "The process name " << productDesc.processName() << " was previously used for products in the input.\n"
             << "This has caused branch name conflicts between input products and new products.\n"
             << "Please modify the configuration file to use a distinct process name.\n"
             << "Alternately, drop all input products using that process name and the\n"
             << "descendants of those products.\n";
       }
     }
     addCalled(productDesc, fromListener);
   }

References addCalled(), cms::cuda::assert(), edm::BranchDescription::branchType(), edm::errors::Configuration, Exception, edm::errors::LogicError, callgraph::previous, edm::BranchDescription::processName(), edm::BranchDescription::produced(), productList_, runTheMatrix::ret, and throwIfFrozen().

Referenced by edm::ProductRegistryHelper::addToRegistry().

◆ aliasToModules()

std::vector< std::string > edm::ProductRegistry::aliasToModules	(	KindOfType	kindOfType,
		TypeID const &	type,
		std::string_view	moduleLabel,
		std::string_view	productInstanceName
	)		const

Definition at line 613 of file ProductRegistry.cc.

                                                                                                      {
     auto aliasFields = [](auto const& item) {
       return std::tie(std::get<Transients::kKind>(item),
                       std::get<Transients::kType>(item),
                       std::get<Transients::kModuleLabel>(item),
                       std::get<Transients::kProductInstanceName>(item));
     };
     auto const target = std::tuple(kindOfType, type, moduleLabel, productInstanceName);
     auto found =
         std::lower_bound(transient_.aliasToOriginal_.begin(),
                          transient_.aliasToOriginal_.end(),
                          target,
                          [aliasFields](auto const& item, auto const& target) { return aliasFields(item) < target; });
     std::vector<std::string> ret;
     for (; found != transient_.aliasToOriginal_.end() and aliasFields(*found) == target; ++found) {
       ret.emplace_back(std::get<Transients::kAliasForModuleLabel>(*found));
     }
     return ret;
   }

References edm::ProductRegistry::Transients::aliasToOriginal_, newFWLiteAna::found, B2GTnPMonitor_cfi::item, pfDeepBoostedJetPreprocessParams_cfi::lower_bound, HerwigMaxPtPartonFilter_cfi::moduleLabel, runTheMatrix::ret, filterCSVwithJSON::target, and transient_.

◆ allBranchDescriptions()

std::vector< BranchDescription const * > edm::ProductRegistry::allBranchDescriptions ( ) const

Definition at line 199 of file ProductRegistry.cc.

                                                                                    {
     std::vector<BranchDescription const*> result;
     result.reserve(productList().size());
  
     for (auto const& product : productList()) {
       result.push_back(&product.second);
     }
     return result;
   }

References productList(), mps_fire::result, and size().

Referenced by edm::RootFile::dropOnInput(), edm::SubProcess::selectProducts(), edm::global::OutputModuleBase::selectProducts(), edm::limited::OutputModuleBase::selectProducts(), edm::one::OutputModuleBase::selectProducts(), and edm::PrincipalGetAdapter::throwUnregisteredPutException().

◆ allBranchNames()

std::vector< std::string > edm::ProductRegistry::allBranchNames ( ) const

Definition at line 189 of file ProductRegistry.cc.

                                                              {
     std::vector<std::string> result;
     result.reserve(productList().size());
  
     for (auto const& product : productList()) {
       result.push_back(product.second.branchName());
     }
     return result;
   }

References productList(), mps_fire::result, and size().

◆ anyProductProduced()

bool edm::ProductRegistry::anyProductProduced ( ) const

inline

Definition at line 122 of file ProductRegistry.h.

122 { return transient_.anyProductProduced_; }

References edm::ProductRegistry::Transients::anyProductProduced_, and transient_.

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

◆ anyProducts()

bool edm::ProductRegistry::anyProducts ( BranchType const brType ) const

Definition at line 135 of file ProductRegistry.cc.

                                                            {
     throwIfNotFrozen();
     for (ProductList::const_iterator it = productList_.begin(), itEnd = productList_.end(); it != itEnd; ++it) {
       if (it->second.branchType() == brType) {
         return true;
       }
     }
     return false;
   }

References productList_, and throwIfNotFrozen().

◆ callForEachBranch()

template<typename T >

void edm::ProductRegistry::callForEachBranch ( T const & iFunc )

inline

Definition at line 100 of file ProductRegistry.h.

                                            {
       //NOTE: If implementation changes from a map, need to check that iterators are still valid
       // after an insert with the new container, else need to copy the container and iterate over the copy
       for (ProductRegistry::ProductList::const_iterator itEntry = productList_.begin(), itEntryEnd = productList_.end();
            itEntry != itEntryEnd;
            ++itEntry) {
         iFunc(itEntry->second);
       }
     }

References productList_.

Referenced by edm::ProducerBase::registerProducts(), edm::stream::EDAnalyzerBase::registerProductsAndCallbacks(), edm::EDAnalyzer::registerProductsAndCallbacks(), edm::one::EDAnalyzerBase::registerProductsAndCallbacks(), edm::global::EDAnalyzerBase::registerProductsAndCallbacks(), and edm::limited::EDAnalyzerBase::registerProductsAndCallbacks().

◆ checkDictionariesOfConsumedTypes()

void edm::ProductRegistry::checkDictionariesOfConsumedTypes	(	std::set< TypeID > const *	productTypesConsumed,
		std::set< TypeID > const *	elementTypesConsumed,
		std::map< TypeID, TypeID > const &	containedTypeMap,
		std::map< TypeID, std::vector< TypeWithDict >> &	containedTypeToBaseTypesMap
	)

private

Definition at line 514 of file ProductRegistry.cc.

                                                                             {
     std::vector<std::string> missingDictionaries;
     std::set<std::string> consumedTypesWithMissingDictionaries;
  
     if (productTypesConsumed) {
       // Check dictionaries for all classes declared to be consumed
       for (auto const& consumedTypeID : *productTypesConsumed) {
         // We use the containedTypeMap to see which types have already
         // had their dictionaries checked. We do not waste time rechecking
         // those dictionaries.
         if (containedTypeMap.find(consumedTypeID) == containedTypeMap.end()) {
           std::string wrappedName = wrappedClassName(consumedTypeID.className());
           TypeWithDict wrappedType = TypeWithDict::byName(wrappedName);
           if (!checkDictionary(missingDictionaries, wrappedName, wrappedType)) {
             checkDictionary(missingDictionaries, consumedTypeID);
             consumedTypesWithMissingDictionaries.emplace(consumedTypeID.className());
             continue;
           }
           bool transient = false;
           TDictAttributeMap* wp = wrappedType.getClass()->GetAttributeMap();
           if (wp && wp->HasKey("persistent") && !strcmp(wp->GetPropertyAsString("persistent"), "false")) {
             transient = true;
           }
           if (transient) {
             if (!checkDictionary(missingDictionaries, consumedTypeID)) {
               consumedTypesWithMissingDictionaries.emplace(consumedTypeID.className());
             }
  
             TypeID containedTypeID = productholderindexhelper::getContainedTypeFromWrapper(
                 TypeID(wrappedType.typeInfo()), consumedTypeID.className());
             bool hasContainedType = (containedTypeID != TypeID(typeid(void)) && containedTypeID != TypeID());
             if (hasContainedType) {
               if (containedTypeToBaseTypesMap.find(containedTypeID) == containedTypeToBaseTypesMap.end()) {
                 std::vector<TypeWithDict> bases;
                 // Run this to check for missing dictionaries, bases is not really used
                 if (!public_base_classes(missingDictionaries, containedTypeID, bases)) {
                   consumedTypesWithMissingDictionaries.emplace(consumedTypeID.className());
                 }
                 containedTypeToBaseTypesMap.insert(std::make_pair(containedTypeID, bases));
               }
             }
           } else {
             if (!checkClassDictionaries(missingDictionaries, wrappedName, wrappedType)) {
               consumedTypesWithMissingDictionaries.emplace(consumedTypeID.className());
             }
           }
         }
       }
       if (!missingDictionaries.empty()) {
         std::string context(
             "Calling ProductRegistry::initializeLookupTables, checking dictionaries for consumed products");
         throwMissingDictionariesException(missingDictionaries, context, consumedTypesWithMissingDictionaries, false);
       }
     }
  
     if (elementTypesConsumed) {
       missingDictionaries.clear();
       consumedTypesWithMissingDictionaries.clear();
       for (auto const& consumedTypeID : *elementTypesConsumed) {
         if (containedTypeToBaseTypesMap.find(consumedTypeID) == containedTypeToBaseTypesMap.end()) {
           std::vector<TypeWithDict> bases;
           // Run this to check for missing dictionaries, bases is not really used
           if (!public_base_classes(missingDictionaries, consumedTypeID, bases)) {
             consumedTypesWithMissingDictionaries.emplace(consumedTypeID.className());
           }
         }
       }
       if (!missingDictionaries.empty()) {
         std::string context(
             "Calling ProductRegistry::initializeLookupTables, checking dictionaries for elements of products consumed "
             "using View");
         throwMissingDictionariesException(missingDictionaries, context, consumedTypesWithMissingDictionaries, true);
       }
     }
   }

References edm::TypeWithDict::byName(), edm::checkClassDictionaries(), edm::checkDictionary(), edm::TypeID::className(), edm::productholderindexhelper::getContainedTypeFromWrapper(), edm::public_base_classes(), AlCaHLTBitMon_QueryRunRegistry::string, edm::throwMissingDictionariesException(), pfClustersFromHGC3DClusters_cfi::wp, and edm::wrappedClassName().

Referenced by initializeLookupTables().

◆ checkForDuplicateProcessName()

void edm::ProductRegistry::checkForDuplicateProcessName	(	BranchDescription const &	desc,
		std::string const *	processName
	)		const

private

Definition at line 594 of file ProductRegistry.cc.

                                                                                          {
     if (processName && !desc.produced() && (*processName == desc.processName())) {
       throw Exception(errors::Configuration, "Duplicate Process Name.\n")
           << "The process name " << *processName << " was previously used for products in the input.\n"
           << "Please modify the configuration file to use a distinct process name.\n"
           << "Alternately, drop all input products using that process name and the\n"
           << "descendants of those products.\n";
     }
   }

References edm::errors::Configuration, submitPVResolutionJobs::desc, Exception, and SimL1EmulatorRepack_CalouGT_cff::processName.

Referenced by initializeLookupTables().

◆ copyProduct()

void edm::ProductRegistry::copyProduct ( BranchDescription const & productdesc )

Definition at line 122 of file ProductRegistry.cc.

                                                                         {
     assert(!productDesc.produced());
     throwIfFrozen();
     BranchKey k = BranchKey(productDesc);
     ProductList::iterator iter = productList_.find(k);
     if (iter == productList_.end()) {
       productList_.insert(std::make_pair(k, productDesc));
     } else {
       assert(combinable(iter->second, productDesc));
       iter->second.merge(productDesc);
     }
   }

References cms::cuda::assert(), edm::combinable(), dqmdumpme::k, edm::BranchDescription::produced(), productList_, and throwIfFrozen().

Referenced by edm::DaqProvenanceHelper::daqInit(), edm::LHEProvenanceHelper::LHEProvenanceHelper(), edm::RootFile::RootFile(), and updateFromInput().

◆ freezeIt()

void edm::ProductRegistry::freezeIt ( bool frozen = true )

inlineprivate

Definition at line 168 of file ProductRegistry.h.

168 { transient_.frozen_ = frozen; }

References frozen(), edm::ProductRegistry::Transients::frozen_, and transient_.

Referenced by ProductRegistry(), and setFrozen().

◆ frozen()

bool edm::ProductRegistry::frozen ( ) const

inline

Definition at line 140 of file ProductRegistry.h.

140 { return transient_.frozen_; }

References edm::ProductRegistry::Transients::frozen_, and transient_.

Referenced by freezeIt(), edm::StreamerInputSource::mergeIntoRegistry(), setFrozen(), throwIfFrozen(), and throwIfNotFrozen().

◆ getNextIndexValue()

ProductResolverIndex const & edm::ProductRegistry::getNextIndexValue ( BranchType branchType ) const

Definition at line 642 of file ProductRegistry.cc.

                                                                                             {
     return transient_.nextIndexValues_[branchType];
   }

References edm::ProductRegistry::Transients::nextIndexValues_, and transient_.

Referenced by initializeLookupTables(), and merge().

◆ indexFrom()

ProductResolverIndex edm::ProductRegistry::indexFrom ( BranchID const & iID ) const

Definition at line 605 of file ProductRegistry.cc.

                                                                            {
     std::map<BranchID, ProductResolverIndex>::const_iterator itFind = transient_.branchIDToIndex_.find(iID);
     if (itFind == transient_.branchIDToIndex_.end()) {
       return ProductResolverIndexInvalid;
     }
     return itFind->second;
   }

References edm::ProductRegistry::Transients::branchIDToIndex_, edm::ProductResolverIndexInvalid, and transient_.

◆ initializeLookupTables()

void edm::ProductRegistry::initializeLookupTables	(	std::set< TypeID > const *	productTypesConsumed,
		std::set< TypeID > const *	elementTypesConsumed,
		std::string const *	processName
	)

private

Definition at line 295 of file ProductRegistry.cc.

                                                                              {
     std::map<TypeID, TypeID> containedTypeMap;
     std::map<TypeID, std::vector<TypeWithDict>> containedTypeToBaseTypesMap;
  
     std::vector<std::string> missingDictionaries;
     std::vector<std::string> branchNamesForMissing;
     std::vector<std::string> producedTypes;
  
     transient_.branchIDToIndex_.clear();
  
     for (auto const& product : productList_) {
       auto const& desc = product.second;
  
       checkForDuplicateProcessName(desc, processName);
  
       if (desc.produced() && !desc.transient()) {
         setProductProduced(desc.branchType());
       }
  
       //only do the following if the data is supposed to be available in the event
       if (desc.present()) {
         // Check dictionaries (we already checked for the produced ones earlier somewhere else).
         // We have to have the dictionaries to properly setup the lookup tables for support of
         // Views. Also we need them to determine which present products are declared to be
         // consumed in the case where the consumed type is a View<T>.
         if (!desc.produced()) {
           if (!checkDictionary(missingDictionaries, desc.className(), desc.unwrappedType())) {
             checkDictionaryOfWrappedType(missingDictionaries, desc.className());
             branchNamesForMissing.emplace_back(desc.branchName());
             producedTypes.emplace_back(desc.className() + std::string(" (read from input)"));
             continue;
           }
         }
         TypeID typeID(desc.unwrappedType().typeInfo());
  
         auto iterContainedType = containedTypeMap.find(typeID);
         bool alreadySawThisType = (iterContainedType != containedTypeMap.end());
  
         if (!desc.produced() && !alreadySawThisType) {
           if (!checkDictionary(missingDictionaries, desc.wrappedName(), desc.wrappedType())) {
             branchNamesForMissing.emplace_back(desc.branchName());
             producedTypes.emplace_back(desc.className() + std::string(" (read from input)"));
             continue;
           }
         }
  
         TypeID wrappedTypeID(desc.wrappedType().typeInfo());
  
         TypeID containedTypeID;
         if (alreadySawThisType) {
           containedTypeID = iterContainedType->second;
         } else {
           containedTypeID = productholderindexhelper::getContainedTypeFromWrapper(wrappedTypeID, typeID.className());
         }
         bool hasContainedType = (containedTypeID != TypeID(typeid(void)) && containedTypeID != TypeID());
  
         std::vector<TypeWithDict>* baseTypesOfContainedType = nullptr;
  
         if (!alreadySawThisType) {
           bool alreadyCheckedConstituents = desc.produced() && !desc.transient();
           if (!alreadyCheckedConstituents && !desc.transient()) {
             // This checks dictionaries of the wrapped class and all its constituent classes
             if (!checkClassDictionaries(missingDictionaries, desc.wrappedName(), desc.wrappedType())) {
               branchNamesForMissing.emplace_back(desc.branchName());
               producedTypes.emplace_back(desc.className() + std::string(" (read from input)"));
               continue;
             }
           }
  
           if (hasContainedType) {
             auto iterBaseTypes = containedTypeToBaseTypesMap.find(containedTypeID);
             if (iterBaseTypes == containedTypeToBaseTypesMap.end()) {
               std::vector<TypeWithDict> baseTypes;
               if (!public_base_classes(missingDictionaries, containedTypeID, baseTypes)) {
                 branchNamesForMissing.emplace_back(desc.branchName());
                 if (desc.produced()) {
                   producedTypes.emplace_back(desc.className() + std::string(" (produced in current process)"));
                 } else {
                   producedTypes.emplace_back(desc.className() + std::string(" (read from input)"));
                 }
                 continue;
               }
               iterBaseTypes = containedTypeToBaseTypesMap.insert(std::make_pair(containedTypeID, baseTypes)).first;
             }
             baseTypesOfContainedType = &iterBaseTypes->second;
           }
  
           // Do this after the dictionary checks of constituents so the list of branch names for missing types
           // is complete
           containedTypeMap.emplace(typeID, containedTypeID);
         } else {
           if (hasContainedType) {
             auto iterBaseTypes = containedTypeToBaseTypesMap.find(containedTypeID);
             if (iterBaseTypes != containedTypeToBaseTypesMap.end()) {
               baseTypesOfContainedType = &iterBaseTypes->second;
             }
           }
         }
  
         if (productTypesConsumed != nullptr && !desc.produced()) {
           bool mainTypeConsumed = (productTypesConsumed->find(typeID) != productTypesConsumed->end());
           bool containedTypeConsumed =
               hasContainedType && (elementTypesConsumed->find(containedTypeID) != elementTypesConsumed->end());
           if (hasContainedType && !containedTypeConsumed && baseTypesOfContainedType != nullptr) {
             for (TypeWithDict const& baseType : *baseTypesOfContainedType) {
               if (elementTypesConsumed->find(TypeID(baseType.typeInfo())) != elementTypesConsumed->end()) {
                 containedTypeConsumed = true;
                 break;
               }
             }
           }
           if (!containedTypeConsumed) {
             if (mainTypeConsumed) {
               // The main type is consumed, but either
               // there is no contained type, or if there is,
               // neither it nor any of its base classes are consumed.
               // Set the contained type, if there is one, to void,
               if (hasContainedType) {
                 containedTypeID = TypeID(typeid(void));
               }
             } else {
               // The main type is not consumed, and either
               // there is no contained type, or if there is,
               // neither it nor any of its base classes are consumed.
               // Don't insert anything in the lookup tables.
               continue;
             }
           }
         }
         ProductResolverIndex index = productLookup(desc.branchType())
                                          ->insert(typeID,
                                                   desc.moduleLabel().c_str(),
                                                   desc.productInstanceName().c_str(),
                                                   desc.processName().c_str(),
                                                   containedTypeID,
                                                   baseTypesOfContainedType);
  
         transient_.branchIDToIndex_[desc.branchID()] = index;
       }
     }
     if (!missingDictionaries.empty()) {
       std::string context("Calling ProductRegistry::initializeLookupTables");
       throwMissingDictionariesException(missingDictionaries, context, producedTypes, branchNamesForMissing);
     }
  
     for (auto& iterProductLookup : transient_.productLookups_) {
       iterProductLookup->setFrozen();
     }
  
     unsigned int indexIntoNextIndexValue = 0;
     for (auto const& iterProductLookup : transient_.productLookups_) {
       transient_.nextIndexValues_[indexIntoNextIndexValue] = iterProductLookup->nextIndexValue();
       ++indexIntoNextIndexValue;
     }
  
     for (auto const& product : productList_) {
       auto const& desc = product.second;
       if (transient_.branchIDToIndex_.find(desc.branchID()) == transient_.branchIDToIndex_.end()) {
         transient_.branchIDToIndex_[desc.branchID()] = getNextIndexValue(desc.branchType());
         ++nextIndexValue(desc.branchType());
       }
     }
     checkDictionariesOfConsumedTypes(
         productTypesConsumed, elementTypesConsumed, containedTypeMap, containedTypeToBaseTypesMap);
  
     addElementTypesForAliases(elementTypesConsumed, containedTypeMap, containedTypeToBaseTypesMap);
   }

References addElementTypesForAliases(), edm::ProductRegistry::Transients::branchIDToIndex_, edm::checkClassDictionaries(), checkDictionariesOfConsumedTypes(), edm::checkDictionary(), edm::checkDictionaryOfWrappedType(), checkForDuplicateProcessName(), submitPVResolutionJobs::desc, edm::productholderindexhelper::getContainedTypeFromWrapper(), getNextIndexValue(), edm::eventsetup::heterocontainer::insert(), nextIndexValue(), edm::ProductRegistry::Transients::nextIndexValues_, SimL1EmulatorRepack_CalouGT_cff::processName, productList_, productLookup(), edm::ProductRegistry::Transients::productLookups_, edm::public_base_classes(), setProductProduced(), AlCaHLTBitMon_QueryRunRegistry::string, edm::throwMissingDictionariesException(), and transient_.

Referenced by setFrozen().

◆ initializeTransients()

void edm::ProductRegistry::initializeTransients ( )

inline

Definition at line 138 of file ProductRegistry.h.

138 { transient_.reset(); }

References edm::ProductRegistry::Transients::reset(), and transient_.

◆ merge()

std::string edm::ProductRegistry::merge	(	ProductRegistry const &	other,
		std::string const &	fileName,
		BranchDescription::MatchMode	branchesMustMatch = `BranchDescription::Permissive`
	)

Definition at line 250 of file ProductRegistry.cc.

                                                                                    {
     std::ostringstream differences;
  
     ProductRegistry::ProductList::iterator j = productList_.begin();
     ProductRegistry::ProductList::iterator s = productList_.end();
     ProductRegistry::ProductList::const_iterator i = other.productList().begin();
     ProductRegistry::ProductList::const_iterator e = other.productList().end();
  
     // Loop over entries in the main product registry.
     while (j != s || i != e) {
       if (j != s && j->second.produced()) {
         // Ignore branches just produced (i.e. not in input file).
         ++j;
       } else if (j == s || (i != e && i->first < j->first)) {
         if (i->second.present()) {
           differences << "Branch '" << i->second.branchName() << "' is in file '" << fileName << "'\n";
           differences << "    but not in previous files.\n";
         } else {
           productList_.insert(*i);
           transient_.branchIDToIndex_[i->second.branchID()] = getNextIndexValue(i->second.branchType());
           ++nextIndexValue(i->second.branchType());
         }
         ++i;
       } else if (i == e || (j != s && j->first < i->first)) {
         if (j->second.present() && branchesMustMatch == BranchDescription::Strict) {
           differences << "Branch '" << j->second.branchName() << "' is in previous files\n";
           differences << "    but not in file '" << fileName << "'.\n";
         }
         ++j;
       } else {
         std::string difs = match(j->second, i->second, fileName);
         if (difs.empty()) {
           j->second.merge(i->second);
         } else {
           differences << difs;
         }
         ++i;
         ++j;
       }
     }
     return differences.str();
   }

References edm::ProductRegistry::Transients::branchIDToIndex_, MillePedeFileConverter_cfg::e, MillePedeFileConverter_cfg::fileName, getNextIndexValue(), mps_fire::i, dqmiolumiharvest::j, edm::match(), nextIndexValue(), trackingPlots::other, productList_, alignCSCRings::s, edm::BranchDescription::Strict, AlCaHLTBitMon_QueryRunRegistry::string, and transient_.

Referenced by edm::StreamerInputSource::mergeIntoRegistry(), edm::RootPrimaryFileSequence::nextFile(), and edm::RootPrimaryFileSequence::previousFile().

◆ nextIndexValue()

ProductResolverIndex & edm::ProductRegistry::nextIndexValue ( BranchType branchType )

private

Definition at line 646 of file ProductRegistry.cc.

                                                                              {
     return transient_.nextIndexValues_[branchType];
   }

References edm::ProductRegistry::Transients::nextIndexValues_, and transient_.

Referenced by initializeLookupTables(), and merge().

◆ print()

void edm::ProductRegistry::print ( std::ostream & os ) const

Definition at line 636 of file ProductRegistry.cc.

                                                   {
     for (auto const& product : productList_) {
       os << product.second << "\n-----\n";
     }
   }

References productList_.

◆ productList()

ProductList const& edm::ProductRegistry::productList ( ) const

inline

Definition at line 76 of file ProductRegistry.h.

                                            {
       //throwIfNotFrozen();
       return productList_;
     }

References productList_.

Referenced by edm::Principal::adjustToNewProductRegistry(), allBranchDescriptions(), allBranchNames(), edm::ProductSelector::fillDroppedToKept(), edm::ThinningProducer< Collection, Selector >::registerThinnedAssociations(), edm::RootFile::RootFile(), edm::SubProcess::selectProducts(), edm::global::OutputModuleBase::selectProducts(), edm::limited::OutputModuleBase::selectProducts(), edm::one::OutputModuleBase::selectProducts(), edm::MergeableRunProductProcesses::setProcessesWithMergeableRunProducts(), edm::ProductProvenanceRetriever::setupEntryInfoSet(), edm::SubProcessParentageHelper::update(), and edm::BranchIDListHelper::updateFromRegistry().

◆ productListUpdator()

ProductList& edm::ProductRegistry::productListUpdator ( )

inline

Definition at line 81 of file ProductRegistry.h.

                                       {
       throwIfFrozen();
       return productList_;
     }

References productList_, and throwIfFrozen().

Referenced by edm::RootFile::dropOnInput(), edm::PoolSource::PoolSource(), edm::RootFile::RootFile(), fwlite::internal::BranchMapReaderStrategyV8::updateFile(), fwlite::internal::BranchMapReaderStrategyV11::updateFile(), fwlite::internal::BranchMapReaderStrategyV17::updateFile(), fwlite::internal::BranchMapReaderStrategyV1::updateMap(), and ProvenanceDumper::work_().

◆ productLookup() [1/2]

std::shared_ptr< ProductResolverIndexHelper > edm::ProductRegistry::productLookup ( BranchType branchType )

Definition at line 149 of file ProductRegistry.cc.

                                                                                                 {
     return get_underlying_safe(transient_.productLookups_[branchType]);
   }

References edm::get_underlying_safe(), edm::ProductRegistry::Transients::productLookups_, and transient_.

◆ productLookup() [2/2]

std::shared_ptr< ProductResolverIndexHelper const > edm::ProductRegistry::productLookup ( BranchType branchType ) const

Definition at line 145 of file ProductRegistry.cc.

                                                                                                             {
     return get_underlying_safe(transient_.productLookups_[branchType]);
   }

References edm::get_underlying_safe(), edm::ProductRegistry::Transients::productLookups_, and transient_.

Referenced by edm::WorkerManager::beginJob(), edm::Schedule::changeModule(), initializeLookupTables(), and edm::EDConsumerBase::modulesWhoseProductsAreConsumed().

◆ productProduced()

bool edm::ProductRegistry::productProduced ( BranchType branchType ) const

inline

Definition at line 121 of file ProductRegistry.h.

121 { return transient_.productProduced_[branchType]; }

References edm::ProductRegistry::Transients::productProduced_, and transient_.

◆ setFrozen() [1/2]

void edm::ProductRegistry::setFrozen ( bool initializeLookupInfo = true )

Definition at line 153 of file ProductRegistry.cc.

                                                            {
     if (frozen())
       return;
     freezeIt();
     if (initializeLookupInfo) {
       initializeLookupTables(nullptr, nullptr, nullptr);
     }
     sort_all(transient_.aliasToOriginal_);
   }

References edm::ProductRegistry::Transients::aliasToOriginal_, freezeIt(), frozen(), initializeLookupTables(), edm::sort_all(), and transient_.

Referenced by fwlite::internal::BranchMapReaderStrategyV8::updateFile(), fwlite::internal::BranchMapReaderStrategyV11::updateFile(), fwlite::internal::BranchMapReaderStrategyV17::updateFile(), and fwlite::internal::BranchMapReaderStrategyV1::updateMap().

◆ setFrozen() [2/2]

void edm::ProductRegistry::setFrozen	(	std::set< TypeID > const &	productTypesConsumed,
		std::set< TypeID > const &	elementTypesConsumed,
		std::string const &	processName
	)

Definition at line 163 of file ProductRegistry.cc.

                                                                 {
     if (frozen())
       return;
     freezeIt();
     initializeLookupTables(&productTypesConsumed, &elementTypesConsumed, &processName);
     sort_all(transient_.aliasToOriginal_);
   }

References edm::ProductRegistry::Transients::aliasToOriginal_, freezeIt(), frozen(), initializeLookupTables(), SimL1EmulatorRepack_CalouGT_cff::processName, edm::sort_all(), and transient_.

◆ setProductProduced()

void edm::ProductRegistry::setProductProduced ( BranchType branchType )

inlineprivate

Definition at line 163 of file ProductRegistry.h.

                                                    {
       transient_.productProduced_[branchType] = true;
       transient_.anyProductProduced_ = true;
     }

References edm::ProductRegistry::Transients::anyProductProduced_, edm::ProductRegistry::Transients::productProduced_, and transient_.

Referenced by initializeLookupTables().

◆ setUnscheduledProducts()

void edm::ProductRegistry::setUnscheduledProducts ( std::set< std::string > const & unscheduledLabels )

Definition at line 221 of file ProductRegistry.cc.

                                                                                          {
     throwIfFrozen();
  
     bool hasAliases = false;
     std::vector<BranchID> onDemandIDs;
     for (auto& prod : productList_) {
       if (prod.second.produced() && prod.second.branchType() == InEvent &&
           unscheduledLabels.end() != unscheduledLabels.find(prod.second.moduleLabel())) {
         prod.second.setOnDemand(true);
         onDemandIDs.push_back(prod.second.branchID());
       }
       if (prod.second.produced() && prod.second.isAlias()) {
         hasAliases = true;
       }
     }
  
     // Need to loop over EDAliases to set their on-demand flag based on the pointed-to branch
     if (hasAliases) {
       std::sort(onDemandIDs.begin(), onDemandIDs.end());
       for (auto& prod : productList_) {
         if (prod.second.isAlias()) {
           if (std::binary_search(onDemandIDs.begin(), onDemandIDs.end(), prod.second.aliasForBranchID())) {
             prod.second.setOnDemand(true);
           }
         }
       }
     }
   }

References edm::InEvent, dumpMFGeometry_cfg::prod, productList_, jetUpdater_cfi::sort, and throwIfFrozen().

Referenced by edm::SecondaryEventProvider::SecondaryEventProvider().

◆ size()

ProductList::size_type edm::ProductRegistry::size ( void ) const

inline

Definition at line 109 of file ProductRegistry.h.

109 { return productList_.size(); }

References productList_.

Referenced by ntupleDataFormat._Collection::__iter__(), ntupleDataFormat._Collection::__len__(), allBranchDescriptions(), and allBranchNames().

◆ throwIfFrozen()

void edm::ProductRegistry::throwIfFrozen ( ) const

private

Definition at line 173 of file ProductRegistry.cc.

                                             {
     if (frozen()) {
       throw cms::Exception("ProductRegistry", "throwIfFrozen")
           << "cannot modify the ProductRegistry because it is frozen\n";
     }
   }

References Exception, and frozen().

Referenced by addLabelAlias(), addProduct(), copyProduct(), productListUpdator(), and setUnscheduledProducts().

◆ throwIfNotFrozen()

void edm::ProductRegistry::throwIfNotFrozen ( ) const

private

Definition at line 180 of file ProductRegistry.cc.

                                                {
     if (!frozen()) {
       throw cms::Exception("ProductRegistry", "throwIfNotFrozen")
           << "cannot read the ProductRegistry because it is not yet frozen\n";
     }
   }

References Exception, and frozen().

Referenced by anyProducts().

◆ updateFromInput() [1/2]

void edm::ProductRegistry::updateFromInput ( ProductList const & other )

Definition at line 209 of file ProductRegistry.cc.

                                                                 {
     for (auto const& product : other) {
       copyProduct(product.second);
     }
   }

References copyProduct(), and trackingPlots::other.

Referenced by edm::StreamerInputSource::mergeIntoRegistry(), edm::RepeatingCachedRootSource::RepeatingCachedRootSource(), edm::RootEmbeddedFileSequence::RootEmbeddedFileSequence(), edm::RootPrimaryFileSequence::RootPrimaryFileSequence(), and edm::RootSecondaryFileSequence::RootSecondaryFileSequence().

◆ updateFromInput() [2/2]

void edm::ProductRegistry::updateFromInput ( std::vector< BranchDescription > const & other )

Definition at line 215 of file ProductRegistry.cc.

                                                                                  {
     for (BranchDescription const& branchDescription : other) {
       copyProduct(branchDescription);
     }
   }

References copyProduct(), and trackingPlots::other.

Member Data Documentation

◆ productList_

ProductList edm::ProductRegistry::productList_

private

Definition at line 190 of file ProductRegistry.h.

Referenced by addLabelAlias(), addProduct(), anyProducts(), callForEachBranch(), copyProduct(), initializeLookupTables(), merge(), print(), productList(), productListUpdator(), setUnscheduledProducts(), and size().

◆ transient_

Transients edm::ProductRegistry::transient_

private

Definition at line 191 of file ProductRegistry.h.

Referenced by addElementTypesForAliases(), addLabelAlias(), aliasToModules(), anyProductProduced(), freezeIt(), frozen(), getNextIndexValue(), indexFrom(), initializeLookupTables(), initializeTransients(), merge(), nextIndexValue(), productLookup(), productProduced(), setFrozen(), and setProductProduced().

Classes

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ ConstProductList

◆ ProductList

Constructor & Destructor Documentation

◆ ProductRegistry() [1/2]

◆ ProductRegistry() [2/2]

◆ ~ProductRegistry()

Member Function Documentation

◆ addCalled()

◆ addElementTypesForAliases()

◆ addLabelAlias()

◆ addProduct()

◆ aliasToModules()

◆ allBranchDescriptions()

◆ allBranchNames()

◆ anyProductProduced()

◆ anyProducts()

◆ callForEachBranch()

◆ checkDictionariesOfConsumedTypes()

◆ checkForDuplicateProcessName()

◆ copyProduct()

◆ freezeIt()

◆ frozen()

◆ getNextIndexValue()

◆ indexFrom()

◆ initializeLookupTables()

◆ initializeTransients()

◆ merge()

◆ nextIndexValue()

◆ print()

◆ productList()

◆ productListUpdator()

◆ productLookup() [1/2]

◆ productLookup() [2/2]

◆ productProduced()

◆ setFrozen() [1/2]

◆ setFrozen() [2/2]

◆ setProductProduced()

◆ setUnscheduledProducts()

◆ size()

◆ throwIfFrozen()

◆ throwIfNotFrozen()

◆ updateFromInput() [1/2]

◆ updateFromInput() [2/2]

Member Data Documentation

◆ productList_

◆ transient_