Namespaces
	depends_on

	heterocontainer

	looper

	produce

Classes
class	Callback

struct	CallbackBase

class	CallbackProxy

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< ElectronLikelihood >

struct	data_default_record_trait< HepPDT::ParticleDataTable >

struct	data_default_record_trait< LumiCorrectionParam >

class	DataKey

class	DataProxy

class	DataProxyProvider

class	DataProxyTemplate

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	ESRecordsToProxyIndices

class	ESSourceInfo

class	EventSetupProvider

class	EventSetupRecord

class	EventSetupRecordGeneric

class	EventSetupRecordImpl

class	EventSetupRecordImplementation

class	EventSetupRecordKey

class	EventSetupRecordProvider

class	EventSetupsController

struct	FactoryInfo

struct	FindDependenciesFromDependentRecord

class	IntersectingIOVRecordIntervalFinder

struct	LooperMaker

struct	LooperMakerTraits

class	MakeDataException

struct	ModuleMaker

struct	ModuleMakerTraits

struct	MUST_GET_RECORD_FROM_EVENTSETUP_TO_GET_DATA

class	NameTag

class	NoDataException

class	NoDataExceptionBase

struct	NoDependenciesForRecord

class	NoProxyException

class	NoRecordException

class	ParameterSetIDHolder

class	ProxyArgumentFactoryTemplate

class	ProxyFactoryBase

class	ProxyFactoryTemplate

struct	RecordDependencyRegister

class	SimpleStringTag

struct	SourceMaker

struct	SourceMakerTraits

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

typedef std::map< DataKey, const DataProxy * >	Proxies

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)

template<class T >
void	addProviderTo (EventSetupProvider &iProvider, std::shared_ptr< T > iComponent, const DataProxyProvider *)

template<class T >
void	addProviderTo (EventSetupProvider &, std::shared_ptr< T >, const void *)

template<typename T >
void	addRecordToDependencies (const T , const T , std::set< EventSetupRecordKey > &)

template<typename TFirst , typename TEnd >
void	addRecordToDependencies (const TFirst , const TEnd iEnd, std::set< EventSetupRecordKey > &oSet)

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<>
bool	EventSetupRecord::get< fwliteeswriter::Handle > (const std::string &iName, fwliteeswriter::Handle &iHolder) const

template<>
void	EventSetupRecordImpl::getImplementation< fwliteeswriter::DummyType > (fwliteeswriter::DummyType const &iData, const char iName, const ComponentDescription *&iDesc, bool iTransientAccessOnly, std::shared_ptr< ESHandleExceptionFactory > &whyFailedFactory) const

void	fillEventSetupProvider (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)

template<class ProxyT >
void	insertProxy (DataProxyProvider::KeyedProxies &iList, std::shared_ptr< ProxyT > iProxy, const char *iName="")

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

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

template<typename FromT , typename ToT >
void	moveFromTo (FromT &iFrom, ToT &iTo)

template<typename FromT , typename ToT >
void	moveFromTo (std::unique_ptr< FromT > &iFrom, ToT &iTo)

template<typename FromT , typename ToT >
void	moveFromTo (std::optional< 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 DataProxyProvider and add it to the 'preferred' list More...

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

void	swap (DataKey &a, DataKey &b)

void	validateEventSetupParameters (ParameterSet &pset)

Variables
static std::recursive_mutex	s_esGlobalMutex

Typedef Documentation

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.

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

Definition at line 32 of file RecordDependencyRegister.h.

typedef NameTag edm::eventsetup::IdTags

Definition at line 51 of file DataKeyTags.h.

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

Definition at line 354 of file EventSetupProvider.cc.

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

Definition at line 101 of file LooperFactory.h.

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

Definition at line 103 of file LooperFactory.h.

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

Definition at line 55 of file ModuleFactory.h.

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

Definition at line 56 of file ModuleFactory.h.

typedef std::map<DataKey, const DataProxy*> edm::eventsetup::Proxies

Definition at line 33 of file EventSetupRecord.cc.

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

Definition at line 104 of file EventSetupProvider.cc.

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

Definition at line 105 of file EventSetupProvider.cc.

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

Definition at line 84 of file SourceFactory.h.

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

Definition at line 87 of file SourceFactory.h.

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

Definition at line 30 of file DataKeyTags.h.

Function Documentation

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

Definition at line 41 of file RecordDependencyRegister.cc.

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

41 { getMap().emplace(iKey, iFunction); }

template<class T >

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

Definition at line 41 of file SourceFactory.h.

References edm::eventsetup::EventSetupProvider::add(), heppy_report::description, and edm::eventsetup::ComponentDescription::isSource_.

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

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

template<class T >

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

Definition at line 49 of file SourceFactory.h.

                                                                                {
       //do nothing
     }

template<typename T >

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

Definition at line 38 of file findDependentRecordsFor.h.

Referenced by addRecordToDependencies(), and edm::eventsetup::FindDependenciesFromDependentRecord< T >::dependentRecords().

38 {}

template<typename TFirst , typename TEnd >

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

Definition at line 42 of file findDependentRecordsFor.h.

References addRecordToDependencies(), edm::eventsetup::EventSetupRecordKey::makeKey(), and GetRecoTauVFromDQM_MC_cff::next.

                                                                                                      {
       oSet.insert(EventSetupRecordKey::makeKey<typename boost::mpl::deref<TFirst>::type>());
       const typename boost::mpl::next<TFirst>::type* next(nullptr);
       addRecordToDependencies(next, iEnd, oSet);
     }

template<typename T , typename TRecord , typename TDecorator >

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

inline

Definition at line 95 of file ESProducer.h.

Referenced by edm::ESProducer::setWhatProduced().

                                                                                              {
       return iDec;
     }

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

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

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

std::set< EventSetupRecordKey > edm::eventsetup::dependencies ( EventSetupRecordKey const & iKey )

Definition at line 32 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>();
     }

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

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

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

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

