#include <EventSetupProvider.h>

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

typedef std::string	DataLabel

typedef std::string	DataType

typedef std::map < ComponentDescription, RecordToDataMap >	PreferredProviderInfo

typedef std::string	RecordName

typedef std::multimap < RecordName, DataKeyInfo >	RecordToDataMap

Public Member Functions
void	add (boost::shared_ptr< DataProxyProvider >)

void	add (boost::shared_ptr< EventSetupRecordIntervalFinder >)

void	addRecordToEventSetup (EventSetupRecord &iRecord)

EventSetup const &	eventSetup () const

EventSetup const &	eventSetupForInstance (IOVSyncValue const &)

	EventSetupProvider (PreferredProviderInfo const *iInfo=0)

void	finishConfiguration ()

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

std::set< ComponentDescription >	proxyProviderDescriptions () const

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

virtual	~EventSetupProvider ()

Protected Member Functions
template<typename T >
void	insert (std::auto_ptr< T > iRecordProvider)

Private Types
typedef std::map < EventSetupRecordKey, boost::shared_ptr < EventSetupRecordProvider > >	Providers

Private Member Functions
	EventSetupProvider (EventSetupProvider const &)

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

EventSetupProvider const &	operator= (EventSetupProvider const &)

Private Attributes
std::auto_ptr< std::vector < boost::shared_ptr < DataProxyProvider > > >	dataProviders_

EventSetup	eventSetup_

std::auto_ptr< std::vector < boost::shared_ptr < EventSetupRecordIntervalFinder > > >	finders_

bool	mustFinishConfiguration_

std::auto_ptr < PreferredProviderInfo >	preferredProviderInfo_

Providers	providers_

Detailed Description

Definition at line 45 of file EventSetupProvider.h.

Member Typedef Documentation

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

Definition at line 51 of file EventSetupProvider.h.

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

Definition at line 50 of file EventSetupProvider.h.

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

Definition at line 49 of file EventSetupProvider.h.

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

Definition at line 53 of file EventSetupProvider.h.

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

private

Definition at line 101 of file EventSetupProvider.h.

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

Definition at line 48 of file EventSetupProvider.h.

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

Definition at line 52 of file EventSetupProvider.h.

Constructor & Destructor Documentation

EventSetupProvider::EventSetupProvider ( PreferredProviderInfo const * iInfo = 0 )

Definition at line 42 of file EventSetupProvider.cc.

                                                                          :
 eventSetup_(),
 providers_(),
 mustFinishConfiguration_(true),
 preferredProviderInfo_((0!=iInfo) ? (new PreferredProviderInfo(*iInfo)): 0),
 finders_(new std::vector<boost::shared_ptr<EventSetupRecordIntervalFinder> >() ),
 dataProviders_(new std::vector<boost::shared_ptr<DataProxyProvider> >() )
 {
 }

EventSetupProvider::~EventSetupProvider ( )

virtual

Definition at line 57 of file EventSetupProvider.cc.

58 {

59 }

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

private

Member Function Documentation

void EventSetupProvider::add ( boost::shared_ptr< DataProxyProvider > iProvider )

Definition at line 85 of file EventSetupProvider.cc.

References dataProviders_, and mustFinishConfiguration_.

Referenced by edm::eventsetup::looper::addFinderTo(), edm::eventsetup::addProviderTo(), edm::eventsetup::looper::addProviderTo(), edm::eventsetup::ModuleMakerTraits::addTo(), and edm::eventsetup::SourceMakerTraits::addTo().

 {
    mustFinishConfiguration_ = true;
    assert(&(*iProvider) != 0);
    dataProviders_->push_back(iProvider);
 }

void EventSetupProvider::add ( boost::shared_ptr< EventSetupRecordIntervalFinder > iFinder )

Definition at line 94 of file EventSetupProvider.cc.

References finders_, and mustFinishConfiguration_.

 {
    mustFinishConfiguration_ = true;
    assert(&(*iFinder) != 0);
    finders_->push_back(iFinder);
 }

void EventSetupProvider::addRecordToEventSetup ( EventSetupRecord & iRecord )

Definition at line 403 of file EventSetupProvider.cc.

References edm::EventSetup::add(), eventSetup_, and edm::eventsetup::EventSetupRecord::setEventSetup().

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

                                                                    {
    iRecord.setEventSetup(&eventSetup_);
    eventSetup_.add(iRecord);
 }

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

inline

Definition at line 65 of file EventSetupProvider.h.

