#include <EventSetupProvider.h>

Public Types
typedef std::pair< DataType, DataLabel >	DataKeyInfo

typedef std::string	DataLabel

typedef std::string	DataType

typedef std::map< ComponentDescription, RecordToDataMap >	PreferredProviderInfo

typedef std::string	RecordName

typedef std::multimap< RecordName, DataKeyInfo >	RecordToDataMap

Public Member Functions
void	add (std::shared_ptr< ESProductResolverProvider >)

void	add (std::shared_ptr< EventSetupRecordIntervalFinder >)

void	addRecord (const EventSetupRecordKey &iKey)
	Intended for use only in tests. More...

void	checkESProducerSharing (ModuleTypeResolverMaker const resolverMaker, EventSetupProvider &precedingESProvider, std::set< ParameterSetIDHolder > &sharingCheckDone, std::map< EventSetupRecordKey, std::vector< ComponentDescription const >> &referencedESProducers, EventSetupsController &esController)

void	clearInitializationData ()

bool	doRecordsMatch (EventSetupProvider &precedingESProvider, EventSetupRecordKey const &eventSetupRecordKey, std::map< EventSetupRecordKey, bool > &allComponentsMatch, EventSetupsController const &esController)

bool	doWeNeedToWaitForIOVsToFinish (IOVSyncValue const &) const

std::shared_ptr< const EventSetupImpl >	eventSetupForInstance (IOVSyncValue const &, bool &newEventSetupImpl)

EventSetupImpl const &	eventSetupImpl () const

	EventSetupProvider (ActivityRegistry const , unsigned subProcessIndex=0U, PreferredProviderInfo const iInfo=nullptr)

	EventSetupProvider (EventSetupProvider const &)=delete

void	fillKeys (std::set< EventSetupRecordKey > &keys) const

void	fillRecordsNotAllowingConcurrentIOVs (std::set< EventSetupRecordKey > &recordsNotAllowingConcurrentIOVs) const

void	fillReferencedDataKeys (EventSetupRecordKey const &eventSetupRecordKey)

void	finishConfiguration (NumberOfConcurrentIOVs const &, bool &hasNonconcurrentFinder)

void	forceCacheClear ()
	Used when testing that all code properly updates on IOV changes of all Records. More...

EventSetupProvider const &	operator= (EventSetupProvider const &)=delete

ESRecordsToProductResolverIndices	recordsToResolverIndices () const

void	replaceExisting (std::shared_ptr< ESProductResolverProvider >)

void	resetRecordPlusDependentRecords (EventSetupRecordKey const &)
	Used when we need to force a Record to reset all its proxies. More...

void	resetRecordToResolverPointers ()

std::set< ComponentDescription >	resolverProviderDescriptions () const

void	setAllValidityIntervals (const IOVSyncValue &iValue)
	Set the validity intervals in all EventSetupRecordProviders. More...

void	setPreferredProviderInfo (PreferredProviderInfo const &iInfo)

unsigned	subProcessIndex () const

EventSetupRecordProvider *	tryToGetRecordProvider (const EventSetupRecordKey &iKey)

	~EventSetupProvider ()

Static Public Member Functions
static void	logInfoWhenSharing (ParameterSet const &iConfiguration)

Private Types
using	RecordKeys = std::vector< EventSetupRecordKey >

using	RecordProviders = std::vector< std::shared_ptr< EventSetupRecordProvider > >

Private Member Functions
void	determinePreferred ()

void	insert (EventSetupRecordKey const &, std::unique_ptr< EventSetupRecordProvider >)

std::shared_ptr< EventSetupRecordProvider > &	recordProvider (const EventSetupRecordKey &iKey)

Private Attributes
ActivityRegistry const *	activityRegistry_

std::unique_ptr< std::vector< std::shared_ptr< ESProductResolverProvider > > >	dataProviders_

propagate_const< std::shared_ptr< EventSetupImpl > >	eventSetupImpl_

std::unique_ptr< std::vector< std::shared_ptr< EventSetupRecordIntervalFinder > > >	finders_

bool	mustFinishConfiguration_

std::unique_ptr< PreferredProviderInfo >	preferredProviderInfo_

std::unique_ptr< std::map< ParameterSetIDHolder, std::set< EventSetupRecordKey > > >	psetIDToRecordKey_

RecordKeys	recordKeys_

RecordProviders	recordProviders_

std::unique_ptr< std::set< EventSetupRecordKey > >	recordsWithALooperResolver_

std::unique_ptr< std::map< EventSetupRecordKey, std::vector< std::shared_ptr< EventSetupRecordIntervalFinder > > > >	recordToFinders_

std::unique_ptr< std::map< EventSetupRecordKey, std::map< DataKey, ComponentDescription > > >	recordToPreferred_

std::unique_ptr< std::map< EventSetupRecordKey, std::map< DataKey, ComponentDescription const * > > >	referencedDataKeys_

unsigned	subProcessIndex_

Detailed Description

Description: Factory for a EventSetup

Usage: <usage>

Definition at line 50 of file EventSetupProvider.h.

Member Typedef Documentation

◆ DataKeyInfo

typedef std::pair<DataType, DataLabel> edm::eventsetup::EventSetupProvider::DataKeyInfo

Definition at line 55 of file EventSetupProvider.h.

◆ DataLabel

typedef std::string edm::eventsetup::EventSetupProvider::DataLabel

Definition at line 54 of file EventSetupProvider.h.

◆ DataType

typedef std::string edm::eventsetup::EventSetupProvider::DataType

Definition at line 53 of file EventSetupProvider.h.

◆ PreferredProviderInfo

typedef std::map<ComponentDescription, RecordToDataMap> edm::eventsetup::EventSetupProvider::PreferredProviderInfo

Definition at line 57 of file EventSetupProvider.h.

◆ RecordKeys

using edm::eventsetup::EventSetupProvider::RecordKeys = std::vector<EventSetupRecordKey>

private

Definition at line 132 of file EventSetupProvider.h.

◆ RecordName

typedef std::string edm::eventsetup::EventSetupProvider::RecordName

Definition at line 52 of file EventSetupProvider.h.

◆ RecordProviders

using edm::eventsetup::EventSetupProvider::RecordProviders = std::vector<std::shared_ptr<EventSetupRecordProvider> >

private

Definition at line 135 of file EventSetupProvider.h.

◆ RecordToDataMap

typedef std::multimap<RecordName, DataKeyInfo> edm::eventsetup::EventSetupProvider::RecordToDataMap

Definition at line 56 of file EventSetupProvider.h.

Constructor & Destructor Documentation

◆ EventSetupProvider() [1/2]

