edm::eventsetup Namespace Reference

Namespaces
	depends_on
	heterocontainer
	impl
	looper
	produce

Classes
class	Callback
class	CallbackBase
class	CallbackExternalWork
class	CallbackProductResolver
struct	CallbackSimpleDecorator
struct	ComponentDescription
class	ComponentFactory
class	ComponentMaker
class	ComponentMakerBase
class	ComponentMakerBaseHelper
struct	data_default_record_trait
struct	data_default_record_trait< DDDetector >
struct	data_default_record_trait< DIPLumiDetail >
struct	data_default_record_trait< DIPLumiSummary >
struct	data_default_record_trait< HepPDT::ParticleDataTable >
struct	data_default_record_trait< hph::Setup >
struct	data_default_record_trait< LumiCorrectionParam >
struct	data_default_record_trait< trackerDTC::LayerEncoding >
struct	data_default_record_trait< trackerTFP::DataFormats >
struct	data_default_record_trait< trackerTFP::Demonstrator >
struct	data_default_record_trait< trackerTFP::KalmanFilterFormats >
struct	data_default_record_trait< trackerTFP::LayerEncoding >
struct	data_default_record_trait< trklet::ChannelAssignment >
struct	data_default_record_trait< tt::Setup >
class	DataKey
struct	DecoratorFromArg
struct	DecoratorFromArg< T, TRecord, depends_on::OneHolder< T, TDependsOnRecord > >
struct	DecoratorFromArg< T, TRecord, depends_on::TwoHolder< T1, T2 > >
struct	default_record
class	DependentRecordImplementation
class	DependentRecordIntervalFinder
struct	DependentRecordTag
struct	DependsOnCaller
struct	DependsOnDoNothingCaller
class	ESPreFunctorDecorator
class	ESProducerInfo
class	ESProductResolver
class	ESProductResolverArgumentFactoryTemplate
class	ESProductResolverFactoryBase
class	ESProductResolverProvider
class	ESProductResolverTemplate
class	ESRecordsToProductResolverIndices
class	ESSourceConcurrentESProductResolverTemplate
class	ESSourceInfo
class	ESSourceProductResolverBase
class	ESSourceProductResolverConcurrentBase
class	ESSourceProductResolverNonConcurrentBase
class	ESSourceProductResolverTemplate
class	EventSetupProvider
class	EventSetupRecord
class	EventSetupRecordGeneric
class	EventSetupRecordImpl
class	EventSetupRecordImplementation
class	EventSetupRecordIOVQueue
class	EventSetupRecordKey
class	EventSetupRecordProvider
class	EventSetupsController
struct	FactoryInfo
class	IntersectingIOVRecordIntervalFinder
struct	LooperMaker
struct	LooperMakerTraits
class	MakeDataException
struct	ModuleMaker
struct	ModuleMakerTraits
struct	MUST_GET_RECORD_FROM_EVENTSETUP_TO_GET_DATA
class	NameTag
class	NoProductResolverException
class	NoRecordException
class	NumberOfConcurrentIOVs
class	ParameterSetIDHolder
struct	RecordDependencyRegister
class	SimpleStringTag
struct	SourceMaker
struct	SourceMakerTraits
class	SynchronousEventSetupsController

Typedefs
template<typename T >
using	default_record_t = typename default_record< T >::RecordT
using	DepFunction = std::set< EventSetupRecordKey >(*)()
typedef NameTag	IdTags
using	Itr = RecordProviders::iterator
typedef ComponentFactory< LooperMakerTraits >	LooperFactory
typedef edmplugin::PluginFactory< edm::eventsetup::ComponentMakerBase< LooperMakerTraits > *()>	LooperPluginFactory
typedef ComponentFactory< ModuleMakerTraits >	ModuleFactory
typedef edmplugin::PluginFactory< edm::eventsetup::ComponentMakerBase< ModuleMakerTraits > *()>	ModulePluginFactory
using	RecordProviders = std::vector< std::shared_ptr< EventSetupRecordProvider > >
using	RecordToPreferred = std::map< EventSetupRecordKey, EventSetupRecordProvider::DataToPreferredProviderMap >
typedef ComponentFactory< SourceMakerTraits >	SourceFactory
typedef edmplugin::PluginFactory< edm::eventsetup::ComponentMakerBase< edm::eventsetup::SourceMakerTraits > *()>	SourcePluginFactory
typedef heterocontainer::HCTypeTag	TypeTag