References eventSetup_.

65 {return eventSetup_;}

edm::eventsetup::EventSetupProvider::eventSetup_

EventSetup eventSetup_

Definition: EventSetupProvider.h:100

EventSetup const & EventSetupProvider::eventSetupForInstance ( IOVSyncValue const & iValue )

Definition at line 412 of file EventSetupProvider.cc.

References edm::EventSetup::clear(), eventSetup_, finishConfiguration(), mustFinishConfiguration_, providers_, and edm::EventSetup::setIOVSyncValue().

 {
    eventSetup_.setIOVSyncValue(iValue);
 
    eventSetup_.clear();
    if(mustFinishConfiguration_) {
       const_cast<EventSetupProvider*>(this)->finishConfiguration();
    }
 
    for(Providers::iterator itProvider = providers_.begin(), itProviderEnd = providers_.end();
         itProvider != itProviderEnd;
         ++itProvider) {
       itProvider->second->addRecordToIfValid(*this, iValue);
    }
    
    return eventSetup_;
 
    
 }

void EventSetupProvider::finishConfiguration ( )

Definition at line 243 of file EventSetupProvider.cc.

References dataProviders_, edm::eventsetup::determinePreferred(), finders_, insert(), edm::eventsetup::EventSetupRecordProviderFactoryManager::instance(), mustFinishConfiguration_, preferredProviderInfo_, and providers_.

Referenced by eventSetupForInstance().

 {   
    //we delayed adding finders to the system till here so that everything would be loaded first
    for(std::vector<boost::shared_ptr<EventSetupRecordIntervalFinder> >::iterator itFinder=finders_->begin(),
        itEnd = finders_->end();
        itFinder != itEnd;
        ++itFinder) {
       typedef std::set<EventSetupRecordKey> Keys;
       const Keys recordsUsing = (*itFinder)->findingForRecords();
       
       for(Keys::const_iterator itKey = recordsUsing.begin(), itKeyEnd = recordsUsing.end();
           itKey != itKeyEnd;
           ++itKey) {
          Providers::iterator itFound = providers_.find(*itKey);
          if(providers_.end() == itFound) {
             //create a provider for this record
             insert(*itKey, EventSetupRecordProviderFactoryManager::instance().makeRecordProvider(*itKey));
             itFound = providers_.find(*itKey);
          }
          itFound->second->addFinder(*itFinder);
       }      
    }
    //we've transfered our ownership so this is no longer needed
    finders_.reset();
    
    //Now handle providers since sources can also be finders and the sources can delay registering
    // their Records and therefore could delay setting up their Proxies
    typedef std::set<EventSetupRecordKey> Keys;
    for(std::vector<boost::shared_ptr<DataProxyProvider> >::iterator itProvider=dataProviders_->begin(),
        itEnd = dataProviders_->end();
        itProvider != itEnd;
        ++itProvider) {
       
       const Keys recordsUsing = (*itProvider)->usingRecords();
       
       for(Keys::const_iterator itKey = recordsUsing.begin(), itKeyEnd = recordsUsing.end();
           itKey != itKeyEnd;
           ++itKey) {
          Providers::iterator itFound = providers_.find(*itKey);
          if(providers_.end() == itFound) {
             //create a provider for this record
             insert(*itKey, EventSetupRecordProviderFactoryManager::instance().makeRecordProvider(*itKey));
             itFound = providers_.find(*itKey);
          }
          itFound->second->add(*itProvider);
       }
    }
    dataProviders_.reset();
    
    //used for the case where no preferred Providers have been specified for the Record
    static const EventSetupRecordProvider::DataToPreferredProviderMap kEmptyMap;
    
    RecordToPreferred recordToPreferred = determinePreferred(preferredProviderInfo_.get(),providers_);
    //For each Provider, find all the Providers it depends on.  If a dependent Provider
    // can not be found pass in an empty list
    //CHANGE: now allow for missing Providers
    for(Providers::iterator itProvider = providers_.begin(), itProviderEnd = providers_.end();
         itProvider != itProviderEnd;
         ++itProvider) {
       const EventSetupRecordProvider::DataToPreferredProviderMap* preferredInfo = &kEmptyMap;
       RecordToPreferred::const_iterator itRecordFound = recordToPreferred.find(itProvider->first);
       if(itRecordFound != recordToPreferred.end()) {
          preferredInfo = &(itRecordFound->second);
       }
       //Give it our list of preferred 
       itProvider->second->usePreferred(*preferredInfo);
       
       std::set<EventSetupRecordKey> records = itProvider->second->dependentRecords();
       if(records.size() != 0) {
          std::string missingRecords;
          std::vector<boost::shared_ptr<EventSetupRecordProvider> > depProviders;
          depProviders.reserve(records.size());
          bool foundAllProviders = true;
          for(std::set<EventSetupRecordKey>::iterator itRecord = records.begin(),
               itRecordEnd = records.end();
               itRecord != itRecordEnd;
               ++itRecord) {
             Providers::iterator itFound = providers_.find(*itRecord);
             if(itFound == providers_.end()) {
                foundAllProviders = false;
                if(missingRecords.size() == 0) {
                  missingRecords = itRecord->name();
                } else {
                  missingRecords += ", ";
                  missingRecords += itRecord->name();
                }
                //break;
             } else {
                depProviders.push_back(itFound->second);
             }
          }
          
          if(!foundAllProviders) {
             edm::LogInfo("EventSetupDependency")<<"The EventSetup record "<<itProvider->second->key().name()
             <<" depends on at least one Record \n ("<<missingRecords<<") which is not present in the job."
            "\n This may lead to an exception begin thrown during event processing.\n If no exception occurs during the job than it is usually safe to ignore this message.";
 
             //depProviders.clear();
            //NOTE: should provide a warning
          }
           
          itProvider->second->setDependentProviders(depProviders);
       }
    }
    mustFinishConfiguration_ = false;
    
 }