edm::eventsetup::EventSetupProvider::EventSetupProvider	(	ActivityRegistry const *	activityRegistry,
		unsigned	subProcessIndex = `0U`,
		PreferredProviderInfo const *	iInfo = `nullptr`
	)

Definition at line 41 of file EventSetupProvider.cc.

         : activityRegistry_(activityRegistry),
           mustFinishConfiguration_(true),
           subProcessIndex_(subProcessIndex),
           preferredProviderInfo_((nullptr != iInfo) ? (new PreferredProviderInfo(*iInfo)) : nullptr),
           finders_(new std::vector<std::shared_ptr<EventSetupRecordIntervalFinder>>()),
           dataProviders_(new std::vector<std::shared_ptr<ESProductResolverProvider>>()),
           referencedDataKeys_(new std::map<EventSetupRecordKey, std::map<DataKey, ComponentDescription const*>>),
           recordToFinders_(
               new std::map<EventSetupRecordKey, std::vector<std::shared_ptr<EventSetupRecordIntervalFinder>>>),
           psetIDToRecordKey_(new std::map<ParameterSetIDHolder, std::set<EventSetupRecordKey>>),
           recordToPreferred_(new std::map<EventSetupRecordKey, std::map<DataKey, ComponentDescription>>),
           recordsWithALooperResolver_(new std::set<EventSetupRecordKey>) {}

◆ EventSetupProvider() [2/2]

edm::eventsetup::EventSetupProvider::EventSetupProvider ( EventSetupProvider const & )

delete

◆ ~EventSetupProvider()

edm::eventsetup::EventSetupProvider::~EventSetupProvider ( )

Definition at line 57 of file EventSetupProvider.cc.

References forceCacheClear().

57 { forceCacheClear(); }

edm::eventsetup::EventSetupProvider::forceCacheClear

void forceCacheClear()

Used when testing that all code properly updates on IOV changes of all Records.

Definition: EventSetupProvider.cc:392

Member Function Documentation

◆ add() [1/2]

void edm::eventsetup::EventSetupProvider::add ( std::shared_ptr< ESProductResolverProvider > iProvider )

Definition at line 90 of file EventSetupProvider.cc.

References activityRegistry_, cms::cuda::assert(), dataProviders_, and edm::ActivityRegistry::postESModuleRegistrationSignal_.

Referenced by edm::eventsetup::looper::addFinderTo(), edm::eventsetup::addProviderTo(), edm::eventsetup::looper::addProviderTo(), edm::eventsetup::ModuleMakerTraits::addTo(), edm::eventsetup::SourceMakerTraits::addTo(), counter.Counter::register(), SequenceTypes._TaskBase::remove(), and SequenceTypes._TaskBase::replace().

                                                                                    {
       assert(iProvider.get() != nullptr);
       dataProviders_->push_back(iProvider);
       if (activityRegistry_) {
         activityRegistry_->postESModuleRegistrationSignal_(iProvider->description());
       }
     }

◆ add() [2/2]

void edm::eventsetup::EventSetupProvider::add ( std::shared_ptr< EventSetupRecordIntervalFinder > iFinder )

Definition at line 106 of file EventSetupProvider.cc.

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

Referenced by counter.Counter::register(), SequenceTypes._TaskBase::remove(), and SequenceTypes._TaskBase::replace().

                                                                                       {
       assert(iFinder.get() != nullptr);
       finders_->push_back(iFinder);
     }

◆ addRecord()

void edm::eventsetup::EventSetupProvider::addRecord ( const EventSetupRecordKey & iKey )

Intended for use only in tests.

Definition at line 745 of file EventSetupProvider.cc.

References eventSetupImpl_, insert(), and recordKeys_.

                                                                       {
       insert(iKey, std::unique_ptr<EventSetupRecordProvider>());
       eventSetupImpl_->setKeyIters(recordKeys_.begin(), recordKeys_.end());
     }

◆ checkESProducerSharing()

void edm::eventsetup::EventSetupProvider::checkESProducerSharing	(	ModuleTypeResolverMaker const *	resolverMaker,
		EventSetupProvider &	precedingESProvider,
		std::set< ParameterSetIDHolder > &	sharingCheckDone,
		std::map< EventSetupRecordKey, std::vector< ComponentDescription const *>> &	referencedESProducers,
		EventSetupsController &	esController
	)

Definition at line 400 of file EventSetupProvider.cc.

