edm::ProductResolverIndexHelper Class Reference

#include <ProductResolverIndexHelper.h>

Classes
class	IndexAndNames
class	Item
class	Matches
class	Range

Public Types
using	ModulesToIndiciesMap = std::unordered_multimap< std::string, std::tuple< TypeID const *, const char *, ProductResolverIndex > >

Public Member Functions
unsigned int	beginElements () const
ProductResolverIndex	index (KindOfType kindOfType, TypeID const &typeID, char const *moduleLabel, char const *instance, char const *process=nullptr) const
std::vector< IndexAndNames > const &	indexAndNames () const
unsigned int	indexToIndexAndNames (KindOfType kindOfType, TypeID const &typeID, char const *moduleLabel, char const *instance, char const *process) const
unsigned int	indexToType (KindOfType kindOfType, TypeID const &typeID) const
ModulesToIndiciesMap	indiciesForModulesInProcess (const std::string &iProcessName) const
ProductResolverIndex	insert (TypeID const &typeID, char const *moduleLabel, char const *instance, char const *process, TypeID const &containedTypeID, std::vector< TypeID > *baseTypesOfContainedType)
ProductResolverIndex	insert (TypeID const &typeID, char const *moduleLabel, char const *instance, char const *process)
std::vector< std::string > const &	lookupProcessNames () const
ProductResolverIndex	nextIndexValue () const
void	print (std::ostream &os) const
unsigned int	processIndex (char const *process) const
std::vector< char > const &	processNames () const
	ProductResolverIndexHelper ()
std::vector< Range > const &	ranges () const
Matches	relatedIndexes (KindOfType kindOfType, TypeID const &typeID, char const *moduleLabel, char const *instance) const
Matches	relatedIndexes (KindOfType kindOfType, TypeID const &typeID) const
void	sanityCheck () const
void	setFrozen ()
std::vector< TypeID > const &	sortedTypeIDs () const

Private Attributes
unsigned int	beginElements_
std::vector< char >	bigNamesContainer_
std::vector< IndexAndNames >	indexAndNames_
edm::propagate_const< std::unique_ptr< std::set< Item > > >	items_
std::vector< std::string >	lookupProcessNames_
ProductResolverIndex	nextIndexValue_
edm::propagate_const< std::unique_ptr< std::set< std::string > > >	processItems_
std::vector< char >	processNames_
std::vector< Range >	ranges_
std::vector< TypeID >	sortedTypeIDs_

Detailed Description

This class assigns and gets the ProductResolverIndex associated with a type, module label, instance, and process. The ProductResolverIndex is used to tell the Principal where to store a ProductResolver and how to find it quickly.

One can also look up the same ProductResolverIndex's using the type or base type of an element in a container in the product (if the product is a container). In this case the KindOfType argument to the Principal::getByLabel function is ELEMENT_TYPE, whereas normally it is PRODUCT_TYPE.

There are also special ProductResolverIndex's generated where the process name is empty. These indexes refer to a special ProductResolvers that search for a matching product from the most recent process that has a matching type, label and instance. There is ProductResolverIndex generated for each type/label/instance combination which has at least one entry in the tables in this class. Both PRODUCT_TYPEs and ELEMENT_TYPEs get these special ProductResolvers.

The ProductResolverIndex for a particular product will not change during a process after the ProductRegistry has been frozen. Nor will any of the other member data of this class. Multiple threads can access it concurrently without problems. The ProductResolverIndexes can be safely cached in InputTags and possibly other places, because they never change within a process. The ProductResolverIndex for a particular product is not intended to be persistent and will be different in different processes.

The ProductResolverIndex is used to order the placement of the ProductResolvers in the Principal that are either present in the input or produced in the current process. Be aware that there are other ProductResolvers for products that come after ProductResolvers placed by this class. For example, the placement of dropped products is not handled by this class, instead by the ProductRegistry. The reason for this distinction is that those other ProductResolvers can change and be added as a process runs. The content of this class never changes after the ProductRegistry is frozen.

Author

W. David Dagenhart, created 10 December, 2012

Definition at line 93 of file ProductResolverIndexHelper.h.

Member Typedef Documentation

ModulesToIndiciesMap

using edm::ProductResolverIndexHelper::ModulesToIndiciesMap = std::unordered_multimap<std::string, std::tuple<TypeID const*, const char*, ProductResolverIndex> >

Definition at line 128 of file ProductResolverIndexHelper.h.