void EventSetupProvider::forceCacheClear ( )

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

Definition at line 392 of file EventSetupProvider.cc.

References providers_.

 {
    for(Providers::iterator it=providers_.begin(), itEnd = providers_.end();
        it != itEnd;
        ++it) {
       it->second->resetProxies();
    }
 }

template<typename T >

void edm::eventsetup::EventSetupProvider::insert ( std::auto_ptr< T > iRecordProvider )

inlineprotected

Definition at line 84 of file EventSetupProvider.h.

References edm::eventsetup::heterocontainer::makeKey(), and groupFilesInBlocks::temp.

Referenced by finishConfiguration().

                                                      {
             std::auto_ptr<EventSetupRecordProvider> temp(iRecordProvider.release());
             insert(eventsetup::heterocontainer::makeKey<
                     typename T::RecordType,
                        eventsetup::EventSetupRecordKey>(),
                     temp);
          }

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

private

Definition at line 77 of file EventSetupProvider.cc.

References providers_, and groupFilesInBlocks::temp.

 {
    boost::shared_ptr<EventSetupRecordProvider> temp(iProvider.release());
    providers_[iKey] = temp;
    //temp->addRecordTo(*this);
 }

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

private

std::set< ComponentDescription > EventSetupProvider::proxyProviderDescriptions ( ) const

Definition at line 443 of file EventSetupProvider.cc.

References dataProviders_, edm::for_all(), providers_, edm::eventsetup::EventSetupRecordProvider::proxyProviderDescriptions(), and edm::second().

 {
    using boost::bind;
    typedef std::set<ComponentDescription> Set;
    Set descriptions;
 
    for_all(providers_,
                  bind(InsertAll(descriptions),
                       bind(&EventSetupRecordProvider::proxyProviderDescriptions,
                            bind(&Providers::value_type::second,_1))));
    if(dataProviders_.get()) {
       for(std::vector<boost::shared_ptr<DataProxyProvider> >::const_iterator it = dataProviders_->begin(),
           itEnd = dataProviders_->end();
           it != itEnd;
           ++it) {
          descriptions.insert((*it)->description());
       }
          
    }
                        
    return descriptions;
 }

void EventSetupProvider::resetRecordPlusDependentRecords ( EventSetupRecordKey const & iKey )

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

Definition at line 372 of file EventSetupProvider.cc.

References edm::eventsetup::findDependents(), edm::for_all(), providers_, and edm::eventsetup::EventSetupRecordProvider::resetProxies().

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

 {
   Providers::iterator itFind = providers_.find(iKey);
   if(itFind == providers_.end()) {
     return;
   }
 
   
   std::vector<boost::shared_ptr<EventSetupRecordProvider> > dependents;
   findDependents(iKey, providers_.begin(), providers_.end(), dependents);
 
   dependents.erase(std::unique(dependents.begin(),dependents.end()), dependents.end());
   
   itFind->second->resetProxies();
   for_all(dependents,
                 boost::bind(&EventSetupRecordProvider::resetProxies,
                             _1));
 }