References cms::cuda::assert(), doRecordsMatch(), edm::eventsetup::ComponentFactory< T >::get(), edm::eventsetup::EventSetupsController::getESProducerPSet(), edm::eventsetup::EventSetupsController::isFirstMatch(), edm::eventsetup::EventSetupsController::isLastMatch(), submitPVResolutionJobs::key, logInfoWhenSharing(), edm::eventsetup::EventSetupsController::lookForMatches(), muonDTDigis_cfi::pset, psetIDToRecordKey_, recordProvider(), recordProviders_, subProcessIndex(), and subProcessIndex_.

                                              {
       edm::LogVerbatim("EventSetupSharing")
           << "EventSetupProvider::checkESProducerSharing: Checking processes with SubProcess Indexes "
           << subProcessIndex() << " and " << precedingESProvider.subProcessIndex();
 
       if (referencedESProducers.empty()) {
         for (auto& recProvider : recordProviders_) {
           recProvider->getReferencedESProducers(referencedESProducers);
         }
       }
 
       // This records whether the configurations of all the ESProductResolverProviders
       // and finders matches for a particular pair of processes and
       // a particular record and also the records it depends on.
       std::map<EventSetupRecordKey, bool> allComponentsMatch;
 
       std::map<ParameterSetID, bool> candidateNotRejectedYet;
 
       // Loop over all the ESProducers which have a ESProductResolver
       // referenced by any EventSetupRecord in this EventSetupProvider
       for (auto const& iRecord : referencedESProducers) {
         for (auto const& iComponent : iRecord.second) {
           ParameterSetID const& psetID = iComponent->pid_;
           ParameterSetIDHolder psetIDHolder(psetID);
           if (sharingCheckDone.find(psetIDHolder) != sharingCheckDone.end())
             continue;
 
           bool firstProcessWithThisPSet = false;
           bool precedingHasMatchingPSet = false;
 
           esController.lookForMatches(psetID,
                                       subProcessIndex_,
                                       precedingESProvider.subProcessIndex_,
                                       firstProcessWithThisPSet,
                                       precedingHasMatchingPSet);
 
           if (firstProcessWithThisPSet) {
             sharingCheckDone.insert(psetIDHolder);
             allComponentsMatch[iRecord.first] = false;
             continue;
           }
 
           if (!precedingHasMatchingPSet) {
             allComponentsMatch[iRecord.first] = false;
             continue;
           }
 
           // An ESProducer that survives to this point is a candidate.
           // It was shared with some other process in the first pass where
           // ESProducers were constructed and one of three possibilities exists:
           //    1) It should not have been shared and a new ESProducer needs
           //    to be created and the proper pointers set.
           //    2) It should have been shared with a different preceding process
           //    in which case some pointers need to be modified.
           //    3) It was originally shared which the correct prior process
           //    in which case nothing needs to be done, but we do need to
           //    do some work to verify that.
           // Make an entry in a map for each of these ESProducers. We
           // will set the value to false if and when we determine
           // the ESProducer cannot be shared between this pair of processes.
           auto iCandidateNotRejectedYet = candidateNotRejectedYet.find(psetID);
           if (iCandidateNotRejectedYet == candidateNotRejectedYet.end()) {
             candidateNotRejectedYet[psetID] = true;
             iCandidateNotRejectedYet = candidateNotRejectedYet.find(psetID);
           }
 
           // At this point we know that the two processes both
           // have an ESProducer matching the type and label in
           // iComponent and also with exactly the same configuration.
           // And there was not an earlier preceding process
           // where the same instance of the ESProducer could
           // have been shared.  And this ESProducer was referenced
           // by the later process's EventSetupRecord (preferred or
           // or just the only thing that could have made the data).
           // To determine if sharing is allowed, now we need to
           // check if all the ESProductResolverProviders and all the
           // finders are the same for this record and also for
           // all records this record depends on. And even
           // if this is true, we have to wait until the loop
           // ends because some other ESProductResolver associated with
           // the ESProducer could write to a different record where
           // the same determination will need to be repeated. Only if
           // all of the the ESProductResolver's can be shared, can the ESProducer
           // instance be shared across processes.
 
           if (iCandidateNotRejectedYet->second == true) {
             auto iAllComponentsMatch = allComponentsMatch.find(iRecord.first);
             if (iAllComponentsMatch == allComponentsMatch.end()) {
               // We do not know the value in AllComponents yet and
               // we need it now so we have to do the difficult calculation
               // now.
               bool match = doRecordsMatch(precedingESProvider, iRecord.first, allComponentsMatch, esController);
               allComponentsMatch[iRecord.first] = match;
               iAllComponentsMatch = allComponentsMatch.find(iRecord.first);
             }
             if (!iAllComponentsMatch->second) {
               iCandidateNotRejectedYet->second = false;
             }
           }
         }  // end loop over components used by record
       }    // end loop over records
 
       // Loop over candidates
       for (auto const& candidate : candidateNotRejectedYet) {
         ParameterSetID const& psetID = candidate.first;
         bool canBeShared = candidate.second;
         if (canBeShared) {
           ParameterSet const& pset = esController.getESProducerPSet(psetID, subProcessIndex_);
           logInfoWhenSharing(pset);
           ParameterSetIDHolder psetIDHolder(psetID);
           sharingCheckDone.insert(psetIDHolder);
           if (esController.isFirstMatch(psetID, subProcessIndex_, precedingESProvider.subProcessIndex_)) {
             continue;  // Proper sharing was already done. Nothing more to do.
           }
 
           // Need to reset the pointer from the EventSetupRecordProvider to the
           // the ESProductResolverProvider so these two processes share an ESProducer.
 
           std::shared_ptr<ESProductResolverProvider> productResolverProvider;
           std::set<EventSetupRecordKey> const& keysForPSetID1 = (*precedingESProvider.psetIDToRecordKey_)[psetIDHolder];
           for (auto const& key : keysForPSetID1) {
             productResolverProvider = precedingESProvider.recordProvider(key)->resolverProvider(psetIDHolder);
             assert(productResolverProvider);
             break;
           }
 
           std::set<EventSetupRecordKey> const& keysForPSetID2 = (*psetIDToRecordKey_)[psetIDHolder];
           for (auto const& key : keysForPSetID2) {
             recordProvider(key)->resetProductResolverProvider(psetIDHolder, productResolverProvider);
           }
         } else {
           if (esController.isLastMatch(psetID, subProcessIndex_, precedingESProvider.subProcessIndex_)) {
             ParameterSet& pset = esController.getESProducerPSet(psetID, subProcessIndex_);
             ModuleFactory::get()->addTo(esController, *this, pset, resolverMaker, true);
           }
         }
       }
     }

◆ clearInitializationData()

void edm::eventsetup::EventSetupProvider::clearInitializationData ( )

Definition at line 651 of file EventSetupProvider.cc.

References preferredProviderInfo_, psetIDToRecordKey_, recordsWithALooperResolver_, recordToFinders_, recordToPreferred_, and referencedDataKeys_.

                                                      {
       preferredProviderInfo_.reset();
       referencedDataKeys_.reset();
       recordToFinders_.reset();
       psetIDToRecordKey_.reset();
       recordToPreferred_.reset();
       recordsWithALooperResolver_.reset();
     }

◆ determinePreferred()

void edm::eventsetup::EventSetupProvider::determinePreferred ( )

private

Definition at line 163 of file EventSetupProvider.cc.

References makeMuonMisalignmentScenario::components, edm::eventsetup::ESProductResolverProvider::KeyedResolvers::contains(), Exception, edm::eventsetup::heterocontainer::HCTypeTag::findType(), edm::eventsetup::preferEverything(), preferredProviderInfo_, align_cfg::recordName, recordProvider(), recordProviders_, recordToPreferred_, edm::eventsetup::EventSetupRecordProvider::resolverProvider(), edm::eventsetup::EventSetupRecordProvider::resolverProviderDescriptions(), AlCaHLTBitMon_QueryRunRegistry::string, and edm::eventsetup::EventSetupRecordKey::type().