Functions
void	addDependencyFunction (EventSetupRecordKey iKey, DepFunction iFunction, bool allowConcurrentIOVs)
template<class T >
void	addProviderTo (EventSetupProvider &iProvider, std::shared_ptr< T > iComponent, const ESProductResolverProvider *)
template<class T >
void	addProviderTo (EventSetupProvider &, std::shared_ptr< T >, const void *)
template<typename TFirst , typename TRemaining >
void	addRecordToDependencies (const TFirst *, const TRemaining *, std::set< EventSetupRecordKey > &oSet)
bool	allowConcurrentIOVs (EventSetupRecordKey const &)
template<typename T , typename TRecord , typename TDecorator >
const TDecorator &	createDecoratorFrom (T *, const TRecord *, const TDecorator &iDec)
template<typename T , typename TRecord , typename TDependsOnRecord >
ESPreFunctorDecorator< TRecord, DependsOnCaller< T, TRecord, TDependsOnRecord, DependsOnDoNothingCaller< TRecord > > >	createDecoratorFrom (T *iT, const TRecord *iRec, const depends_on::OneHolder< T, TDependsOnRecord > &iHolder)
template<typename T , typename TRecord , typename T1 , typename T2 >
ESPreFunctorDecorator< TRecord, typename depends_on::HolderToCaller< TRecord, depends_on::TwoHolder< T1, T2 > >::Caller_t >	createDecoratorFrom (T *iT, const TRecord *iRec, const depends_on::TwoHolder< T1, T2 > &iHolder)
template<class T , class TRecord , class TDependsOnRecord , class TCallerChain >
DependsOnCaller< T, TRecord, TDependsOnRecord, TCallerChain >	createDependsOnCaller (T *iCallee, const TRecord *, void(T::*iMethod)(const TDependsOnRecord &), const TCallerChain &iChain)
std::set< EventSetupRecordKey >	dependencies (EventSetupRecordKey const &)
template<typename T , typename TDependsOnRecord >
depends_on::OneHolder< T, TDependsOnRecord >	dependsOn (void(T::*iT)(const TDependsOnRecord &))
template<typename T , typename T1 , typename T2 >
depends_on::TwoHolder< depends_on::OneHolder< T, T1 >, T2 >	dependsOn (void(T::*iT1)(const T1 &), T2 iT2)
template<typename T , typename T1 , typename T2 , typename T3 >
depends_on::TwoHolder< depends_on::TwoHolder< depends_on::OneHolder< T, T1 >, T2 >, T3 >	dependsOn (void(T::*iT1)(const T1 &), T2 iT2, T3 iT3)
static const ComponentDescription *	dummyDescription ()
template<>
edm::ESHandle< fwliteeswriter::DummyType >	EventSetupRecord::getHandleImpl< edm::ESHandle, fwliteeswriter::DummyType, fwliteeswriter::FWLWEventSetupRecord > (ESGetToken< fwliteeswriter::DummyType, fwliteeswriter::FWLWEventSetupRecord > const &iToken) const
template<>
void	EventSetupRecordImpl::getImplementation< fwliteeswriter::DummyType > (fwliteeswriter::DummyType const *&iData, ESResolverIndex iResolverIndex, bool iTransientAccessOnly, ComponentDescription const *&oDesc, std::shared_ptr< ESHandleExceptionFactory > &whyFailedFactory) const
void	fillEventSetupProvider (ModuleTypeResolverMaker const *resolverMaker, EventSetupsController &esController, EventSetupProvider &cp, ParameterSet &params)
template<typename T >
std::set< EventSetupRecordKey >	findDependentRecordsFor ()
static void	findDependents (const EventSetupRecordKey &iKey, Itr itBegin, Itr itEnd, std::vector< std::shared_ptr< EventSetupRecordProvider >> &oDependents)
static const std::string	kAppendToDataLabel ("appendToDataLabel")
std::unique_ptr< EventSetupProvider >	makeEventSetupProvider (ParameterSet const &params, unsigned subProcessIndex, ActivityRegistry *activityRegistry)
template<typename FromT , typename ToT >
void	moveFromTo (FromT &iFrom, ToT &iTo)
void	no_record_exception_message_builder (cms::Exception &, const char *, bool iKnownRecord)
static void	preferEverything (const ComponentDescription &iComponent, const RecordProviders &iRecordProviders, RecordToPreferred &iReturnValue)
	find everything made by a ESProductResolverProvider and add it to the 'preferred' list More...
bool	recordDoesExist (edm::EventSetupImpl const &, edm::eventsetup::EventSetupRecordKey const &)
void	swap (DataKey &a, DataKey &b)
void	synchronousEventSetupForInstance (IOVSyncValue const &syncValue, oneapi::tbb::task_group &iGroup, eventsetup::EventSetupsController &espController)

Typedef Documentation

default_record_t

template<typename T >

using edm::eventsetup::default_record_t = typedef typename default_record<T>::RecordT

Definition at line 68 of file data_default_record_trait.h.

DepFunction

using edm::eventsetup::DepFunction = typedef std::set<EventSetupRecordKey> (*)()