Constructor & Destructor Documentation

ProductResolverIndexHelper()

edm::ProductResolverIndexHelper::ProductResolverIndexHelper

(

)

Definition at line 101 of file ProductResolverIndexHelper.cc.

      : nextIndexValue_(0),
        beginElements_(0),
        items_(new std::set<ProductResolverIndexHelper::Item>),
        processItems_(new std::set<std::string>) {}

Member Function Documentation

beginElements()

unsigned int edm::ProductResolverIndexHelper::beginElements ( ) const

inline

Definition at line 227 of file ProductResolverIndexHelper.h.

References beginElements_.

{ return beginElements_; }

index()

ProductResolverIndex edm::ProductResolverIndexHelper::index	(	KindOfType	kindOfType,
		TypeID const &	typeID,
		char const *	moduleLabel,
		char const *	instance,
		char const *	process = nullptr
	)		const

Definition at line 107 of file ProductResolverIndexHelper.cc.

References indexAndNames_, indexToIndexAndNames(), instance, SiStripPI::max, HerwigMaxPtPartonFilter_cfi::moduleLabel, LaserDQM_cfg::process, and edm::ProductResolverIndexInvalid.

Referenced by edm::TransformerBase::extendUpdateLookup(), edm::Principal::findProductByLabel(), edm::PrincipalGetAdapter::getBranchDescription(), and edm::EDConsumerBase::updateLookup().

                                                                                    {
    unsigned int iToIndexAndNames = indexToIndexAndNames(kindOfType, typeID, moduleLabel, instance, process);

    if (iToIndexAndNames == std::numeric_limits<unsigned int>::max()) {
      return ProductResolverIndexInvalid;
    }
    return indexAndNames_[iToIndexAndNames].index();
  }

indexAndNames()

std::vector<IndexAndNames> const& edm::ProductResolverIndexHelper::indexAndNames ( ) const

inline

Definition at line 230 of file ProductResolverIndexHelper.h.

References indexAndNames_.

Referenced by indiciesForModulesInProcess().

{ return indexAndNames_; }

indexToIndexAndNames()

unsigned int edm::ProductResolverIndexHelper::indexToIndexAndNames	(	KindOfType	kindOfType,
		TypeID const &	typeID,
		char const *	moduleLabel,
		char const *	instance,
		char const *	process
	)		const

Definition at line 448 of file ProductResolverIndexHelper.cc.

References bigNamesContainer_, indexAndNames_, indexToType(), instance, label, SiStripPI::max, HerwigMaxPtPartonFilter_cfi::moduleLabel, LaserDQM_cfg::process, processIndex(), FastTimerService_cff::range, and ranges_.

Referenced by index(), and relatedIndexes().

                                                                                           {
    // Look for the type and check to see if it found it
    unsigned iType = indexToType(kindOfType, typeID);
    if (iType != std::numeric_limits<unsigned int>::max()) {
      unsigned startProcess = 0;
      if (process) {
        startProcess = processIndex(process);
        if (startProcess == std::numeric_limits<unsigned int>::max()) {
          return std::numeric_limits<unsigned int>::max();
        }
      }

      ProductResolverIndexHelper::Range const& range = ranges_[iType];
      unsigned int begin = range.begin();
      unsigned int end = range.end();

      while (begin < end) {
        unsigned int midpoint = begin + ((end - begin) / 2);
        char const* namePtr = &bigNamesContainer_[indexAndNames_[midpoint].startInBigNamesContainer()];

        // Compare the module label
        char const* label = moduleLabel;
        while (*namePtr && (*namePtr == *label)) {
          ++namePtr;
          ++label;
        }
        if (*namePtr == *label) {  // true only if both are at the '\0' at the end of the C string
          ++namePtr;               // move to the next C string

          // Compare the instance name
          char const* instanceName = instance;
          while (*namePtr && (*namePtr == *instanceName)) {
            ++namePtr;
            ++instanceName;
          }
          if (*namePtr == *instanceName) {
            // Compare the process name
            if (startProcess == indexAndNames_[midpoint].startInProcessNames()) {
              return midpoint;
            } else {
              if (indexAndNames_[midpoint].startInProcessNames() > startProcess) {
                while (true) {
                  --midpoint;
                  if (indexAndNames_[midpoint].startInProcessNames() == startProcess) {
                    return midpoint;
                  }
                  if (indexAndNames_[midpoint].startInProcessNames() == 0)
                    break;
                }
              } else {
                while (true) {
                  ++midpoint;
                  if (midpoint == indexAndNames_.size())
                    break;
                  if (indexAndNames_[midpoint].startInProcessNames() == 0)
                    break;
                  if (indexAndNames_[midpoint].startInProcessNames() == startProcess) {
                    return midpoint;
                  }
                }
              }
              break;
            }
          } else if (*namePtr < *instanceName) {
            if (begin == midpoint)
              break;
            begin = midpoint;
          } else {
            end = midpoint;
          }
        } else if (*namePtr < *label) {
          if (begin == midpoint)
            break;
          begin = midpoint;
        } else {
          end = midpoint;
        }
      }  // end while (begin < end)
    }
    return std::numeric_limits<unsigned int>::max();
  }