static

Definition at line 32 of file DataProxy.cc.

                                                           {
       static ComponentDescription s_desc;
       return &s_desc;
     }

template<>

bool edm::eventsetup::EventSetupRecord::get< fwliteeswriter::Handle >	(	const std::string &	iName,
		fwliteeswriter::Handle &	iHolder
	)		const

Definition at line 90 of file FWLiteESRecordWriterAnalyzer.cc.

References edm::IOVSyncValue::eventID(), edm::EventSetup::find(), edm::ValidityInterval::first(), h, fwliteeswriter::DummyType::m_data, fwliteeswriter::Handle::m_data, fwliteeswriter::DummyType::m_tag, lumiQTWidget::t, edm::IOVSyncValue::time(), and update.

                                                                                                                   {
          fwliteeswriter::DummyType t;
          t.m_tag = &(iHolder.m_info->m_tag);
          const fwliteeswriter::DummyType* value = &t;
          const ComponentDescription* desc = nullptr;
          std::shared_ptr<ESHandleExceptionFactory> dummy;
          impl_->getImplementation(value, iName.c_str(),desc,true, dummy);
          iHolder.m_data = t.m_data;
          iHolder.m_desc = desc;
          return true;
       }

template<>

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

Definition at line 72 of file FWLiteESRecordWriterAnalyzer.cc.

References Exception, and crabWrapper::key.

                                                                                                                                                {
          DataKey dataKey(*(iData->m_tag),
                          iName,
                          DataKey::kDoNotCopyMemory);
          
          const void* pValue = this->getFromProxy(dataKey,iDesc,iTransientAccessOnly);
          if(nullptr==pValue) {
        throw cms::Exception("NoProxyException")<<"No data of type \""<<iData->m_tag->name()<<"\" with label \""<<
          iName<<"\" in record \""<<this->key().name()<<"\"";
          }
          iData->m_data = pValue;
       }

void edm::eventsetup::fillEventSetupProvider	(	EventSetupsController &	esController,
		EventSetupProvider &	cp,
		ParameterSet &	params
	)

Definition at line 93 of file EventSetupProviderMaker.cc.

References edm::eventsetup::ComponentFactory< T >::get(), edm::ParameterSet::getParameter(), edm::ParameterSet::getPSetForUpdate(), edm::ParameterSet::registerIt(), and validateEventSetupParameters().

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);
         validateEventSetupParameters(*providerPSet);
         providerPSet->registerIt();
         ModuleFactory::get()->addTo(esController, cp, *providerPSet);
       }
 
       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);
         validateEventSetupParameters(*providerPSet);
         providerPSet->registerIt();
         SourceFactory::get()->addTo(esController, cp, *providerPSet);
       }
     }

template<typename T >

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

Definition at line 65 of file findDependentRecordsFor.h.

                                                           {
       typedef typename boost::mpl::if_<typename std::is_base_of<edm::eventsetup::DependentRecordTag, T>::type,
                                        FindDependenciesFromDependentRecord<T>,
                                        NoDependenciesForRecord>::type DepFinder;
       std::set<EventSetupRecordKey> returnValue;
       DepFinder::dependentRecords(returnValue);
       return returnValue;
     }

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

static

Definition at line 355 of file EventSetupProvider.cc.

References symbols::deps.

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

template<class ProxyT >

void edm::eventsetup::insertProxy	(	DataProxyProvider::KeyedProxies &	iList,
		std::shared_ptr< ProxyT >	iProxy,
		const char *	iName = `""`
	)

inline

Definition at line 109 of file DataProxyProvider.h.

                                                     {
       iList.push_back(DataProxyProvider::KeyedProxies::value_type(
           DataKey(DataKey::makeTypeTag<typename ProxyT::value_type>(), iName), iProxy));
     }

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

static

Referenced by edm::eventsetup::DataProxyProvider::keyedProxies(), and edm::eventsetup::DataProxyProvider::prevalidate().

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

Definition at line 25 of file EventSetupProviderMaker.cc.