Definition at line 32 of file RecordDependencyRegister.h.

IdTags

typedef NameTag edm::eventsetup::IdTags

Definition at line 51 of file DataKeyTags.h.

Itr

using edm::eventsetup::Itr = typedef RecordProviders::iterator

Definition at line 359 of file EventSetupProvider.cc.

LooperFactory

typedef ComponentFactory<LooperMakerTraits> edm::eventsetup::LooperFactory

Definition at line 105 of file LooperFactory.h.

LooperPluginFactory

typedef edmplugin::PluginFactory<edm::eventsetup::ComponentMakerBase<LooperMakerTraits>*()> edm::eventsetup::LooperPluginFactory

Definition at line 107 of file LooperFactory.h.

ModuleFactory

typedef ComponentFactory<ModuleMakerTraits> edm::eventsetup::ModuleFactory

Definition at line 56 of file ModuleFactory.h.

ModulePluginFactory

typedef edmplugin::PluginFactory<edm::eventsetup::ComponentMakerBase<ModuleMakerTraits>*()> edm::eventsetup::ModulePluginFactory

Definition at line 57 of file ModuleFactory.h.

RecordProviders

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

Definition at line 111 of file EventSetupProvider.cc.

RecordToPreferred

using edm::eventsetup::RecordToPreferred = typedef std::map<EventSetupRecordKey, EventSetupRecordProvider::DataToPreferredProviderMap>

Definition at line 112 of file EventSetupProvider.cc.

SourceFactory

typedef ComponentFactory<SourceMakerTraits> edm::eventsetup::SourceFactory

Definition at line 85 of file SourceFactory.h.

SourcePluginFactory

typedef edmplugin::PluginFactory<edm::eventsetup::ComponentMakerBase<edm::eventsetup::SourceMakerTraits>*()> edm::eventsetup::SourcePluginFactory

Definition at line 88 of file SourceFactory.h.

TypeTag

typedef heterocontainer::HCTypeTag edm::eventsetup::TypeTag

Definition at line 30 of file DataKeyTags.h.

Function Documentation

addDependencyFunction()

void edm::eventsetup::addDependencyFunction	(	EventSetupRecordKey	iKey,
		DepFunction	iFunction,
		bool	allowConcurrentIOVs
	)

Definition at line 55 of file RecordDependencyRegister.cc.

References allowConcurrentIOVs().

Referenced by edm::eventsetup::RecordDependencyRegister< T >::RecordDependencyRegister().

                                                                                                          {
      getMap().emplace(iKey, iFunction);
      getAllowMap().emplace(iKey, allowConcurrentIOVs);
    }

addProviderTo() [1/2]

template<class T >

void edm::eventsetup::addProviderTo	(	EventSetupProvider &	iProvider,
		std::shared_ptr< T >	iComponent,
		const ESProductResolverProvider *
	)

Definition at line 41 of file SourceFactory.h.

References edm::eventsetup::EventSetupProvider::add(), and makeListRunsInFiles::description.

Referenced by edm::eventsetup::SourceMakerTraits::addTo().

                                                                                                                     {
      std::shared_ptr<ESProductResolverProvider> pProvider(iComponent);
      ComponentDescription description = pProvider->description();
      description.isSource_ = true;
      pProvider->setDescription(description);
      iProvider.add(pProvider);
    }

addProviderTo() [2/2]

template<class T >

void edm::eventsetup::addProviderTo	(	EventSetupProvider &	,
		std::shared_ptr< T >	,
		const void *
	)

Definition at line 49 of file SourceFactory.h.

                                                                               {
      //do nothing
    }

addRecordToDependencies()

template<typename TFirst , typename TRemaining >

void edm::eventsetup::addRecordToDependencies	(	const TFirst *	,
		const TRemaining *	,
		std::set< EventSetupRecordKey > &	oSet
	)

Definition at line 36 of file findDependentRecordsFor.h.

References ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), relativeConstraints::empty, and GetRecoTauVFromDQM_MC_cff::next.

Referenced by findDependentRecordsFor().

                                                                                                      {
      oSet.insert(EventSetupRecordKey::makeKey<TFirst>());
      using Pop = edm::mpl::Pop<TRemaining>;
      if constexpr (not Pop::empty) {
        const typename Pop::Item* next(nullptr);
        const typename Pop::Remaining* remaining(nullptr);
        addRecordToDependencies(next, remaining, oSet);
      }
    }

allowConcurrentIOVs()

bool edm::eventsetup::allowConcurrentIOVs

(

EventSetupRecordKey const &

iKey

)

Definition at line 46 of file RecordDependencyRegister.cc.

References genParticles_cff::map.