indexToType()

unsigned int edm::ProductResolverIndexHelper::indexToType	(	KindOfType	kindOfType,
		TypeID const &	typeID
	)		const

Definition at line 534 of file ProductResolverIndexHelper.cc.

References beginElements_, edm::ELEMENT_TYPE, SiStripPI::max, and sortedTypeIDs_.

Referenced by indexToIndexAndNames(), and relatedIndexes().

                                                                                                        {
    unsigned int beginType = 0;
    unsigned int endType = beginElements_;
    if (kindOfType == ELEMENT_TYPE) {
      beginType = beginElements_;
      endType = sortedTypeIDs_.size();
    }

    while (beginType < endType) {
      unsigned int midpointType = beginType + ((endType - beginType) / 2);
      if (sortedTypeIDs_[midpointType] == typeID) {
        return midpointType;  // Found it
      } else if (sortedTypeIDs_[midpointType] < typeID) {
        if (beginType == midpointType)
          break;
        beginType = midpointType;
      } else {
        endType = midpointType;
      }
    }
    return std::numeric_limits<unsigned int>::max();  // Failed to find it
  }

indiciesForModulesInProcess()

ProductResolverIndexHelper::ModulesToIndiciesMap edm::ProductResolverIndexHelper::indiciesForModulesInProcess

(

const std::string &

iProcessName

)

const

Definition at line 581 of file ProductResolverIndexHelper.cc.

References beginElements_, bigNamesContainer_, mps_fire::i, indexAndNames(), indexAndNames_, dqmiolumiharvest::j, MainPageGenerator::l, processNames_, FastTimerService_cff::range, ranges_, mps_fire::result, and sortedTypeIDs_.

                                           {
    ModulesToIndiciesMap result;
    for (unsigned int i = 0; i < beginElements_; ++i) {
      auto const& range = ranges_[i];
      for (unsigned int j = range.begin(); j < range.end(); ++j) {
        auto const& indexAndNames = indexAndNames_[j];
        if (0 == strcmp(&processNames_[indexAndNames.startInProcessNames()], iProcessName.c_str())) {
          //The first null terminated string is the module label
          auto pModLabel = &bigNamesContainer_[indexAndNames.startInBigNamesContainer()];
          auto l = strlen(pModLabel);
          auto pInstance = pModLabel + l + 1;
          result.emplace(pModLabel, std::make_tuple(&sortedTypeIDs_[i], pInstance, indexAndNames.index()));
        }
      }
    }
    return result;
  }

insert() [1/2]

ProductResolverIndex edm::ProductResolverIndexHelper::insert	(	TypeID const &	typeID,
		char const *	moduleLabel,
		char const *	instance,
		char const *	process,
		TypeID const &	containedTypeID,
		std::vector< TypeID > *	baseTypesOfContainedType
	)

Definition at line 207 of file ProductResolverIndexHelper.cc.

References edm::ProductResolverIndexHelper::Item::clearProcess(), edm::ELEMENT_TYPE, Exception, instance, B2GTnPMonitor_cfi::item, items_, edm::errors::LogicError, HerwigMaxPtPartonFilter_cfi::moduleLabel, nextIndexValue_, LaserDQM_cfg::process, edm::PRODUCT_TYPE, edm::ProductResolverIndexAmbiguous, edm::ProductResolverIndexHelper::Item::setIndex(), and edm::TypeID::typeInfo().

