edm::ProductRegistry Class Reference

#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 const >	productLookup (BranchType branchType) const
std::shared_ptr < ProductResolverIndexHelper >	productLookup (BranchType branchType)
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

author Stefano ARGIRO author Bill Tanenbaum

Date

19 Jul 2005

Definition at line 37 of file ProductRegistry.h.

Member Typedef Documentation

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

Definition at line 50 of file ProductRegistry.h.

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

Definition at line 39 of file ProductRegistry.h.

Constructor & Destructor Documentation

edm::ProductRegistry::ProductRegistry

(

)

Definition at line 32 of file ProductRegistry.cc.

: productList_(), transient_() {}

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

explicit

Definition at line 63 of file ProductRegistry.cc.

References freezeIt().

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

virtual edm::ProductRegistry::~ProductRegistry ( )

inlinevirtual

Definition at line 48 of file ProductRegistry.h.

{}

Member Function Documentation

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

privatevirtual

Reimplemented in edm::SignallingProductRegistry.

Definition at line 187 of file ProductRegistry.cc.

Referenced by addLabelAlias(), and addProduct().

{}

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 466 of file ProductRegistry.cc.

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

Referenced by initializeLookupTables().

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

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

Definition at line 108 of file ProductRegistry.cc.

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

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

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

Definition at line 68 of file ProductRegistry.cc.

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

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

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

Definition at line 614 of file ProductRegistry.cc.

References edm::ProductRegistry::Transients::aliasToOriginal_, newFWLiteAna::found, B2GTnPMonitor_cfi::item, cuda_std::lower_bound(), runTheMatrix::ret, filterCSVwithJSON::target, and transient_.

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

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

(

)

const

Definition at line 199 of file ProductRegistry.cc.

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

Referenced by edm::RootFile::dropOnInputAndReorder(), edm::SubProcess::selectProducts(), edm::core::OutputModuleCore::selectProducts(), and edm::PrincipalGetAdapter::throwUnregisteredPutException().

                                                                                   {
    std::vector<BranchDescription const*> result;
    result.reserve(productList().size());

    for (auto const& product : productList()) {
      result.push_back(&product.second);
    }
    return result;
  }

std::vector< std::string > edm::ProductRegistry::allBranchNames

(

)

const

Definition at line 189 of file ProductRegistry.cc.

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

                                                             {
    std::vector<std::string> result;
    result.reserve(productList().size());

    for (auto const& product : productList()) {
      result.push_back(product.second.branchName());
    }
    return result;
  }

bool edm::ProductRegistry::anyProductProduced ( ) const

inline

Definition at line 122 of file ProductRegistry.h.

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

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

{ return transient_.anyProductProduced_; }

bool edm::ProductRegistry::anyProducts

(

BranchType const

brType

)

const

Definition at line 135 of file ProductRegistry.cc.

References productList_, and throwIfNotFrozen().

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

template<typename T >

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

inline

Definition at line 100 of file ProductRegistry.h.

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

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

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 515 of file ProductRegistry.cc.

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

Referenced by initializeLookupTables().

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

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

private

Definition at line 595 of file ProductRegistry.cc.

References edm::errors::Configuration, Exception, edm::BranchDescription::processName(), and edm::BranchDescription::produced().

Referenced by initializeLookupTables().

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

void edm::ProductRegistry::copyProduct

(

BranchDescription const &

productdesc

)

Definition at line 122 of file ProductRegistry.cc.

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

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

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

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

inlineprivate

Definition at line 168 of file ProductRegistry.h.

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

Referenced by ProductRegistry(), and setFrozen().

{ transient_.frozen_ = frozen; }

bool edm::ProductRegistry::frozen ( ) const

inline

Definition at line 140 of file ProductRegistry.h.

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

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

{ return transient_.frozen_; }

ProductResolverIndex const & edm::ProductRegistry::getNextIndexValue

(

BranchType

branchType

)

const

Definition at line 643 of file ProductRegistry.cc.

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

Referenced by initializeLookupTables(), and merge().

                                                                                            {
    return transient_.nextIndexValues_[branchType];
  }

