CMSSW Reference Manual

Definition at line 54 of file DataKeyTags.h.

typedef Providers::iterator edm::eventsetup::Itr

Definition at line 339 of file EventSetupProvider.cc.

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

Definition at line 94 of file LooperFactory.h.

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

Definition at line 96 of file LooperFactory.h.

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

Definition at line 43 of file ModuleFactory.h.

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

Definition at line 44 of file ModuleFactory.h.

typedef std::map< EventSetupRecordKey, boost::shared_ptr< EventSetupRecordProvider > > edm::eventsetup::Providers

Definition at line 112 of file EventSetupProvider.cc.

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

Definition at line 27 of file EventSetupRecord.cc.

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

Definition at line 113 of file EventSetupProvider.cc.

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

Definition at line 68 of file SourceFactory.h.

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

Definition at line 70 of file SourceFactory.h.

typedef heterocontainer::HCTypeTag<DataKey> edm::eventsetup::TypeTag

Definition at line 31 of file DataKeyTags.h.

template<class T>

void edm::eventsetup::addProviderTo	(	EventSetupProvider &	,
		boost::shared_ptr< T >	,
		const void *
	)			`[inline]`

Definition at line 48 of file SourceFactory.h.

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

00049       {
00050             //do nothing
00051       }

template<class T>

void edm::eventsetup::addProviderTo	(	EventSetupProvider &	iProvider,
		boost::shared_ptr< T >	iComponent,
		const DataProxyProvider *
	)			`[inline]`

Definition at line 39 of file SourceFactory.h.

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

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

00040       {
00041             boost::shared_ptr<DataProxyProvider> pProvider(iComponent);
00042             ComponentDescription description = pProvider->description();
00043             description.isSource_=true;
00044             pProvider->setDescription(description);
00045             iProvider.add(pProvider);
00046       }

template<typename FromT, typename ToT>

void edm::eventsetup::copyFromTo	(	FromT &	iFrom,
		ToT &	iTo
	)			`[inline]`

Definition at line 33 of file produce_helpers.h.

Referenced by edm::eventsetup::Callback< T, TReturn, TRecord, TDecorator >::setData().

00034                                                                        {
00035        iTo = iFrom;
00036      }

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

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

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

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 170 of file eventsetup_dependsOn.h.

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

00170                                                                                                                 {
00171             DependsOnDoNothingCaller<TRecord> tCaller;
00172             ESPreFunctorDecorator<TRecord,DependsOnCaller<T,TRecord, TDependsOnRecord, DependsOnDoNothingCaller<TRecord> > >
00173                temp(createDependsOnCaller(iT, iRec, iHolder.holdee_, tCaller));
00174             return temp;
00175          }

template<typename T, typename TRecord, typename TDecorator>

const TDecorator& edm::eventsetup::createDecoratorFrom	(	T *	,
		const TRecord *	,
		const TDecorator &	iDec
	)			`[inline]`

Definition at line 94 of file ESProducer.h.

00094                                                                                                {
00095          return iDec;
00096       }

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
	)			`[inline]`

Definition at line 92 of file eventsetup_dependsOn.h.

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

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

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
	)			`[inline]`

Definition at line 201 of file eventsetup_dependsOn.h.

Referenced by CastorDbProducer::CastorDbProducer(), CSCGeometryESModule::CSCGeometryESModule(), DTGeometryESModule::DTGeometryESModule(), EcalLaserCorrectionService::EcalLaserCorrectionService(), HcalDbProducer::HcalDbProducer(), HcalDDDGeometryEP::HcalDDDGeometryEP(), HcalHardcodeGeometryEP::HcalHardcodeGeometryEP(), HcalTPGCoderULUT::HcalTPGCoderULUT(), MuonNumberingInitialization::MuonNumberingInitialization(), RPCConeBuilder::RPCConeBuilder(), TrackerDigiGeometryESModule::TrackerDigiGeometryESModule(), and ZdcHardcodeGeometryEP::ZdcHardcodeGeometryEP().

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

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
	)			`[inline]`

Definition at line 197 of file eventsetup_dependsOn.h.

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

template<typename T, typename TDependsOnRecord>

depends_on::OneHolder<T,TDependsOnRecord> edm::eventsetup::dependsOn ( void(T::*)(const TDependsOnRecord &) iT ) [inline]

Definition at line 193 of file eventsetup_dependsOn.h.

00193 { return iT ; }

static RecordToPreferred edm::eventsetup::determinePreferred	(	const EventSetupProvider::PreferredProviderInfo *	iInfo,
		const Providers &	iProviders
	)			`[static]`