Referenced by SequenceTypes.Schedule::_replaceIfHeldDirectly(), and insert().

                                                                                                       {
    if (!items_) {
      throw Exception(errors::LogicError)
          << "ProductResolverIndexHelper::insert - Attempt to insert more elements after frozen.\n";
    }

    if (process == nullptr || *process == '\0') {
      throw Exception(errors::LogicError) << "ProductResolverIndexHelper::insert - Empty process.\n";
    }

    // Throw if this has already been inserted
    Item item(PRODUCT_TYPE, typeID, moduleLabel, instance, process, 0);
    std::set<Item>::iterator iter = items_->find(item);
    if (iter != items_->end()) {
      throw Exception(errors::LogicError)
          << "ProductResolverIndexHelper::insert - Attempt to insert duplicate entry.\n";
    }

    // Put in an entry for the product
    item.setIndex(nextIndexValue_);
    unsigned int savedProductIndex = nextIndexValue_;
    ++nextIndexValue_;
    items_->insert(item);

    // Put in an entry for the product with an empty process name
    // if it is not already there
    item.clearProcess();
    iter = items_->find(item);
    if (iter == items_->end()) {
      item.setIndex(nextIndexValue_);
      ++nextIndexValue_;
      items_->insert(item);
    }

    // Now put in entries for a contained class if this is a
    // recognized container.
    if (containedTypeID != TypeID(typeid(void)) && containedTypeID != TypeID()) {
      TypeWithDict containedType(containedTypeID.typeInfo());

      Item containedItem(ELEMENT_TYPE, containedTypeID, moduleLabel, instance, process, savedProductIndex);
      iter = items_->find(containedItem);
      if (iter != items_->end()) {
        containedItem.setIndex(ProductResolverIndexAmbiguous);
        items_->erase(iter);
      }
      items_->insert(containedItem);

      containedItem.clearProcess();
      iter = items_->find(containedItem);
      if (iter == items_->end()) {
        containedItem.setIndex(nextIndexValue_);
        ++nextIndexValue_;
        items_->insert(containedItem);
      }

      // Repeat this for all public base classes of the contained type
      if (baseTypesOfContainedType) {
        for (TypeID const& baseTypeID : *baseTypesOfContainedType) {
          Item baseItem(ELEMENT_TYPE, baseTypeID, moduleLabel, instance, process, savedProductIndex);
          iter = items_->find(baseItem);
          if (iter != items_->end()) {
            baseItem.setIndex(ProductResolverIndexAmbiguous);
            items_->erase(iter);
          }
          items_->insert(baseItem);

          baseItem.clearProcess();
          iter = items_->find(baseItem);
          if (iter == items_->end()) {
            baseItem.setIndex(nextIndexValue_);
            ++nextIndexValue_;
            items_->insert(baseItem);
          }
        }
      }
    }
    return savedProductIndex;
  }

insert() [2/2]

ProductResolverIndex edm::ProductResolverIndexHelper::insert	(	TypeID const &	typeID,
		char const *	moduleLabel,
		char const *	instance,
		char const *	process
	)

Definition at line 291 of file ProductResolverIndexHelper.cc.

References edm::productholderindexhelper::getContainedType(), insert(), instance, HerwigMaxPtPartonFilter_cfi::moduleLabel, LaserDQM_cfg::process, and edm::public_base_classes().

Referenced by SequenceTypes.Schedule::_replaceIfHeldDirectly().

                                                                               {
    TypeID containedTypeID = productholderindexhelper::getContainedType(typeID);
    bool hasContainedType = (containedTypeID != TypeID(typeid(void)) && containedTypeID != TypeID());
    std::vector<TypeID> baseTypes;
    std::vector<TypeID>* baseTypesOfContainedType = &baseTypes;
    if (hasContainedType) {
      std::vector<std::string> missingDictionaries;
      public_base_classes(missingDictionaries, containedTypeID, baseTypes);
    }
    return insert(typeID, moduleLabel, instance, process, containedTypeID, baseTypesOfContainedType);
  }

lookupProcessNames()

std::vector< std::string > const & edm::ProductResolverIndexHelper::lookupProcessNames

(

)

const

Definition at line 440 of file ProductResolverIndexHelper.cc.

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

                                                                                   {
    if (items_) {
      throw Exception(errors::LogicError)
          << "ProductResolverIndexHelper::lookupProcessNames - Attempt to access names before frozen.\n";
    }
    return lookupProcessNames_;
  }

nextIndexValue()

ProductResolverIndex edm::ProductResolverIndexHelper::nextIndexValue ( ) const

inline

Definition at line 255 of file ProductResolverIndexHelper.h.

References nextIndexValue_.

{ return nextIndexValue_; }

print()

void edm::ProductResolverIndexHelper::print