Referenced by addDependencyFunction(), and edm::eventsetup::ESProductResolverProvider::ESProductResolverContainer::fillRecordsNotAllowingConcurrentIOVs().

                                                              {
      auto& map = getAllowMap();
      auto itFind = map.find(iKey);
      if (itFind != map.end()) {
        return itFind->second;
      }
      return false;
    }

createDecoratorFrom() [1/3]

template<typename T , typename TRecord , typename TDecorator >

const TDecorator& edm::eventsetup::createDecoratorFrom ( T *  , const TRecord *  , const TDecorator &  iDec  )

inline

Definition at line 99 of file ESProducer.h.

                                                                                             {
      return iDec;
    }

createDecoratorFrom() [2/3]

template<typename T , typename TRecord , typename TDependsOnRecord >

ESPreFunctorDecorator<TRecord, DependsOnCaller<T, TRecord, TDependsOnRecord, DependsOnDoNothingCaller<TRecord> > > edm::eventsetup::createDecoratorFrom ( T *  iT, const TRecord *  iRec, const depends_on::OneHolder< T, TDependsOnRecord > &  iHolder  )

inline

Definition at line 169 of file eventsetup_dependsOn.h.

References createDependsOnCaller(), edm::eventsetup::depends_on::OneHolder< T, TDependsOnRecord >::holdee_, and groupFilesInBlocks::temp.

                                                                                                             {
      DependsOnDoNothingCaller<TRecord> tCaller;
      ESPreFunctorDecorator<TRecord, DependsOnCaller<T, TRecord, TDependsOnRecord, DependsOnDoNothingCaller<TRecord> > >
          temp(createDependsOnCaller(iT, iRec, iHolder.holdee_, tCaller));
      return temp;
    }

createDecoratorFrom() [3/3]

template<typename T , typename TRecord , typename T1 , typename T2 >

ESPreFunctorDecorator<TRecord, typename depends_on::HolderToCaller<TRecord, depends_on::TwoHolder<T1, T2> >::Caller_t> edm::eventsetup::createDecoratorFrom ( T *  iT, const TRecord *  iRec, const depends_on::TwoHolder< T1, T2 > &  iHolder  )

inline

Definition at line 186 of file eventsetup_dependsOn.h.

References createDependsOnCaller(), edm::eventsetup::depends_on::TwoHolder< T, U >::h1_, edm::eventsetup::depends_on::TwoHolder< T, U >::h2_, and edm::eventsetup::depends_on::makeCaller().

                                                                                                {
      return ESPreFunctorDecorator<
          TRecord,
          typename depends_on::HolderToCaller<TRecord, depends_on::TwoHolder<T1, T2> >::Caller_t>(
          createDependsOnCaller(iT, iRec, iHolder.h2_, makeCaller(iT, iRec, iHolder.h1_)));
    }

createDependsOnCaller()

template<class T , class TRecord , class TDependsOnRecord , class TCallerChain >

DependsOnCaller<T, TRecord, TDependsOnRecord, TCallerChain> edm::eventsetup::createDependsOnCaller	(	T *	iCallee,
		const TRecord *	,
		void(T::*)(const TDependsOnRecord &)	iMethod,
		const TCallerChain &	iChain
	)

Definition at line 87 of file eventsetup_dependsOn.h.

Referenced by createDecoratorFrom(), and edm::eventsetup::depends_on::makeCaller().

                                                                                                           {
      return DependsOnCaller<T, TRecord, TDependsOnRecord, TCallerChain>(iCallee, iMethod, iChain);
    }

dependencies()

std::set< EventSetupRecordKey > edm::eventsetup::dependencies

(

EventSetupRecordKey const &

iKey

)

Definition at line 37 of file RecordDependencyRegister.cc.

References genParticles_cff::map.

Referenced by edm::eventsetup::EventSetupRecordProvider::dependentRecords().

                                                                              {
      auto& map = getMap();
      auto itFind = map.find(iKey);
      if (itFind != map.end()) {
        return itFind->second();
      }
      return std::set<EventSetupRecordKey>();
    }

dependsOn() [1/3]

template<typename T , typename TDependsOnRecord >

depends_on::OneHolder<T, TDependsOnRecord> edm::eventsetup::dependsOn

(

void(T::*)(const TDependsOnRecord &)

iT

)

Definition at line 195 of file eventsetup_dependsOn.h.

                                                                                             {
      return iT;
    }

dependsOn() [2/3]

template<typename T , typename T1 , typename T2 >

depends_on::TwoHolder<depends_on::OneHolder<T, T1>, T2> edm::eventsetup::dependsOn	(	void(T::*)(const T1 &)	iT1,
		T2	iT2
	)

Definition at line 200 of file eventsetup_dependsOn.h.

                                                                                                   {
      return depends_on::OneHolder<T, T1>(iT1) & iT2;
    }