Referenced by finishConfiguration().

                                                 {
       using namespace edm::eventsetup;
       if (preferredProviderInfo_) {
         for (auto const& itInfo : *preferredProviderInfo_) {
           if (itInfo.second.empty()) {
             //want everything
             preferEverything(itInfo.first, recordProviders_, *recordToPreferred_);
           } else {
             for (auto const& itRecData : itInfo.second) {
               std::string recordName = itRecData.first;
               EventSetupRecordKey recordKey(eventsetup::EventSetupRecordKey::TypeTag::findType(recordName));
               if (recordKey.type() == eventsetup::EventSetupRecordKey::TypeTag()) {
                 throw cms::Exception("ESPreferUnknownRecord")
                     << "Unknown record \"" << recordName
                     << "\" used in es_prefer statement for type=" << itInfo.first.type_ << " label=\""
                     << itInfo.first.label_ << "\"\n Please check spelling.";
                 //record not found
               }
               //See if the ResolverProvider provides something for this Record
               EventSetupRecordProvider& recordProviderForKey = *recordProvider(recordKey);
 
               std::set<ComponentDescription> components = recordProviderForKey.resolverProviderDescriptions();
               std::set<ComponentDescription>::iterator itResolverProv = components.find(itInfo.first);
               if (itResolverProv == components.end()) {
                 throw cms::Exception("ESPreferWrongRecord")
                     << "The type=" << itInfo.first.type_ << " label=\"" << itInfo.first.label_
                     << "\" does not provide data for the Record " << recordName;
               }
               //Does it data type exist?
               eventsetup::TypeTag datumType = eventsetup::TypeTag::findType(itRecData.second.first);
               if (datumType == eventsetup::TypeTag()) {
                 //not found
                 throw cms::Exception("ESPreferWrongDataType")
                     << "The es_prefer statement for type=" << itInfo.first.type_ << " label=\"" << itInfo.first.label_
                     << "\" has the unknown data type \"" << itRecData.second.first << "\""
                     << "\n Please check spelling";
               }
               eventsetup::DataKey datumKey(datumType, itRecData.second.second.c_str());
 
               //Does the resolverprovider make this?
               std::shared_ptr<ESProductResolverProvider> resolverProv =
                   recordProviderForKey.resolverProvider(*itResolverProv);
               unsigned int iovIndex = 0;  // Doesn't matter which index is picked, at least 1 should always exist
               const ESProductResolverProvider::KeyedResolvers& keyedResolvers =
                   resolverProv->keyedResolvers(recordKey, iovIndex);
               if (!keyedResolvers.contains(datumKey)) {
                 throw cms::Exception("ESPreferWrongData")
                     << "The es_prefer statement for type=" << itInfo.first.type_ << " label=\"" << itInfo.first.label_
                     << "\" specifies the data item \n"
                     << "  type=\"" << itRecData.second.first << "\" label=\"" << itRecData.second.second << "\""
                     << "  which is not provided.  Please check spelling.";
               }
 
               EventSetupRecordProvider::DataToPreferredProviderMap& dataToProviderMap =
                   (*recordToPreferred_)[recordKey];
               //has another provider already been specified?
               if (dataToProviderMap.end() != dataToProviderMap.find(datumKey)) {
                 EventSetupRecordProvider::DataToPreferredProviderMap::iterator itFind =
                     dataToProviderMap.find(datumKey);
                 throw cms::Exception("ESPreferConflict")
                     << "Two providers have been set to be preferred for\n"
                     << datumKey.type().name() << " \"" << datumKey.name().value() << "\""
                     << "\n the providers are "
                     << "\n 1) type=" << itFind->second.type_ << " label=\"" << itFind->second.label_ << "\""
                     << "\n 2) type=" << itResolverProv->type_ << " label=\"" << itResolverProv->label_ << "\""
                     << "\nPlease modify configuration so only one is preferred";
               }
               dataToProviderMap.insert(std::make_pair(datumKey, *itResolverProv));
             }
           }
         }
       }
     }

◆ doRecordsMatch()

bool edm::eventsetup::EventSetupProvider::doRecordsMatch	(	EventSetupProvider &	precedingESProvider,
		EventSetupRecordKey const &	eventSetupRecordKey,
		std::map< EventSetupRecordKey, bool > &	allComponentsMatch,
		EventSetupsController const &	esController
	)

Definition at line 544 of file EventSetupProvider.cc.

References edm::eventsetup::EventSetupRecordProvider::dependentRecords(), fillReferencedDataKeys(), HLT_2024v10_cff::finder, edm::eventsetup::EventSetupsController::isMatchingESProducer(), edm::eventsetup::EventSetupsController::isMatchingESSource(), recordsWithALooperResolver_, recordToFinders_, referencedDataKeys_, subProcessIndex_, and tryToGetRecordProvider().

Referenced by checkESProducerSharing().

                                                                                        {
       // first check if this record matches. If not just return false
 
       // then find the directly dependent records and iterate over them
       // recursively call this function on them. If they return false
       // set allComponentsMatch to false for them and return false.
       // if they all return true then set allComponents to true
       // and return true.
 
       if (precedingESProvider.recordsWithALooperResolver_->find(eventSetupRecordKey) !=
           precedingESProvider.recordsWithALooperResolver_->end()) {
         return false;
       }
 
       if ((*recordToFinders_)[eventSetupRecordKey].size() !=
           (*precedingESProvider.recordToFinders_)[eventSetupRecordKey].size()) {
         return false;
       }
 
       for (auto const& finder : (*recordToFinders_)[eventSetupRecordKey]) {
         ParameterSetID const& psetID = finder->descriptionForFinder().pid_;
         bool itMatches =
             esController.isMatchingESSource(psetID, subProcessIndex_, precedingESProvider.subProcessIndex_);
         if (!itMatches) {
           return false;
         }
       }
 
       fillReferencedDataKeys(eventSetupRecordKey);
       precedingESProvider.fillReferencedDataKeys(eventSetupRecordKey);
 
       std::map<DataKey, ComponentDescription const*> const& dataItems = (*referencedDataKeys_)[eventSetupRecordKey];
 
       std::map<DataKey, ComponentDescription const*> const& precedingDataItems =
           (*precedingESProvider.referencedDataKeys_)[eventSetupRecordKey];
 
       if (dataItems.size() != precedingDataItems.size()) {
         return false;
       }
 
       for (auto const& dataItem : dataItems) {
         auto precedingDataItem = precedingDataItems.find(dataItem.first);
         if (precedingDataItem == precedingDataItems.end()) {
           return false;
         }
         if (dataItem.second->pid_ != precedingDataItem->second->pid_) {
           return false;
         }
         // Check that the configurations match exactly for the ESProducers
         // (We already checked the ESSources above and there should not be
         // any loopers)
         if (!dataItem.second->isSource_ && !dataItem.second->isLooper_) {
           bool itMatches = esController.isMatchingESProducer(
               dataItem.second->pid_, subProcessIndex_, precedingESProvider.subProcessIndex_);
           if (!itMatches) {
             return false;
           }
         }
       }
       EventSetupRecordProvider* recProvider = tryToGetRecordProvider(eventSetupRecordKey);
       if (recProvider != nullptr) {
         std::set<EventSetupRecordKey> dependentRecords = recProvider->dependentRecords();
         for (auto const& dependentRecord : dependentRecords) {
           auto iter = allComponentsMatch.find(dependentRecord);
           if (iter != allComponentsMatch.end()) {
             if (iter->second) {
               continue;
             } else {
               return false;
             }
           }
           bool match = doRecordsMatch(precedingESProvider, dependentRecord, allComponentsMatch, esController);
           allComponentsMatch[dependentRecord] = match;
           if (!match)
             return false;
         }
       }
       return true;
     }