(

std::ostream &

os

)

const

Definition at line 698 of file ProductResolverIndexHelper.cc.

References beginElements_, bigNamesContainer_, gather_cfg::cout, mps_fire::i, indexAndNames_, B2GTnPMonitor_cfi::item, items_, nextIndexValue_, l1tGTMenu_BTagSeeds_cff::os, processItems_, processNames_, ranges_, and sortedTypeIDs_.

                                                             {
    os << "\n******* Dump ProductResolverIndexHelper *************************\n";

    os << "\nnextIndexValue_ = " << nextIndexValue_ << "\n";
    os << "beginElements_ = " << beginElements_ << "\n";

    os << "\n******* sortedTypeIDs_ \n";
    for (auto const& i : sortedTypeIDs_) {
      os << i << "\n";
    }
    os << "******* ranges_ \n";
    for (auto const& i : ranges_) {
      os << i.begin() << " " << i.end() << "\n";
    }
    os << "******* indexAndNames_ \n";
    for (auto const& i : indexAndNames_) {
      os << i.index() << " " << i.startInBigNamesContainer() << " ";
      char const* ptr = &bigNamesContainer_[i.startInBigNamesContainer()];
      while (*ptr) {
        os << *ptr;
        ++ptr;
      }
      ++ptr;
      os << " ";
      while (*ptr) {
        os << *ptr;
        ++ptr;
      }
      os << " " << i.startInProcessNames() << " ";
      ptr = &processNames_[i.startInProcessNames()];
      while (*ptr) {
        os << *ptr;
        ++ptr;
      }
      os << "\n";
    }
    os << "******* bigNamesContainer_ \n";
    for (auto i : bigNamesContainer_) {
      if (i == '\0')
        os << '\\' << '0';
      else
        os << i;
    }
    if (!bigNamesContainer_.empty())
      os << "\n";
    os << "******* processNames_ \n";
    for (auto i : processNames_) {
      if (i == '\0')
        os << '\\' << '0';
      else
        os << i;
    }
    if (!processNames_.empty())
      os << "\n";
    if (items_) {
      os << "******* items_ \n";
      for (auto const& item : *items_) {
        std::cout << item.kindOfType() << " " << item.moduleLabel() << " " << item.instance() << " " << item.process()
                  << " " << item.index() << " " << item.typeID() << "\n";
      }
    }
    if (processItems_) {
      os << "******* processItems_ \n";
      for (auto const& item : *processItems_) {
        os << item << "\n";
      }
    }
    os << "sortedTypeIDs_.size() = " << sortedTypeIDs_.size() << "\n";
    os << "indexAndNames_.size() = " << indexAndNames_.size() << "\n";
    os << "bigNamesContainer_.size() = " << bigNamesContainer_.size() << "\n";
    os << "processNames_.size() = " << processNames_.size() << "\n";
    os << "\n";
  }

processIndex()

unsigned int edm::ProductResolverIndexHelper::processIndex

(

char const *

process

)

const

Definition at line 557 of file ProductResolverIndexHelper.cc.

References SiStripPI::max, AlCaHLTBitMon_ParallelJobs::p, LaserDQM_cfg::process, and processNames_.

Referenced by indexToIndexAndNames(), and setFrozen().

                                                                                 {
    char const* ptr = &processNames_[0];
    char const* begin = ptr;
    while (true) {
      char const* p = process;
      char const* beginName = ptr;
      while (*ptr && (*ptr == *p)) {
        ++ptr;
        ++p;
      }
      if (*ptr == *p) {
        return beginName - begin;
      }
      while (*ptr) {
        ++ptr;
      }
      ++ptr;
      if (static_cast<unsigned>(ptr - begin) >= processNames_.size()) {
        return std::numeric_limits<unsigned int>::max();
      }
    }
    return 0;
  }

processNames()

std::vector<char> const& edm::ProductResolverIndexHelper::processNames ( ) const

inline

Definition at line 231 of file ProductResolverIndexHelper.h.

References processNames_.

{ return processNames_; }

ranges()

std::vector<Range> const& edm::ProductResolverIndexHelper::ranges ( ) const

inline

Definition at line 229 of file ProductResolverIndexHelper.h.

References ranges_.

{ return ranges_; }

relatedIndexes() [1/2]

ProductResolverIndexHelper::Matches edm::ProductResolverIndexHelper::relatedIndexes	(	KindOfType	kindOfType,
		TypeID const &	typeID,
		char const *	moduleLabel,
		char const *	instance
	)		const