dependsOn() [3/3]

template<typename T , typename T1 , typename T2 , typename T3 >

depends_on::TwoHolder<depends_on::TwoHolder<depends_on::OneHolder<T, T1>, T2>, T3> edm::eventsetup::dependsOn	(	void(T::*)(const T1 &)	iT1,
		T2	iT2,
		T3	iT3
	)

Definition at line 205 of file eventsetup_dependsOn.h.

                                                 {
      return depends_on::OneHolder<T, T1>(iT1) & iT2 & iT3;
    }

dummyDescription()

static const ComponentDescription* edm::eventsetup::dummyDescription ( )

static

Definition at line 27 of file ESProductResolver.cc.

                                                          {
      static const ComponentDescription s_desc;
      return &s_desc;
    }

EventSetupRecord::getHandleImpl< edm::ESHandle, fwliteeswriter::DummyType, fwliteeswriter::FWLWEventSetupRecord >()

template<>

edm::ESHandle<fwliteeswriter::DummyType> edm::eventsetup::EventSetupRecord::getHandleImpl< edm::ESHandle, fwliteeswriter::DummyType, fwliteeswriter::FWLWEventSetupRecord >

(

ESGetToken< fwliteeswriter::DummyType, fwliteeswriter::FWLWEventSetupRecord > const &

iToken

)

const

Definition at line 152 of file FWLiteESRecordWriterAnalyzer.cc.

References cms::cuda::assert(), submitPVResolutionJobs::desc, submitPVResolutionJobs::key, edm::makeESHandleExceptionFactory(), WZElectronSkims53X_cff::max, makeGlobalPositionRcd_cfg::tag, UNLIKELY, and relativeConstraints::value.

                                                                                                     {
      if UNLIKELY (not iToken.isInitialized()) {
        std::rethrow_exception(makeUninitializedTokenException(this->key(), iToken.dataInfo().m_tag));
      }
      if UNLIKELY (iToken.transitionID() != transitionID()) {
        throwWrongTransitionID();
      }
      using TheHandle = edm::ESHandle<fwliteeswriter::DummyType>;
      assert(getTokenIndices_);
      //need to check token has valid index
      if UNLIKELY (not iToken.hasValidIndex()) {
        return TheHandle{makeESHandleExceptionFactory(
            [key = this->key(), tag = iToken.dataInfo().m_tag, transitionID = iToken.transitionID()] {
              return makeInvalidTokenException(key, tag, transitionID);
            })};
      }

      auto proxyIndex = getTokenIndices_[iToken.index().value()];
      if UNLIKELY (proxyIndex.value() == std::numeric_limits<int>::max()) {
        return TheHandle(makeESHandleExceptionFactory([iToken, key = this->key()] {
          cms::Exception exc("NoProductResolverException");
          exc << "No data of type \"" << iToken.dataInfo().m_tag.name() << "\" with label \"" << iToken.name()
              << "\" in record \"" << key.name() << "\"";
          return std::make_exception_ptr(exc);
        }));
      }

      fwliteeswriter::DummyType value;
      fwliteeswriter::DummyType const* pValue = &value;
      ComponentDescription const* desc = nullptr;
      std::shared_ptr<ESHandleExceptionFactory> whyFailedFactory;

      impl_->getImplementation(pValue, proxyIndex, false, desc, whyFailedFactory);

      if UNLIKELY (not value.m_data) {
        std::rethrow_exception(whyFailedFactory->make());
      }
      return edm::ESHandle<fwliteeswriter::DummyType>(value.m_data, desc);
    }

EventSetupRecordImpl::getImplementation< fwliteeswriter::DummyType >()

template<>

void edm::eventsetup::EventSetupRecordImpl::getImplementation< fwliteeswriter::DummyType >	(	fwliteeswriter::DummyType const *&	iData,
		ESResolverIndex	iResolverIndex,
		bool	iTransientAccessOnly,
		ComponentDescription const *&	oDesc,
		std::shared_ptr< ESHandleExceptionFactory > &	whyFailedFactory
	)		const

Definition at line 124 of file FWLiteESRecordWriterAnalyzer.cc.

References cms::cuda::assert(), Exception, submitPVResolutionJobs::key, WZElectronSkims53X_cff::max, edm::eventsetup::DataKey::name(), and edm::eventsetup::SimpleStringTag::value().

                                                                         {
      DataKey const* dataKey = nullptr;

      if (iResolverIndex.value() == std::numeric_limits<int>::max()) {
        throw cms::Exception("NoProductResolverException")
            << "No data of type \"" << iData->m_tag->name() << "\" with unknown label in record \""
            << this->key().name() << "\"";
        iData->m_data = nullptr;
        return;
      }
      assert(iResolverIndex.value() > -1 and
             iResolverIndex.value() < static_cast<ESResolverIndex::Value_t>(keysForResolvers_.size()));
      void const* pValue = this->getFromResolverAfterPrefetch(iResolverIndex, iTransientAccessOnly, oDesc, dataKey);
      if (nullptr == pValue) {
        throw cms::Exception("NoDataException")
            << "No data of type \"" << iData->m_tag->name() << "\" with label \"" << dataKey->name().value()
            << "\" in record \"" << this->key().name() << "\"";
      }
      iData->m_data = pValue;
    }