References cms::Exception::append(), edm::errors::Configuration, Exception, edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterNames(), edm::ParameterSet::getParameterSet(), and AlCaHLTBitMon_QueryRunRegistry::string.

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("DummyProxyProvider", "", 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"),
                                         false)] = recordToData;
       }
       return std::make_unique<EventSetupProvider>(activityRegistry, subProcessIndex, &preferInfo);
     }

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::Callback< T, TReturn, TRecord, TDecorator >::setData().

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

template<typename FromT , typename ToT >

void edm::eventsetup::moveFromTo	(	std::unique_ptr< FromT > &	iFrom,
		ToT &	iTo
	)

Definition at line 38 of file produce_helpers.h.

References eostools::move().

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

template<typename FromT , typename ToT >

void edm::eventsetup::moveFromTo	(	std::optional< FromT > &	iFrom,
		ToT &	iTo
	)

Definition at line 42 of file produce_helpers.h.

References eostools::move().

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

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

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

static

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

Definition at line 107 of file EventSetupProvider.cc.

References makeMuonMisalignmentScenario::components, Exception, edm::eventsetup::ComponentDescription::label_, and edm::eventsetup::ComponentDescription::type_.

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

                                                                   {
       //need to get our hands on the actual DataProxyProvider
       bool foundProxyProvider = false;
       for (auto const& recordProvider : iRecordProviders) {
         std::set<ComponentDescription> components = recordProvider->proxyProviderDescriptions();
         if (components.find(iComponent) != components.end()) {
           std::shared_ptr<DataProxyProvider> proxyProv = recordProvider->proxyProvider(*(components.find(iComponent)));
           assert(proxyProv.get());
 
           std::set<EventSetupRecordKey> records = proxyProv->usingRecords();
           for (std::set<EventSetupRecordKey>::iterator itRecord = records.begin(), itRecordEnd = records.end();
                itRecord != itRecordEnd;
                ++itRecord) {
             const DataProxyProvider::KeyedProxies& keyedProxies = proxyProv->keyedProxies(*itRecord);
             if (!keyedProxies.empty()) {
               //add them to our output
               EventSetupRecordProvider::DataToPreferredProviderMap& dataToProviderMap = iReturnValue[*itRecord];
 
               for (DataProxyProvider::KeyedProxies::const_iterator itProxy = keyedProxies.begin(),
                                                                    itProxyEnd = keyedProxies.end();
                    itProxy != itProxyEnd;
                    ++itProxy) {
                 EventSetupRecordProvider::DataToPreferredProviderMap::iterator itFind =
                     dataToProviderMap.find(itProxy->first);
                 if (itFind != dataToProviderMap.end()) {
                   throw cms::Exception("ESPreferConflict")
                       << "Two providers have been set to be preferred for\n"
                       << itProxy->first.type().name() << " \"" << itProxy->first.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(itProxy->first, iComponent));
               }
             }
           }
           foundProxyProvider = true;
           break;
         }
       }
       if (!foundProxyProvider) {
         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.";
       }
     }

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

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

inline

Definition at line 85 of file DataKey.h.

References edm::eventsetup::DataKey::swap.

Referenced by edm::eventsetup::DataProxyProvider::keyedProxies().

85 { a.swap(b); }

void edm::eventsetup::validateEventSetupParameters ( ParameterSet & pset )

Definition at line 117 of file EventSetupProviderMaker.cc.

References cms::Exception::addContext(), beamerCreator::create(), objects.autophobj::filler, reco::get(), edm::ParameterSet::getParameter(), AlCaHLTBitMon_QueryRunRegistry::string, and edm::convertException::wrap().

Referenced by fillEventSetupProvider().

                                                           {
       std::string modtype;
       std::string moduleLabel;
       modtype = pset.getParameter<std::string>("@module_type");
       moduleLabel = pset.getParameter<std::string>("@module_label");
       // Check for the "unlabeled" case
       // This is an artifact left over from the old configuration language
       // we were using before switching to the python configuration
       // This is handled in the validation code and python configuration
       // files by using a label equal to the module typename.
       if (moduleLabel == std::string("")) {
         moduleLabel = modtype;
       }
 
       std::unique_ptr<ParameterSetDescriptionFillerBase> filler(
           ParameterSetDescriptionFillerPluginFactory::get()->create(modtype));
       ConfigurationDescriptions descriptions(filler->baseType(), modtype);
       filler->fill(descriptions);
       try {
         edm::convertException::wrap([&]() { descriptions.validate(pset, moduleLabel); });
       } catch (cms::Exception& iException) {
         std::ostringstream ost;
         ost << "Validating configuration of ESProducer or ESSource of type " << modtype << " with label: '"
             << moduleLabel << "'";
         iException.addContext(ost.str());
         throw;
       }
     }

Variable Documentation

std::recursive_mutex edm::eventsetup::s_esGlobalMutex

static

Definition at line 28 of file DataProxy.cc.

Namespaces

Classes

Typedefs

Functions

Variables

Typedef Documentation

Function Documentation

Variable Documentation