Definition at line 172 of file EventSetupProvider.cc.

References Exception, first, preferEverything(), HLT_VtxMuL3::recordName, and edm::eventsetup::EventSetupRecordKey::type().

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

00174 {
00175    using namespace edm::eventsetup;
00176    RecordToPreferred returnValue;
00177    if(0 != iInfo){
00178       for(EventSetupProvider::PreferredProviderInfo::const_iterator itInfo = iInfo->begin(),
00179           itInfoEnd = iInfo->end();
00180           itInfo != itInfoEnd;
00181           ++itInfo) {
00182          if(itInfo->second.empty()) {
00183             //want everything
00184             preferEverything(itInfo->first, iProviders, returnValue);
00185          } else {
00186             for(EventSetupProvider::RecordToDataMap::const_iterator itRecData = itInfo->second.begin(),
00187                 itRecDataEnd = itInfo->second.end();
00188                 itRecData != itRecDataEnd;
00189                 ++itRecData) {
00190                std::string recordName= itRecData->first;
00191                EventSetupRecordKey recordKey(eventsetup::EventSetupRecordKey::TypeTag::findType(recordName));
00192                if(recordKey.type() == eventsetup::EventSetupRecordKey::TypeTag()) {
00193                   throw cms::Exception("ESPreferUnknownRecord") <<"Unknown record \""<<recordName
00194                   <<"\" used in es_prefer statement for type="
00195                   <<itInfo->first.type_<<" label=\""<<itInfo->first.label_
00196                   <<"\"\n Please check spelling.";
00197                   //record not found
00198                }
00199                //See if the ProxyProvider provides something for this Record
00200                Providers::const_iterator itRecordProvider = iProviders.find(recordKey);
00201                assert(itRecordProvider != iProviders.end());
00202                
00203                std::set<ComponentDescription> components = itRecordProvider->second->proxyProviderDescriptions();
00204                std::set<ComponentDescription>::iterator itProxyProv = components.find(itInfo->first);
00205                if(itProxyProv == components.end()){
00206                   throw cms::Exception("ESPreferWrongRecord")<<"The type="<<itInfo->first.type_<<" label=\""<<
00207                   itInfo->first.label_<<"\" does not provide data for the Record "<<recordName;
00208                }
00209                //Does it data type exist?
00210                eventsetup::TypeTag datumType = eventsetup::TypeTag::findType(itRecData->second.first);
00211                if(datumType == eventsetup::TypeTag()) {
00212                   //not found
00213                   throw cms::Exception("ESPreferWrongDataType")<<"The es_prefer statement for type="<<itInfo->first.type_<<" label=\""<<
00214                   itInfo->first.label_<<"\" has the unknown data type \""<<itRecData->second.first<<"\""
00215                   <<"\n Please check spelling";
00216                }
00217                eventsetup::DataKey datumKey(datumType, itRecData->second.second.c_str());
00218                
00219                //Does the proxyprovider make this?
00220                boost::shared_ptr<DataProxyProvider> proxyProv = 
00221                   itRecordProvider->second->proxyProvider(*itProxyProv);
00222                const DataProxyProvider::KeyedProxies& keyedProxies = proxyProv->keyedProxies(recordKey);
00223                if(std::find_if(keyedProxies.begin(), keyedProxies.end(), 
00224                                 boost::bind(std::equal_to<DataKey>(), datumKey, boost::bind(&DataProxyProvider::KeyedProxies::value_type::first,_1))) ==
00225                    keyedProxies.end()){
00226                   throw cms::Exception("ESPreferWrongData")<<"The es_prefer statement for type="<<itInfo->first.type_<<" label=\""<<
00227                   itInfo->first.label_<<"\" specifies the data item \n"
00228                   <<"  type=\""<<itRecData->second.first<<"\" label=\""<<itRecData->second.second<<"\""
00229                   <<"  which is not provided.  Please check spelling.";
00230                }
00231                
00232                EventSetupRecordProvider::DataToPreferredProviderMap& dataToProviderMap
00233                   =returnValue[recordKey];
00234                //has another provider already been specified?
00235                if(dataToProviderMap.end() != dataToProviderMap.find(datumKey)) {
00236                   EventSetupRecordProvider::DataToPreferredProviderMap::iterator itFind =
00237                   dataToProviderMap.find(datumKey);
00238                   throw cms::Exception("ESPreferConflict") <<"Two providers have been set to be preferred for\n"
00239                   <<datumKey.type().name()<<" \""<<datumKey.name().value()<<"\""
00240                   <<"\n the providers are "
00241                   <<"\n 1) type="<<itFind->second.type_<<" label=\""<<itFind->second.label_<<"\""
00242                   <<"\n 2) type="<<itProxyProv->type_<<" label=\""<<itProxyProv->label_<<"\""
00243                   <<"\nPlease modify configuration so only one is preferred";
00244                }
00245                dataToProviderMap.insert(std::make_pair(datumKey,*itProxyProv));
00246             }
00247          }
00248       }
00249    }
00250    return returnValue;
00251 }

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