Definition at line 171 of file ProductResolverIndexHelper.cc.

References indexAndNames_, indexToIndexAndNames(), instance, dqmiolumiharvest::j, SiStripPI::max, HerwigMaxPtPartonFilter_cfi::moduleLabel, and mitigatedMETSequence_cff::U.

                                                                                                             {
    unsigned int startInIndexAndNames = indexToIndexAndNames(kindOfType, typeID, moduleLabel, instance, nullptr);
    unsigned int numberOfMatches = 1;

    if (startInIndexAndNames == std::numeric_limits<unsigned int>::max()) {
      numberOfMatches = 0;
    } else {
      auto vSize = indexAndNames_.size();
      for (unsigned int j = startInIndexAndNames + 1U; j < vSize && (indexAndNames_[j].startInProcessNames() != 0U);
           ++j) {
        ++numberOfMatches;
      }
    }
    return Matches(this, startInIndexAndNames, numberOfMatches);
  }

relatedIndexes() [2/2]

ProductResolverIndexHelper::Matches edm::ProductResolverIndexHelper::relatedIndexes	(	KindOfType	kindOfType,
		TypeID const &	typeID
	)		const

Definition at line 190 of file ProductResolverIndexHelper.cc.

References indexToType(), SiStripPI::max, FastTimerService_cff::range, and ranges_.

                                                                                                             {
    unsigned int startInIndexAndNames = std::numeric_limits<unsigned int>::max();
    unsigned int numberOfMatches = 0;

    // Look for the type and check to see if it found it
    unsigned iType = indexToType(kindOfType, typeID);
    if (iType != std::numeric_limits<unsigned int>::max()) {
      // Get the range of entries with a matching TypeID
      Range const& range = ranges_[iType];

      startInIndexAndNames = range.begin();
      numberOfMatches = range.end() - range.begin();
    }
    return Matches(this, startInIndexAndNames, numberOfMatches);
  }

sanityCheck()

void edm::ProductResolverIndexHelper::sanityCheck

(

)

const

Definition at line 600 of file ProductResolverIndexHelper.cc.

References bigNamesContainer_, Exception, indexAndNames_, dqmiolumiharvest::j, edm::errors::LogicError, nextIndexValue_, processNames_, edm::ProductResolverIndexAmbiguous, FastTimerService_cff::range, ranges_, and sortedTypeIDs_.

Referenced by setFrozen().

                                                     {
    bool sanityChecksPass = true;
    if (sortedTypeIDs_.size() != ranges_.size())
      sanityChecksPass = false;

    unsigned int previousEnd = 0;
    for (auto const& range : ranges_) {
      if (range.begin() != previousEnd)
        sanityChecksPass = false;
      if (range.begin() >= range.end())
        sanityChecksPass = false;
      previousEnd = range.end();
    }
    if (previousEnd != indexAndNames_.size())
      sanityChecksPass = false;

    unsigned maxStart = 0;
    unsigned maxStartProcess = 0;
    for (auto const& indexAndName : indexAndNames_) {
      if (indexAndName.index() >= nextIndexValue_ && indexAndName.index() != ProductResolverIndexAmbiguous)
        sanityChecksPass = false;

      if (indexAndName.startInBigNamesContainer() >= bigNamesContainer_.size())
        sanityChecksPass = false;
      if (indexAndName.startInProcessNames() >= processNames_.size())
        sanityChecksPass = false;

      if (indexAndName.startInBigNamesContainer() > maxStart)
        maxStart = indexAndName.startInBigNamesContainer();
      if (indexAndName.startInProcessNames() > maxStartProcess)
        maxStartProcess = indexAndName.startInProcessNames();
    }

    if (!indexAndNames_.empty()) {
      if (bigNamesContainer_.back() != '\0')
        sanityChecksPass = false;
      if (processNames_.back() != '\0')
        sanityChecksPass = false;
      if (maxStart >= bigNamesContainer_.size())
        sanityChecksPass = false;
      unsigned int countZeroes = 0;
      for (unsigned j = maxStart; j < bigNamesContainer_.size(); ++j) {
        if (bigNamesContainer_[j] == '\0') {
          ++countZeroes;
        }
      }
      if (countZeroes != 2)
        sanityChecksPass = false;
      if (maxStartProcess >= processNames_.size())
        sanityChecksPass = false;
      countZeroes = 0;
      for (unsigned j = maxStartProcess; j < processNames_.size(); ++j) {
        if (processNames_[j] == '\0') {
          ++countZeroes;
        }
      }
      if (countZeroes != 1)
        sanityChecksPass = false;
    }

    if (!sanityChecksPass) {
      throw Exception(errors::LogicError) << "ProductResolverIndexHelper::setFrozen - Detected illegal state.\n";
    }
  }