◆ doWeNeedToWaitForIOVsToFinish()

bool edm::eventsetup::EventSetupProvider::doWeNeedToWaitForIOVsToFinish ( IOVSyncValue const & iValue ) const

Definition at line 719 of file EventSetupProvider.cc.

References recordProviders_.

                                                                                            {
       for (auto& recProvider : recordProviders_) {
         if (recProvider->doWeNeedToWaitForIOVsToFinish(iValue)) {
           return true;
         }
       }
       return false;
     }

◆ eventSetupForInstance()

std::shared_ptr< const EventSetupImpl > edm::eventsetup::EventSetupProvider::eventSetupForInstance	(	IOVSyncValue const &	iValue,
		bool &	newEventSetupImpl
	)

Definition at line 680 of file EventSetupProvider.cc.

References eventSetupImpl_, edm::get_underlying_safe(), DetStateFilter::Invalid, recordKeys_, and recordProviders_.

                                                                                                              {
       using IntervalStatus = EventSetupRecordProvider::IntervalStatus;
 
       // It is important to understand that eventSetupForInstance is a function
       // where only one call is executing at a time (not multiple calls running
       // concurrently). These calls are made in the order determined by the
       // InputSource. One invocation completes and returns before another starts.
 
       bool needNewEventSetupImpl = false;
       if (eventSetupImpl_.get() == nullptr) {
         needNewEventSetupImpl = true;
       } else {
         for (auto& recProvider : recordProviders_) {
           if (recProvider->intervalStatus() == IntervalStatus::Invalid) {
             if (eventSetupImpl_->validRecord(recProvider->key())) {
               needNewEventSetupImpl = true;
             }
           } else {
             if (recProvider->newIntervalForAnySubProcess()) {
               needNewEventSetupImpl = true;
             }
           }
         }
       }
 
       if (needNewEventSetupImpl) {
         //cannot use make_shared because constructor is private
         eventSetupImpl_ = std::shared_ptr<EventSetupImpl>(new EventSetupImpl());
         newEventSetupImpl = true;
         eventSetupImpl_->setKeyIters(recordKeys_.begin(), recordKeys_.end());
 
         for (auto& recProvider : recordProviders_) {
           recProvider->setEventSetupImpl(eventSetupImpl_.get());
         }
       }
       return get_underlying_safe(eventSetupImpl_);
     }

◆ eventSetupImpl()

EventSetupImpl const& edm::eventsetup::EventSetupProvider::eventSetupImpl ( ) const

inline

Definition at line 78 of file EventSetupProvider.h.

References eventSetupImpl_.

78 { return *eventSetupImpl_; }

edm::eventsetup::EventSetupProvider::eventSetupImpl_

propagate_const< std::shared_ptr< EventSetupImpl > > eventSetupImpl_

Definition: EventSetupProvider.h:142

◆ fillKeys()

void edm::eventsetup::EventSetupProvider::fillKeys ( std::set< EventSetupRecordKey > & keys ) const

Definition at line 754 of file EventSetupProvider.cc.

References relativeConstraints::keys, and recordProviders_.

                                                                              {
       for (auto const& recProvider : recordProviders_) {
         keys.insert(recProvider->key());
       }
     }

◆ fillRecordsNotAllowingConcurrentIOVs()

void edm::eventsetup::EventSetupProvider::fillRecordsNotAllowingConcurrentIOVs ( std::set< EventSetupRecordKey > & recordsNotAllowingConcurrentIOVs ) const

Definition at line 660 of file EventSetupProvider.cc.

References dataProviders_.

Referenced by edm::eventsetup::NumberOfConcurrentIOVs::fillRecordsNotAllowingConcurrentIOVs().

                                                                              {
       for (auto const& productResolverProvider : *dataProviders_) {
         productResolverProvider->fillRecordsNotAllowingConcurrentIOVs(recordsNotAllowingConcurrentIOVs);
       }
     }

◆ fillReferencedDataKeys()

void edm::eventsetup::EventSetupProvider::fillReferencedDataKeys ( EventSetupRecordKey const & eventSetupRecordKey )

Definition at line 627 of file EventSetupProvider.cc.

References edm::eventsetup::EventSetupRecordProvider::fillReferencedDataKeys(), referencedDataKeys_, and tryToGetRecordProvider().

Referenced by doRecordsMatch().

                                                                                                   {
       if (referencedDataKeys_->find(eventSetupRecordKey) != referencedDataKeys_->end())
         return;
 
       EventSetupRecordProvider* recProvider = tryToGetRecordProvider(eventSetupRecordKey);
       if (recProvider == nullptr) {
         (*referencedDataKeys_)[eventSetupRecordKey];
         return;
       }
       recProvider->fillReferencedDataKeys((*referencedDataKeys_)[eventSetupRecordKey]);
     }

◆ finishConfiguration()

void edm::eventsetup::EventSetupProvider::finishConfiguration	(	NumberOfConcurrentIOVs const &	numberOfConcurrentIOVs,
		bool &	hasNonconcurrentFinder
	)

Definition at line 237 of file EventSetupProvider.cc.