ProductResolverIndex edm::ProductRegistry::indexFrom

(

BranchID const &

iID

)

const

Definition at line 606 of file ProductRegistry.cc.

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

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

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

private

Definition at line 296 of file ProductRegistry.cc.

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

Referenced by setFrozen().

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

void edm::ProductRegistry::initializeTransients ( )

inline

Definition at line 138 of file ProductRegistry.h.

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

{ transient_.reset(); }

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.

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

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

                                                                                   {
    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 || j->second.branchType() == InProcess)) {
          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();
  }

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

private

Definition at line 647 of file ProductRegistry.cc.

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

Referenced by initializeLookupTables(), and merge().

                                                                             {
    return transient_.nextIndexValues_[branchType];
  }

void edm::ProductRegistry::print

(

std::ostream &

os

)

const

Definition at line 637 of file ProductRegistry.cc.

References productList_.

Referenced by edm::operator<<().

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

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

inline

Definition at line 76 of file ProductRegistry.h.

References productList_.

Referenced by edm::Principal::adjustToNewProductRegistry(), allBranchDescriptions(), allBranchNames(), edm::ProductSelector::fillDroppedToKept(), merge(), edm::operator==(), edm::ThinningProducer< Collection, Selector >::registerThinnedAssociations(), edm::RootFile::RootFile(), edm::ProcessBlockHelperBase::selectProcess(), edm::SubProcess::selectProducts(), edm::core::OutputModuleCore::selectProducts(), edm::MergeableRunProductProcesses::setProcessesWithMergeableRunProducts(), edm::ProductProvenanceLookup::setupEntryInfoSet(), edm::SubProcessParentageHelper::update(), edm::ProcessBlockHelperBase::updateForNewProcess(), edm::SubProcessBlockHelper::updateFromParentProcess(), and edm::BranchIDListHelper::updateFromRegistry().

                                           {
      //throwIfNotFrozen();
      return productList_;
    }

ProductList& edm::ProductRegistry::productListUpdator ( )

inline

Definition at line 81 of file ProductRegistry.h.

References productList_, and throwIfFrozen().

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

                                      {
      throwIfFrozen();
      return productList_;
    }

std::shared_ptr< ProductResolverIndexHelper const > edm::ProductRegistry::productLookup

(

BranchType

branchType

)

const

Definition at line 145 of file ProductRegistry.cc.

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

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

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

std::shared_ptr< ProductResolverIndexHelper > edm::ProductRegistry::productLookup

(

BranchType

branchType

)

Definition at line 149 of file ProductRegistry.cc.

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

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

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

inline

Definition at line 121 of file ProductRegistry.h.

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

{ return transient_.productProduced_[branchType]; }

void edm::ProductRegistry::setFrozen

(

bool

initializeLookupInfo = true

)

Definition at line 153 of file ProductRegistry.cc.

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

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

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.

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

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

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

inlineprivate

Definition at line 163 of file ProductRegistry.h.

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

Referenced by initializeLookupTables().

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

void edm::ProductRegistry::setUnscheduledProducts

(

std::set< std::string > const &

unscheduledLabels

)

Definition at line 221 of file ProductRegistry.cc.

References edm::InEvent, productList_, and throwIfFrozen().

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

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

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

inline

Definition at line 109 of file ProductRegistry.h.

References productList_.

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

{ return productList_.size(); }

void edm::ProductRegistry::throwIfFrozen ( ) const

private

Definition at line 173 of file ProductRegistry.cc.

References Exception, and frozen().

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

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

void edm::ProductRegistry::throwIfNotFrozen ( ) const

private

Definition at line 180 of file ProductRegistry.cc.

References Exception, and frozen().

Referenced by anyProducts().

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

void edm::ProductRegistry::updateFromInput

(

ProductList const &

other

)

Definition at line 209 of file ProductRegistry.cc.

References copyProduct().

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

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

void edm::ProductRegistry::updateFromInput

(

std::vector< BranchDescription > const &

other

)

Definition at line 215 of file ProductRegistry.cc.

References copyProduct().

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

Member Data Documentation

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

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