setFrozen()

void edm::ProductResolverIndexHelper::setFrozen

(

)

Definition at line 306 of file ProductResolverIndexHelper.cc.

References beginElements_, bigNamesContainer_, DummyCfis::c, edm::ELEMENT_TYPE, Exception, indexAndNames_, B2GTnPMonitor_cfi::item, items_, dqmiolumiharvest::j, edm::errors::LogicError, lookupProcessNames_, SiStripPI::max, processIndex(), processItems_, processNames_, edm::PRODUCT_TYPE, ranges_, sanityCheck(), sortedTypeIDs_, and AlCaHLTBitMon_QueryRunRegistry::string.

                                             {
    if (!items_)
      return;

    // Make a first pass and count things so we
    // can reserve memory in the vectors. Also
    // fill processItems_ on the first pass.
    bool iFirstThisType = true;
    bool beginElementsWasSet = false;
    TypeID previousTypeID;
    KindOfType previousKindOfType = PRODUCT_TYPE;
    std::string previousModuleLabel;
    std::string previousInstance;
    unsigned int iCountTypes = 0;
    unsigned int iCountCharacters = 0;
    for (auto const& item : *items_) {
      if (iFirstThisType || item.typeID() != previousTypeID || item.kindOfType() != previousKindOfType) {
        ++iCountTypes;
        iFirstThisType = true;

        if (!beginElementsWasSet) {
          if (item.kindOfType() == ELEMENT_TYPE) {
            beginElementsWasSet = true;
          } else {
            beginElements_ = iCountTypes;
          }
        }
      }

      processItems_->insert(item.process());

      if (iFirstThisType || item.moduleLabel() != previousModuleLabel || item.instance() != previousInstance) {
        iCountCharacters += item.moduleLabel().size();
        iCountCharacters += item.instance().size();
        iCountCharacters += 2;
      }

      iFirstThisType = false;
      previousTypeID = item.typeID();
      previousKindOfType = item.kindOfType();
      previousModuleLabel = item.moduleLabel();
      previousInstance = item.instance();
    }

    // Size and fill the process name vector
    unsigned int processNamesSize = 0;
    for (auto const& processItem : *processItems_) {
      processNamesSize += processItem.size();
      ++processNamesSize;
    }
    processNames_.reserve(processNamesSize);
    for (auto const& processItem : *processItems_) {
      for (auto const& c : processItem) {
        processNames_.push_back(c);
      }
      processNames_.push_back('\0');
      lookupProcessNames_.push_back(processItem);
    }

    // Reserve memory in the vectors
    sortedTypeIDs_.reserve(iCountTypes);
    ranges_.reserve(iCountTypes);
    indexAndNames_.reserve(items_->size());
    bigNamesContainer_.reserve(iCountCharacters);

    // Second pass. Really fill the vectors this time.
    bool iFirstType = true;
    iFirstThisType = true;
    previousTypeID = TypeID();
    unsigned int iCount = 0;
    unsigned int iBeginning = 0;
    iCountCharacters = 0;
    unsigned int previousCharacterCount = 0;
    if (!items_->empty()) {
      for (auto const& item : *items_) {
        if (iFirstThisType || item.typeID() != previousTypeID || item.kindOfType() != previousKindOfType) {
          iFirstThisType = true;
          sortedTypeIDs_.push_back(item.typeID());
          if (iFirstType) {
            iFirstType = false;
          } else {
            ranges_.push_back(Range(iBeginning, iCount));
          }
          iBeginning = iCount;
        }
        ++iCount;

        if (iFirstThisType || item.moduleLabel() != previousModuleLabel || item.instance() != previousInstance) {
          unsigned int labelSize = item.moduleLabel().size();
          for (unsigned int j = 0; j < labelSize; ++j) {
            bigNamesContainer_.push_back(item.moduleLabel()[j]);
          }
          bigNamesContainer_.push_back('\0');

          unsigned int instanceSize = item.instance().size();
          for (unsigned int j = 0; j < instanceSize; ++j) {
            bigNamesContainer_.push_back(item.instance()[j]);
          }
          bigNamesContainer_.push_back('\0');

          previousCharacterCount = iCountCharacters;

          iCountCharacters += labelSize;
          iCountCharacters += instanceSize;
          iCountCharacters += 2;
        }

        unsigned int processStart = processIndex(item.process().c_str());
        if (processStart == std::numeric_limits<unsigned int>::max()) {
          throw Exception(errors::LogicError)
              << "ProductResolverIndexHelper::setFrozen - Process not found in processNames_.\n";
        }
        indexAndNames_.emplace_back(item.index(), previousCharacterCount, processStart);

        iFirstThisType = false;
        previousTypeID = item.typeID();
        previousKindOfType = item.kindOfType();
        previousModuleLabel = item.moduleLabel();
        previousInstance = item.instance();
      }
      ranges_.push_back(Range(iBeginning, iCount));
    }

    // Some sanity checks to protect against out of bounds vector accesses
    // These should only fail if there is a bug. If profiling ever shows
    // them to be expensive one might delete them.
    sanityCheck();

    // Cleanup, do not need the temporary containers anymore
    // propagate_const<T> has no reset() function
    items_ = nullptr;
    processItems_ = nullptr;
  }