fillEventSetupProvider()

void edm::eventsetup::fillEventSetupProvider	(	ModuleTypeResolverMaker const *	resolverMaker,
		EventSetupsController &	esController,
		EventSetupProvider &	cp,
		ParameterSet &	params
	)

Definition at line 93 of file EventSetupProviderMaker.cc.

References edm::eventsetup::ComponentFactory< T >::get(), submitPVValidationJobs::params, and CalibrationSummaryClient_cfi::sources.

Referenced by edm::eventsetup::EventSetupsController::makeProvider().

                                                      {
      std::vector<std::string> providers = params.getParameter<std::vector<std::string> >("@all_esmodules");

      for (std::vector<std::string>::iterator itName = providers.begin(), itNameEnd = providers.end();
           itName != itNameEnd;
           ++itName) {
        ParameterSet* providerPSet = params.getPSetForUpdate(*itName);
        ModuleFactory::get()->addTo(esController, cp, *providerPSet, resolverMaker);
      }

      std::vector<std::string> sources = params.getParameter<std::vector<std::string> >("@all_essources");

      for (std::vector<std::string>::iterator itName = sources.begin(), itNameEnd = sources.end(); itName != itNameEnd;
           ++itName) {
        ParameterSet* providerPSet = params.getPSetForUpdate(*itName);
        SourceFactory::get()->addTo(esController, cp, *providerPSet, resolverMaker);
      }
    }

findDependentRecordsFor()

template<typename T >

std::set<EventSetupRecordKey> edm::eventsetup::findDependentRecordsFor

(

)

Definition at line 47 of file findDependentRecordsFor.h.

References addRecordToDependencies(), and ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr().

                                                          {
      std::set<EventSetupRecordKey> returnValue;
      if constexpr (std::is_base_of_v<edm::eventsetup::DependentRecordTag, T>) {
        using list_type = typename T::list_type;
        using Pop = edm::mpl::Pop<list_type>;

        const typename Pop::Item* begin(nullptr);
        const typename Pop::Remaining* remaining(nullptr);
        addRecordToDependencies(begin, remaining, returnValue);
      }
      return returnValue;
    }

findDependents()

static void edm::eventsetup::findDependents ( const EventSetupRecordKey &  iKey, Itr  itBegin, Itr  itEnd, std::vector< std::shared_ptr< EventSetupRecordProvider >> &  oDependents  )

static

Definition at line 360 of file EventSetupProvider.cc.

References symbols::deps, and ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it.

Referenced by edm::eventsetup::EventSetupProvider::resetRecordPlusDependentRecords().

                                                                                                {
      for (Itr it = itBegin; it != itEnd; ++it) {
        //does it depend on the record in question?
        const std::set<EventSetupRecordKey>& deps = (*it)->dependentRecords();
        if (deps.end() != deps.find(iKey)) {
          oDependents.push_back(*it);
          //now see who is dependent on this record since they will be indirectly dependent on iKey
          findDependents((*it)->key(), itBegin, itEnd, oDependents);
        }
      }
    }

kAppendToDataLabel()

static const std::string edm::eventsetup::kAppendToDataLabel ( "appendToDataLabel"  )

static

Referenced by edm::eventsetup::ESProductResolverProvider::prevalidate().

makeEventSetupProvider()

std::unique_ptr< EventSetupProvider > edm::eventsetup::makeEventSetupProvider	(	ParameterSet const &	params,
		unsigned	subProcessIndex,
		ActivityRegistry *	activityRegistry
	)

Definition at line 24 of file EventSetupProviderMaker.cc.

References cms::Exception::append(), edm::errors::Configuration, Exception, edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterNames(), customiseL1CustomReco::labelName, submitPVValidationJobs::params, AlCaHLTBitMon_QueryRunRegistry::string, and edm::eventsetup::ComponentDescription::unknownID().