References activityRegistry_, edm::eventsetup::EventSetupRecordProvider::add(), edm::eventsetup::EventSetupRecordProvider::addFinder(), dataProviders_, determinePreferred(), HLT_2024v10_cff::distance, HLT_2024v10_cff::finder, finders_, dqmdumpme::indices, insert(), submitPVResolutionJobs::key, pfDeepBoostedJetPreprocessParams_cfi::lower_bound, mustFinishConfiguration_, options_cfi::numberOfConcurrentIOVs, psetIDToRecordKey_, recordKeys_, recordProviders_, recordsToResolverIndices(), recordsWithALooperResolver_, recordToFinders_, recordToPreferred_, AlCaHLTBitMon_QueryRunRegistry::string, and tryToGetRecordProvider().

                                                                                {
       //we delayed adding finders to the system till here so that everything would be loaded first
       recordToFinders_->clear();
       for (auto& finder : *finders_) {
         if (!finder->concurrentFinder()) {
           hasNonconcurrentFinder = true;
         }
 
         const std::set<EventSetupRecordKey> recordsUsing = finder->findingForRecords();
 
         for (auto const& key : recordsUsing) {
           (*recordToFinders_)[key].push_back(finder);
 
           EventSetupRecordProvider* recProvider = tryToGetRecordProvider(key);
           if (recProvider == nullptr) {
             bool printInfoMsg = true;
             unsigned int nConcurrentIOVs = numberOfConcurrentIOVs.numberOfConcurrentIOVs(key, printInfoMsg);
 
             //create a provider for this record
             insert(key, std::make_unique<EventSetupRecordProvider>(key, activityRegistry_, nConcurrentIOVs));
             recProvider = tryToGetRecordProvider(key);
           }
           recProvider->addFinder(finder);
         }
       }
       //we've transfered our ownership so this is no longer needed
       finders_.reset();
 
       //Now handle providers since sources can also be finders and the sources can delay registering
       // their Records and therefore could delay setting up their Proxies
       psetIDToRecordKey_->clear();
       for (auto& productResolverProvider : *dataProviders_) {
         ParameterSetIDHolder psetID(productResolverProvider->description().pid_);
 
         const std::set<EventSetupRecordKey> recordsUsing = productResolverProvider->usingRecords();
         for (auto const& key : recordsUsing) {
           unsigned int nConcurrentIOVs = numberOfConcurrentIOVs.numberOfConcurrentIOVs(key);
           productResolverProvider->createKeyedResolvers(key, nConcurrentIOVs);
 
           if (productResolverProvider->description().isLooper_) {
             recordsWithALooperResolver_->insert(key);
           }
 
           (*psetIDToRecordKey_)[psetID].insert(key);
 
           EventSetupRecordProvider* recProvider = tryToGetRecordProvider(key);
           if (recProvider == nullptr) {
             bool printInfoMsg = true;
             nConcurrentIOVs = numberOfConcurrentIOVs.numberOfConcurrentIOVs(key, printInfoMsg);
             //create a provider for this record
             insert(key, std::make_unique<EventSetupRecordProvider>(key, activityRegistry_, nConcurrentIOVs));
             recProvider = tryToGetRecordProvider(key);
           }
           recProvider->add(productResolverProvider);
         }
       }
 
       //used for the case where no preferred Providers have been specified for the Record
       static const EventSetupRecordProvider::DataToPreferredProviderMap kEmptyMap;
 
       determinePreferred();
 
       //For each Provider, find all the Providers it depends on.  If a dependent Provider
       // can not be found pass in an empty list
       //CHANGE: now allow for missing Providers
       for (auto& itRecordProvider : recordProviders_) {
         const EventSetupRecordProvider::DataToPreferredProviderMap* preferredInfo = &kEmptyMap;
         RecordToPreferred::const_iterator itRecordFound = recordToPreferred_->find(itRecordProvider->key());
         if (itRecordFound != recordToPreferred_->end()) {
           preferredInfo = &(itRecordFound->second);
         }
         //Give it our list of preferred
         itRecordProvider->usePreferred(*preferredInfo);
 
         std::set<EventSetupRecordKey> records = itRecordProvider->dependentRecords();
         if (!records.empty()) {
           std::string missingRecords;
           std::vector<std::shared_ptr<EventSetupRecordProvider>> depProviders;
           depProviders.reserve(records.size());
           bool foundAllProviders = true;
           for (auto const& key : records) {
             auto lb = std::lower_bound(recordKeys_.begin(), recordKeys_.end(), key);
             if (lb == recordKeys_.end() || key != *lb) {
               foundAllProviders = false;
               if (missingRecords.empty()) {
                 missingRecords = key.name();
               } else {
                 missingRecords += ", ";
                 missingRecords += key.name();
               }
             } else {
               auto index = std::distance(recordKeys_.begin(), lb);
               depProviders.push_back(recordProviders_[index]);
             }
           }
 
           if (!foundAllProviders) {
             edm::LogInfo("EventSetupDependency")
                 << "The EventSetup record " << itRecordProvider->key().name() << " depends on at least one Record \n ("
                 << missingRecords
                 << ") which is not present in the job."
                    "\n This may lead to an exception begin thrown during event processing.\n If no exception occurs "
                    "during the job than it is usually safe to ignore this message.";
 
             //depProviders.clear();
             //NOTE: should provide a warning
           }
 
           itRecordProvider->setDependentProviders(depProviders);
         }
       }
 
       auto indices = recordsToResolverIndices();
       for (auto& provider : *dataProviders_) {
         provider->updateLookup(indices);
       }
       dataProviders_.reset();
 
       mustFinishConfiguration_ = false;
     }

◆ forceCacheClear()

void edm::eventsetup::EventSetupProvider::forceCacheClear ( )

Used when testing that all code properly updates on IOV changes of all Records.

Definition at line 392 of file EventSetupProvider.cc.

References recordProviders_.

Referenced by ~EventSetupProvider().

                                              {
       for (auto& recProvider : recordProviders_) {
         if (recProvider) {
           recProvider->resetProxies();
         }
       }
     }

◆ insert()

void edm::eventsetup::EventSetupProvider::insert	(	EventSetupRecordKey const &	iKey,
		std::unique_ptr< EventSetupRecordProvider >	iProvider
	)

private

Definition at line 78 of file EventSetupProvider.cc.

References HLT_2024v10_cff::distance, pfDeepBoostedJetPreprocessParams_cfi::lower_bound, eostools::move(), recordKeys_, and recordProviders_.

Referenced by SequenceTypes.Schedule::_replaceIfHeldDirectly(), addRecord(), and finishConfiguration().

                                                                                        {
       auto lb = std::lower_bound(recordKeys_.begin(), recordKeys_.end(), iKey);
       auto index = std::distance(recordKeys_.begin(), lb);
       if (lb == recordKeys_.end() || iKey != *lb) {
         recordKeys_.insert(lb, iKey);
         recordProviders_.insert(recordProviders_.begin() + index, std::move(iProvider));
       } else {
         recordProviders_[index] = std::move(iProvider);
       }
     }

◆ logInfoWhenSharing()

void edm::eventsetup::EventSetupProvider::logInfoWhenSharing ( ParameterSet const & iConfiguration )

static

Definition at line 775 of file EventSetupProvider.cc.

References edm::ParameterSet::getParameter(), label, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by checkESProducerSharing().

                                                                                   {
       std::string edmtype = iConfiguration.getParameter<std::string>("@module_edm_type");
       std::string modtype = iConfiguration.getParameter<std::string>("@module_type");
       std::string label = iConfiguration.getParameter<std::string>("@module_label");
       edm::LogVerbatim("EventSetupSharing")
           << "Sharing " << edmtype << ": class=" << modtype << " label='" << label << "'";
     }

◆ operator=()

EventSetupProvider const& edm::eventsetup::EventSetupProvider::operator= ( EventSetupProvider const & )

delete

◆ recordProvider()

std::shared_ptr< EventSetupRecordProvider > & edm::eventsetup::EventSetupProvider::recordProvider ( const EventSetupRecordKey & iKey )

private

Definition at line 59 of file EventSetupProvider.cc.

References HLT_2024v10_cff::distance, Exception, pfDeepBoostedJetPreprocessParams_cfi::lower_bound, recordKeys_, and recordProviders_.