sortedTypeIDs()

std::vector<TypeID> const& edm::ProductResolverIndexHelper::sortedTypeIDs ( ) const

inline

Definition at line 228 of file ProductResolverIndexHelper.h.

References sortedTypeIDs_.

{ return sortedTypeIDs_; }

Member Data Documentation

beginElements_

unsigned int edm::ProductResolverIndexHelper::beginElements_

private

Definition at line 268 of file ProductResolverIndexHelper.h.

Referenced by beginElements(), indexToType(), indiciesForModulesInProcess(), print(), and setFrozen().

bigNamesContainer_

std::vector<char> edm::ProductResolverIndexHelper::bigNamesContainer_

private

Definition at line 306 of file ProductResolverIndexHelper.h.

Referenced by indexToIndexAndNames(), indiciesForModulesInProcess(), print(), sanityCheck(), and setFrozen().

indexAndNames_

std::vector<IndexAndNames> edm::ProductResolverIndexHelper::indexAndNames_

private

Definition at line 294 of file ProductResolverIndexHelper.h.

Referenced by index(), indexAndNames(), indexToIndexAndNames(), indiciesForModulesInProcess(), edm::ProductResolverIndexHelper::Matches::Matches(), print(), relatedIndexes(), sanityCheck(), and setFrozen().

items_

edm::propagate_const<std::unique_ptr<std::set<Item> > > edm::ProductResolverIndexHelper::items_

private

Definition at line 345 of file ProductResolverIndexHelper.h.

Referenced by insert(), lookupProcessNames(), print(), and setFrozen().

lookupProcessNames_

std::vector<std::string> edm::ProductResolverIndexHelper::lookupProcessNames_

private

Definition at line 311 of file ProductResolverIndexHelper.h.

Referenced by lookupProcessNames(), and setFrozen().

nextIndexValue_

ProductResolverIndex edm::ProductResolverIndexHelper::nextIndexValue_

private

Definition at line 263 of file ProductResolverIndexHelper.h.

Referenced by insert(), nextIndexValue(), print(), and sanityCheck().

processItems_

edm::propagate_const<std::unique_ptr<std::set<std::string> > > edm::ProductResolverIndexHelper::processItems_

private

Definition at line 347 of file ProductResolverIndexHelper.h.

Referenced by print(), and setFrozen().

processNames_

std::vector<char> edm::ProductResolverIndexHelper::processNames_

private

Definition at line 307 of file ProductResolverIndexHelper.h.

Referenced by indiciesForModulesInProcess(), print(), processIndex(), processNames(), sanityCheck(), and setFrozen().

ranges_

std::vector<Range> edm::ProductResolverIndexHelper::ranges_

private

Definition at line 282 of file ProductResolverIndexHelper.h.

Referenced by indexToIndexAndNames(), indiciesForModulesInProcess(), print(), ranges(), relatedIndexes(), sanityCheck(), and setFrozen().

sortedTypeIDs_

std::vector<TypeID> edm::ProductResolverIndexHelper::sortedTypeIDs_

private

Definition at line 275 of file ProductResolverIndexHelper.h.

Referenced by indexToType(), indiciesForModulesInProcess(), print(), sanityCheck(), setFrozen(), and sortedTypeIDs().