Referenced by edm::eventsetup::EventSetupsController::makeProvider().

                                                                                                   {
      std::vector<std::string> prefers = params.getParameter<std::vector<std::string> >("@all_esprefers");

      if (prefers.empty()) {
        return std::make_unique<EventSetupProvider>(activityRegistry, subProcessIndex);
      }

      EventSetupProvider::PreferredProviderInfo preferInfo;
      EventSetupProvider::RecordToDataMap recordToData;

      //recordToData.insert(std::make_pair(std::string("DummyRecord"),
      //      std::make_pair(std::string("DummyData"), std::string())));
      //preferInfo[ComponentDescription("DummyESProductResolverProvider", "", false)]=
      //      recordToData;

      for (std::vector<std::string>::iterator itName = prefers.begin(), itNameEnd = prefers.end(); itName != itNameEnd;
           ++itName) {
        recordToData.clear();
        ParameterSet const& preferPSet = params.getParameterSet(*itName);
        std::vector<std::string> recordNames = preferPSet.getParameterNames();
        for (std::vector<std::string>::iterator itRecordName = recordNames.begin(), itRecordNameEnd = recordNames.end();
             itRecordName != itRecordNameEnd;
             ++itRecordName) {
          if ((*itRecordName)[0] == '@') {
            //this is a 'hidden parameter' so skip it
            continue;
          }

          //this should be a record name with its info
          try {
            std::vector<std::string> dataInfo = preferPSet.getParameter<std::vector<std::string> >(*itRecordName);

            if (dataInfo.empty()) {
              //FUTURE: empty should just mean all data
              throw Exception(errors::Configuration)
                  << "The record named " << *itRecordName << " specifies no data items";
            }
            //FUTURE: 'any' should be a special name
            for (std::vector<std::string>::iterator itDatum = dataInfo.begin(), itDatumEnd = dataInfo.end();
                 itDatum != itDatumEnd;
                 ++itDatum) {
              std::string datumName(*itDatum, 0, itDatum->find_first_of("/"));
              std::string labelName;

              if (itDatum->size() != datumName.size()) {
                labelName = std::string(*itDatum, datumName.size() + 1);
              }
              recordToData.insert(std::make_pair(std::string(*itRecordName), std::make_pair(datumName, labelName)));
            }
          } catch (cms::Exception const& iException) {
            cms::Exception theError("ESPreferConfigurationError");
            theError << "While parsing the es_prefer statement for type="
                     << preferPSet.getParameter<std::string>("@module_type") << " label=\""
                     << preferPSet.getParameter<std::string>("@module_label") << "\" an error occurred.";
            theError.append(iException);
            throw theError;
          }
        }
        preferInfo[ComponentDescription(preferPSet.getParameter<std::string>("@module_type"),
                                        preferPSet.getParameter<std::string>("@module_label"),
                                        ComponentDescription::unknownID(),
                                        false)] = recordToData;
      }
      return std::make_unique<EventSetupProvider>(activityRegistry, subProcessIndex, &preferInfo);
    }

moveFromTo()

template<typename FromT , typename ToT >

void edm::eventsetup::moveFromTo	(	FromT &	iFrom,
		ToT &	iTo
	)

Definition at line 33 of file produce_helpers.h.

References eostools::move().

Referenced by edm::eventsetup::CallbackBase< T, TProduceFunc, TProduceReturn, TRecord, TDecorator >::setData().

                                          {
    iTo = std::move(iFrom);
  }

no_record_exception_message_builder()

void edm::eventsetup::no_record_exception_message_builder	(	cms::Exception &	oException,
		const char *	iName,
		bool	iKnownRecord
	)

Definition at line 26 of file NoRecordException.cc.

Referenced by edm::eventsetup::NoRecordException< T >::NoRecordException().

                                                                             {
  oException << "No \"" << iName << "\" record found in the EventSetup.\n";
  if (iKnownRecord) {
    oException << "\n The Record is delivered by an ESSource or ESProducer but there is no valid IOV for the "
                  "synchronization value.\n"
                  " Please check \n"
                  "   a) if the synchronization value is reasonable and report to the hypernews if it is not.\n"
                  "   b) else check that all ESSources have been properly configured. \n";
  } else {
    oException << "\n Please add an ESSource or ESProducer that delivers such a record.\n";
  }
}

preferEverything()

static void edm::eventsetup::preferEverything ( const ComponentDescription &  iComponent, const RecordProviders &  iRecordProviders, RecordToPreferred &  iReturnValue  )

static

find everything made by a ESProductResolverProvider and add it to the 'preferred' list

Definition at line 114 of file EventSetupProvider.cc.

References cms::cuda::assert(), makeMuonMisalignmentScenario::components, Exception, edm::eventsetup::ComponentDescription::label_, edm::eventsetup::ComponentDescription::type_, and edm::eventsetup::ESProductResolverProvider::KeyedResolvers::unInitialized().