Referenced by checkESProducerSharing(), determinePreferred(), and replaceExisting().

                                                                                                                {
       auto lb = std::lower_bound(recordKeys_.begin(), recordKeys_.end(), iKey);
       if (lb == recordKeys_.end() || iKey != *lb) {
         throw cms::Exception("LogicError") << "EventSetupProvider::recordProvider Could not find key\n"
                                            << "Should be impossible. Please contact Framework developer.\n";
       }
       auto index = std::distance(recordKeys_.begin(), lb);
       return recordProviders_[index];
     }

◆ recordsToResolverIndices()

ESRecordsToProductResolverIndices edm::eventsetup::EventSetupProvider::recordsToResolverIndices ( ) const

Definition at line 760 of file EventSetupProvider.cc.

References recordKeys_, recordProviders_, and runTheMatrix::ret.

Referenced by finishConfiguration().

                                                                                          {
       ESRecordsToProductResolverIndices ret(recordKeys_);
 
       unsigned int index = 0;
       for (const auto& provider : recordProviders_) {
         index = ret.dataKeysInRecord(
             index, provider->key(), provider->registeredDataKeys(), provider->componentsForRegisteredDataKeys());
       }
 
       return ret;
     }

◆ replaceExisting()

void edm::eventsetup::EventSetupProvider::replaceExisting ( std::shared_ptr< ESProductResolverProvider > productResolverProvider )

Definition at line 98 of file EventSetupProvider.cc.

References submitPVResolutionJobs::key, and recordProvider().

Referenced by edm::eventsetup::ModuleMakerTraits::replaceExisting().

                                                                                                              {
       ParameterSetIDHolder psetID(productResolverProvider->description().pid_);
       std::set<EventSetupRecordKey> const& keysForPSetID = (*psetIDToRecordKey_)[psetID];
       for (auto const& key : keysForPSetID) {
         recordProvider(key)->resetProductResolverProvider(psetID, productResolverProvider);
       }
     }

◆ resetRecordPlusDependentRecords()

void edm::eventsetup::EventSetupProvider::resetRecordPlusDependentRecords ( EventSetupRecordKey const & iKey )

Used when we need to force a Record to reset all its proxies.

Definition at line 375 of file EventSetupProvider.cc.

References ztail::d, edm::eventsetup::findDependents(), recordProviders_, edm::eventsetup::EventSetupRecordProvider::resetProxies(), tryToGetRecordProvider(), and tier0::unique().

Referenced by edm::EDLooperBase::prepareForNextLoop().

                                                                                             {
       EventSetupRecordProvider* recProvider = tryToGetRecordProvider(iKey);
       if (recProvider == nullptr) {
         return;
       }
 
       std::vector<std::shared_ptr<EventSetupRecordProvider>> dependents;
       findDependents(iKey, recordProviders_.begin(), recordProviders_.end(), dependents);
 
       dependents.erase(std::unique(dependents.begin(), dependents.end()), dependents.end());
 
       recProvider->resetProxies();
       for (auto& d : dependents) {
         d->resetProxies();
       }
     }

◆ resetRecordToResolverPointers()

void edm::eventsetup::EventSetupProvider::resetRecordToResolverPointers ( )

Definition at line 639 of file EventSetupProvider.cc.

References recordProviders_, and recordToPreferred_.

                                                            {
       for (auto const& recProvider : recordProviders_) {
         static const EventSetupRecordProvider::DataToPreferredProviderMap kEmptyMap;
         const EventSetupRecordProvider::DataToPreferredProviderMap* preferredInfo = &kEmptyMap;
         RecordToPreferred::const_iterator itRecordFound = recordToPreferred_->find(recProvider->key());
         if (itRecordFound != recordToPreferred_->end()) {
           preferredInfo = &(itRecordFound->second);
         }
         recProvider->resetRecordToResolverPointers(*preferredInfo);
       }
     }

◆ resolverProviderDescriptions()

std::set< ComponentDescription > edm::eventsetup::EventSetupProvider::resolverProviderDescriptions ( ) const

Definition at line 728 of file EventSetupProvider.cc.

References ztail::d, dataProviders_, AlCaHLTBitMon_ParallelJobs::p, and recordProviders_.

                                                                                         {
       typedef std::set<ComponentDescription> Set;
       Set descriptions;
 
       for (auto const& recProvider : recordProviders_) {
         auto const& d = recProvider->resolverProviderDescriptions();
         descriptions.insert(d.begin(), d.end());
       }
       if (dataProviders_.get()) {
         for (auto const& p : *dataProviders_) {
           descriptions.insert(p->description());
         }
       }
 
       return descriptions;
     }

◆ setAllValidityIntervals()

void edm::eventsetup::EventSetupProvider::setAllValidityIntervals ( const IOVSyncValue & iValue )

Set the validity intervals in all EventSetupRecordProviders.

Definition at line 667 of file EventSetupProvider.cc.

References recordProviders_.

                                                                                {
       // First loop sets a flag that helps us to not duplicate calls to the
       // same EventSetupRecordProvider setting the IOVs. Dependent records
       // can cause duplicate calls without this protection.
       for (auto& recProvider : recordProviders_) {
         recProvider->initializeForNewSyncValue();
       }
 
       for (auto& recProvider : recordProviders_) {
         recProvider->setValidityIntervalFor(iValue);
       }
     }

◆ setPreferredProviderInfo()

void edm::eventsetup::EventSetupProvider::setPreferredProviderInfo ( PreferredProviderInfo const & iInfo )

Definition at line 750 of file EventSetupProvider.cc.

References preferredProviderInfo_.

                                                                                         {
       preferredProviderInfo_ = std::make_unique<PreferredProviderInfo>(iInfo);
     }

◆ subProcessIndex()

unsigned edm::eventsetup::EventSetupProvider::subProcessIndex ( ) const

inline

Definition at line 110 of file EventSetupProvider.h.

References subProcessIndex_.

Referenced by checkESProducerSharing().

110 { return subProcessIndex_; }

edm::eventsetup::EventSetupProvider::subProcessIndex_

unsigned subProcessIndex_

Definition: EventSetupProvider.h:141

◆ tryToGetRecordProvider()

EventSetupRecordProvider * edm::eventsetup::EventSetupProvider::tryToGetRecordProvider ( const EventSetupRecordKey & iKey )

Definition at line 69 of file EventSetupProvider.cc.

References HLT_2024v10_cff::distance, pfDeepBoostedJetPreprocessParams_cfi::lower_bound, recordKeys_, and recordProviders_.

Referenced by doRecordsMatch(), fillReferencedDataKeys(), finishConfiguration(), and resetRecordPlusDependentRecords().

                                                                                                         {
       auto lb = std::lower_bound(recordKeys_.begin(), recordKeys_.end(), iKey);
       if (lb == recordKeys_.end() || iKey != *lb) {
         return nullptr;
       }
       auto index = std::distance(recordKeys_.begin(), lb);
       return recordProviders_[index].get();
     }