Definition at line 31 of file DataProxy.cc.

00032 {
00033    static ComponentDescription s_desc;
00034    return &s_desc;
00035 }

template<class T>

void edm::eventsetup::eventSetupGetImplementation	(	EventSetup const &	,
		T const *&
	)			`[inline]`

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

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

Definition at line 342 of file EventSetupProvider.cc.

References it.

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

00346 {
00347   
00348   for(Itr it = itBegin; it != itEnd; ++it) {
00349     //does it depend on the record in question?
00350     const std::set<EventSetupRecordKey>& deps = it->second->dependentRecords();
00351     if(deps.end() != deps.find(iKey)) {
00352       oDependents.push_back(it->second);
00353       //now see who is dependent on this record since they will be indirectly dependent on iKey
00354       findDependents(it->first, itBegin, itEnd, oDependents);
00355     }
00356   }
00357 }

template<class ProxyT>

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

Definition at line 107 of file DataProxyProvider.h.

00109                                               {
00110    iList.push_back(DataProxyProvider::KeyedProxies::value_type(
00111                                              DataKey(DataKey::makeTypeTag<typename ProxyT::value_type>(),
00112                                                      iName),
00113                                              iProxy));
00114    
00115 }

static void edm::eventsetup::preferEverything	(	const ComponentDescription &	iComponent,
		const Providers &	iProviders,
		RecordToPreferred &	iReturnValue
	)			`[static]`

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

Definition at line 117 of file EventSetupProvider.cc.

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

Referenced by determinePreferred().

00120 {
00121    //need to get our hands on the actual DataProxyProvider
00122    bool foundProxyProvider = false;
00123    for(Providers::const_iterator itProvider = iProviders.begin(), itProviderEnd = iProviders.end();
00124        itProvider!= itProviderEnd;
00125        ++itProvider) {
00126       std::set<ComponentDescription> components = itProvider->second->proxyProviderDescriptions();
00127       if(components.find(iComponent)!= components.end()) {
00128          boost::shared_ptr<DataProxyProvider> proxyProv = 
00129          itProvider->second->proxyProvider(*(components.find(iComponent)));
00130          assert(proxyProv.get());
00131          
00132          std::set<EventSetupRecordKey> records = proxyProv->usingRecords();
00133          for(std::set<EventSetupRecordKey>::iterator itRecord = records.begin(),
00134              itRecordEnd = records.end();
00135              itRecord != itRecordEnd;
00136              ++itRecord){
00137             const DataProxyProvider::KeyedProxies& keyedProxies = proxyProv->keyedProxies(*itRecord);
00138             if(!keyedProxies.empty()){
00139                //add them to our output
00140                EventSetupRecordProvider::DataToPreferredProviderMap& dataToProviderMap =
00141                iReturnValue[*itRecord];
00142                
00143                for(DataProxyProvider::KeyedProxies::const_iterator itProxy = keyedProxies.begin(),
00144                    itProxyEnd = keyedProxies.end();
00145                    itProxy != itProxyEnd;
00146                    ++itProxy) {
00147                   EventSetupRecordProvider::DataToPreferredProviderMap::iterator itFind =
00148                   dataToProviderMap.find(itProxy->first);
00149                   if(itFind != dataToProviderMap.end()){
00150                      throw cms::Exception("ESPreferConflict") <<"Two providers have been set to be preferred for\n"
00151                      <<itProxy->first.type().name()<<" \""<<itProxy->first.name().value()<<"\""
00152                      <<"\n the providers are "
00153                      <<"\n 1) type="<<itFind->second.type_<<" label=\""<<itFind->second.label_<<"\""
00154                      <<"\n 2) type="<<iComponent.type_<<" label=\""<<iComponent.label_<<"\""
00155                      <<"\nPlease modify configuration so only one is preferred";
00156                   }
00157                   dataToProviderMap.insert(std::make_pair(itProxy->first,iComponent));
00158                }
00159             }
00160          }
00161          foundProxyProvider=true;
00162          break;
00163       }
00164    }
00165    if(!foundProxyProvider) {
00166       throw cms::Exception("ESPreferNoProvider")<<"Could not make type=\""<<iComponent.type_
00167       <<"\" label=\""<<iComponent.label_<<"\" a preferred Provider."<<
00168       "\n  Please check spelling of name, or that it was loaded into the job.";
00169    }
00170 }