Referenced by edm::eventsetup::EventSetupProvider::determinePreferred().

                                                                  {
      //need to get our hands on the actual ESProductResolverProvider
      bool foundResolverProvider = false;
      for (auto const& recordProvider : iRecordProviders) {
        std::set<ComponentDescription> components = recordProvider->resolverProviderDescriptions();
        if (components.find(iComponent) != components.end()) {
          std::shared_ptr<ESProductResolverProvider> resolverProv =
              recordProvider->resolverProvider(*(components.find(iComponent)));
          assert(resolverProv.get());

          std::set<EventSetupRecordKey> records = resolverProv->usingRecords();
          for (auto const& recordKey : records) {
            unsigned int iovIndex = 0;  // Doesn't matter which index is picked, at least 1 should always exist
            ESProductResolverProvider::KeyedResolvers& keyedResolvers =
                resolverProv->keyedResolvers(recordKey, iovIndex);
            if (!keyedResolvers.unInitialized()) {
              //add them to our output
              EventSetupRecordProvider::DataToPreferredProviderMap& dataToProviderMap = iReturnValue[recordKey];

              for (auto keyedResolver : keyedResolvers) {
                EventSetupRecordProvider::DataToPreferredProviderMap::iterator itFind =
                    dataToProviderMap.find(keyedResolver.dataKey_);
                if (itFind != dataToProviderMap.end()) {
                  throw cms::Exception("ESPreferConflict")
                      << "Two providers have been set to be preferred for\n"
                      << keyedResolver.dataKey_.type().name() << " \"" << keyedResolver.dataKey_.name().value() << "\""
                      << "\n the providers are "
                      << "\n 1) type=" << itFind->second.type_ << " label=\"" << itFind->second.label_ << "\""
                      << "\n 2) type=" << iComponent.type_ << " label=\"" << iComponent.label_ << "\""
                      << "\nPlease modify configuration so only one is preferred";
                }
                dataToProviderMap.insert(std::make_pair(keyedResolver.dataKey_, iComponent));
              }
            }
          }
          foundResolverProvider = true;
          break;
        }
      }
      if (!foundResolverProvider) {
        throw cms::Exception("ESPreferNoProvider")
            << "Could not make type=\"" << iComponent.type_ << "\" label=\"" << iComponent.label_
            << "\" a preferred Provider."
            << "\n  Please check spelling of name, or that it was loaded into the job.";
      }
    }

recordDoesExist()

bool edm::eventsetup::recordDoesExist	(	edm::EventSetupImpl const &	iES,
		edm::eventsetup::EventSetupRecordKey const &	iKey
	)

Definition at line 22 of file NoRecordException.cc.

References edm::EventSetupImpl::recordIsProvidedByAModule().

Referenced by edm::EventSetup::get().

                                                                                              {
  return iES.recordIsProvidedByAModule(iKey);
}

swap()

void edm::eventsetup::swap ( DataKey &  a, DataKey &  b  )

inline

Definition at line 85 of file DataKey.h.

References a, and b.

Referenced by edm::eventsetup::NumberOfConcurrentIOVs::clear(), and edm::eventsetup::ESProductResolverProvider::keyedResolvers().

{ a.swap(b); }

synchronousEventSetupForInstance()

void edm::eventsetup::synchronousEventSetupForInstance	(	IOVSyncValue const &	syncValue,
		oneapi::tbb::task_group &	iGroup,
		eventsetup::EventSetupsController &	espController
	)

Definition at line 470 of file EventSetupsController.cc.

References CMS_SA_ALLOW, edm::WaitingTaskHolder::doneWaiting(), edm::WaitingTaskList::doneWaiting(), and edm::eventsetup::EventSetupsController::eventSetupForInstanceAsync().

Referenced by edm::test::TestProcessor::beginLuminosityBlock(), edm::test::TestProcessor::beginRun(), edm::test::TestProcessor::endLuminosityBlock(), edm::test::TestProcessor::endRun(), and edm::eventsetup::SynchronousEventSetupsController::eventSetupForInstance().

                                                                                          {
      FinalWaitingTask waitUntilIOVInitializationCompletes{iGroup};

      // These do nothing ...
      WaitingTaskList dummyWaitingTaskList;
      std::vector<std::shared_ptr<const EventSetupImpl>> dummyEventSetupImpls;

      {
        WaitingTaskHolder waitingTaskHolder(iGroup, &waitUntilIOVInitializationCompletes);
        // Caught exception is propagated via WaitingTaskHolder
        CMS_SA_ALLOW try {
          // All the real work is done here.
          espController.eventSetupForInstanceAsync(
              syncValue, waitingTaskHolder, dummyWaitingTaskList, dummyEventSetupImpls);
          dummyWaitingTaskList.doneWaiting(std::exception_ptr{});
        } catch (...) {
          dummyWaitingTaskList.doneWaiting(std::exception_ptr{});
          waitingTaskHolder.doneWaiting(std::current_exception());
        }
      }
      waitUntilIOVInitializationCompletes.wait();
    }