Member Data Documentation

◆ activityRegistry_

ActivityRegistry const* edm::eventsetup::EventSetupProvider::activityRegistry_

private

Definition at line 138 of file EventSetupProvider.h.

Referenced by add(), and finishConfiguration().

◆ dataProviders_

std::unique_ptr<std::vector<std::shared_ptr<ESProductResolverProvider> > > edm::eventsetup::EventSetupProvider::dataProviders_

private

Definition at line 148 of file EventSetupProvider.h.

Referenced by add(), fillRecordsNotAllowingConcurrentIOVs(), finishConfiguration(), and resolverProviderDescriptions().

◆ eventSetupImpl_

propagate_const<std::shared_ptr<EventSetupImpl> > edm::eventsetup::EventSetupProvider::eventSetupImpl_

private

Definition at line 142 of file EventSetupProvider.h.

Referenced by addRecord(), eventSetupForInstance(), and eventSetupImpl().

◆ finders_

std::unique_ptr<std::vector<std::shared_ptr<EventSetupRecordIntervalFinder> > > edm::eventsetup::EventSetupProvider::finders_

private

Definition at line 147 of file EventSetupProvider.h.

Referenced by add(), and finishConfiguration().

◆ mustFinishConfiguration_

bool edm::eventsetup::EventSetupProvider::mustFinishConfiguration_

private

Definition at line 140 of file EventSetupProvider.h.

Referenced by finishConfiguration().

◆ preferredProviderInfo_

std::unique_ptr<PreferredProviderInfo> edm::eventsetup::EventSetupProvider::preferredProviderInfo_

private

Definition at line 146 of file EventSetupProvider.h.

Referenced by clearInitializationData(), determinePreferred(), and setPreferredProviderInfo().

◆ psetIDToRecordKey_

std::unique_ptr<std::map<ParameterSetIDHolder, std::set<EventSetupRecordKey> > > edm::eventsetup::EventSetupProvider::psetIDToRecordKey_

private

Definition at line 152 of file EventSetupProvider.h.

Referenced by checkESProducerSharing(), clearInitializationData(), and finishConfiguration().

◆ recordKeys_

RecordKeys edm::eventsetup::EventSetupProvider::recordKeys_

private

Definition at line 133 of file EventSetupProvider.h.

Referenced by addRecord(), eventSetupForInstance(), finishConfiguration(), insert(), recordProvider(), recordsToResolverIndices(), and tryToGetRecordProvider().

◆ recordProviders_

RecordProviders edm::eventsetup::EventSetupProvider::recordProviders_

private

Definition at line 136 of file EventSetupProvider.h.

Referenced by checkESProducerSharing(), determinePreferred(), doWeNeedToWaitForIOVsToFinish(), eventSetupForInstance(), fillKeys(), finishConfiguration(), forceCacheClear(), insert(), recordProvider(), recordsToResolverIndices(), resetRecordPlusDependentRecords(), resetRecordToResolverPointers(), resolverProviderDescriptions(), setAllValidityIntervals(), and tryToGetRecordProvider().

◆ recordsWithALooperResolver_

std::unique_ptr<std::set<EventSetupRecordKey> > edm::eventsetup::EventSetupProvider::recordsWithALooperResolver_

private

Definition at line 154 of file EventSetupProvider.h.

Referenced by clearInitializationData(), doRecordsMatch(), and finishConfiguration().

◆ recordToFinders_

std::unique_ptr<std::map<EventSetupRecordKey, std::vector<std::shared_ptr<EventSetupRecordIntervalFinder> > > > edm::eventsetup::EventSetupProvider::recordToFinders_

private

Definition at line 151 of file EventSetupProvider.h.

Referenced by clearInitializationData(), doRecordsMatch(), and finishConfiguration().

◆ recordToPreferred_

std::unique_ptr<std::map<EventSetupRecordKey, std::map<DataKey, ComponentDescription> > > edm::eventsetup::EventSetupProvider::recordToPreferred_

private

Definition at line 153 of file EventSetupProvider.h.

Referenced by clearInitializationData(), determinePreferred(), finishConfiguration(), and resetRecordToResolverPointers().

◆ referencedDataKeys_

std::unique_ptr<std::map<EventSetupRecordKey, std::map<DataKey, ComponentDescription const*> > > edm::eventsetup::EventSetupProvider::referencedDataKeys_

private

Definition at line 149 of file EventSetupProvider.h.

Referenced by clearInitializationData(), doRecordsMatch(), and fillReferencedDataKeys().

◆ subProcessIndex_

unsigned edm::eventsetup::EventSetupProvider::subProcessIndex_

private

Definition at line 141 of file EventSetupProvider.h.

Referenced by checkESProducerSharing(), doRecordsMatch(), and subProcessIndex().

Public Types

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ DataKeyInfo

◆ DataLabel

◆ DataType

◆ PreferredProviderInfo

◆ RecordKeys

◆ RecordName

◆ RecordProviders

◆ RecordToDataMap

Constructor & Destructor Documentation

◆ EventSetupProvider() [1/2]

◆ EventSetupProvider() [2/2]

◆ ~EventSetupProvider()

Member Function Documentation

◆ add() [1/2]

◆ add() [2/2]

◆ addRecord()

◆ checkESProducerSharing()

◆ clearInitializationData()

◆ determinePreferred()

◆ doRecordsMatch()

◆ doWeNeedToWaitForIOVsToFinish()

◆ eventSetupForInstance()

◆ eventSetupImpl()

◆ fillKeys()

◆ fillRecordsNotAllowingConcurrentIOVs()

◆ fillReferencedDataKeys()

◆ finishConfiguration()

◆ forceCacheClear()

◆ insert()

◆ logInfoWhenSharing()

◆ operator=()

◆ recordProvider()

◆ recordsToResolverIndices()

◆ replaceExisting()

◆ resetRecordPlusDependentRecords()

◆ resetRecordToResolverPointers()

◆ resolverProviderDescriptions()

◆ setAllValidityIntervals()

◆ setPreferredProviderInfo()

◆ subProcessIndex()

◆ tryToGetRecordProvider()

Member Data Documentation

◆ activityRegistry_

◆ dataProviders_

◆ eventSetupImpl_

◆ finders_

◆ mustFinishConfiguration_

◆ preferredProviderInfo_

◆ psetIDToRecordKey_

◆ recordKeys_

◆ recordProviders_

◆ recordsWithALooperResolver_

◆ recordToFinders_

◆ recordToPreferred_

◆ referencedDataKeys_

◆ subProcessIndex_