void edm::eventsetup::swap	(	DataKey &	a,
		DataKey &	b
	)			`[inline]`

Definition at line 100 of file DataKey.h.

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

00101     {
00102       a.swap(b);
00103     }

edm::eventsetup Namespace Reference

Classes

Namespaces

Typedefs

Functions

Typedef Documentation

Function Documentation


Classes
class	Callback
struct	CallbackBase
class	CallbackProxy
struct	CallbackSimpleDecorator
struct	ComponentDescription
class	ComponentFactory
class	ComponentMaker
class	ComponentMakerBase
struct	data_default_record_trait
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 > >
class	DependentEventSetupRecordProvider
class	DependentEventSetupRecordProviderTemplate
class	DependentRecordImplementation
class	DependentRecordIntervalFinder
struct	DependentRecordTag
struct	DependsOnCaller
struct	DependsOnDoNothingCaller
class	ESPreFunctorDecorator
class	EventSetupProvider
class	EventSetupRecord
class	EventSetupRecordImplementation
class	EventSetupRecordKey
class	EventSetupRecordProvider
class	EventSetupRecordProviderFactory
class	EventSetupRecordProviderFactoryManager
class	EventSetupRecordProviderFactoryTemplate
class	EventSetupRecordProviderTemplate
struct	FactoryInfo
class	IntersectingIOVRecordIntervalFinder
struct	LooperMaker
struct	LooperMakerTraits
class	MakeDataException
struct	ModuleMaker
struct	ModuleMakerTraits
class	NameTag
class	NoDataException
class	NoProxyException
class	NoRecordException
class	ProxyArgumentFactoryTemplate
class	ProxyFactoryBase
class	ProxyFactoryTemplate
class	SimpleStringTag
struct	SourceMaker
struct	SourceMakerTraits
Namespaces
namespace	depends_on
namespace	heterocontainer
namespace	looper
namespace	produce
Typedefs
typedef NameTag	IdTags
typedef Providers::iterator	Itr
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 < EventSetupRecordKey, boost::shared_ptr < EventSetupRecordProvider > >	Providers
typedef std::map< DataKey, const DataProxy * >	Proxies
typedef std::map < EventSetupRecordKey, EventSetupRecordProvider::DataToPreferredProviderMap >	RecordToPreferred
typedef ComponentFactory < SourceMakerTraits >	SourceFactory
typedef edmplugin::PluginFactory < edm::eventsetup::ComponentMakerBase < edm::eventsetup::SourceMakerTraits > *()>	SourcePluginFactory
typedef heterocontainer::HCTypeTag < DataKey >	TypeTag
Functions
template<class T>
void	addProviderTo (EventSetupProvider &, boost::shared_ptr< T >, const void *)
template<class T>
void	addProviderTo (EventSetupProvider &iProvider, boost::shared_ptr< T > iComponent, const DataProxyProvider *)
template<typename FromT, typename ToT>
void	copyFromTo (FromT &iFrom, ToT &iTo)
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<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 TDecorator>
const TDecorator &	createDecoratorFrom (T , const TRecord , const TDecorator &iDec)
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)
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)
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 TDependsOnRecord>
depends_on::OneHolder< T, TDependsOnRecord >	dependsOn (void(T::*iT)(const TDependsOnRecord &))
static RecordToPreferred	determinePreferred (const EventSetupProvider::PreferredProviderInfo *iInfo, const Providers &iProviders)
static const ComponentDescription *	dummyDescription ()
template<class T>
void	eventSetupGetImplementation (EventSetup const &, T const *&)
static void	findDependents (const EventSetupRecordKey &iKey, Itr itBegin, Itr itEnd, std::vector< boost::shared_ptr< EventSetupRecordProvider > > &oDependents)
template<class ProxyT>
void	insertProxy (DataProxyProvider::KeyedProxies &iList, boost::shared_ptr< ProxyT > iProxy, const char *iName="")
static void	preferEverything (const ComponentDescription &iComponent, const Providers &iProviders, RecordToPreferred &iReturnValue)
	find everything made by a DataProxyProvider and add it to the 'preferred' list
void	swap (DataKey &a, DataKey &b)