EventSetupProvider.h

Go to the documentation of this file.

#ifndef FWCore_Framework_EventSetupProvider_h
#define FWCore_Framework_EventSetupProvider_h
// -*- C++ -*-
//
// Package:     Framework
// Class:      EventSetupProvider
//
//
// Author:      Chris Jones
// Created:     Thu Mar 24 14:10:07 EST 2005
//
 
#include "FWCore/Utilities/interface/propagate_const.h"
 
#include <map>
#include <memory>
#include <set>
#include <string>
#include <vector>
 
// forward declarations
namespace edm {
  class ActivityRegistry;
  class EventSetupImpl;
  class EventSetupRecordIntervalFinder;
  class IOVSyncValue;
  class ParameterSet;
 
  namespace eventsetup {
    struct ComponentDescription;
    class DataKey;
    class DataProxyProvider;
    class EventSetupRecordImpl;
    class EventSetupRecordKey;
    class EventSetupRecordProvider;
    class EventSetupsController;
    class NumberOfConcurrentIOVs;
    class ParameterSetIDHolder;
    class ESRecordsToProxyIndices;
 
    class EventSetupProvider {
    public:
      typedef std::string RecordName;
      typedef std::string DataType;
      typedef std::string DataLabel;
      typedef std::pair<DataType, DataLabel> DataKeyInfo;
      typedef std::multimap<RecordName, DataKeyInfo> RecordToDataMap;
      typedef std::map<ComponentDescription, RecordToDataMap> PreferredProviderInfo;
 
      EventSetupProvider(ActivityRegistry const*,
                         unsigned subProcessIndex = 0U,
                         PreferredProviderInfo const* iInfo = nullptr);
      EventSetupProvider(EventSetupProvider const&) = delete;
      EventSetupProvider const& operator=(EventSetupProvider const&) = delete;
 
      ~EventSetupProvider();
 
      std::set<ComponentDescription> proxyProviderDescriptions() const;
 
      ESRecordsToProxyIndices recordsToProxyIndices() const;
 
      void setAllValidityIntervals(const IOVSyncValue& iValue);
 
      std::shared_ptr<const EventSetupImpl> eventSetupForInstance(IOVSyncValue const&, bool& newEventSetupImpl);
 
      bool doWeNeedToWaitForIOVsToFinish(IOVSyncValue const&) const;
 
      EventSetupImpl const& eventSetupImpl() const { return *eventSetupImpl_; }
 
      void add(std::shared_ptr<DataProxyProvider>);
      void replaceExisting(std::shared_ptr<DataProxyProvider>);
      void add(std::shared_ptr<EventSetupRecordIntervalFinder>);
 
      void finishConfiguration(NumberOfConcurrentIOVs const&, bool& hasNonconcurrentFinder);
 
      void resetRecordPlusDependentRecords(EventSetupRecordKey const&);
 
      void forceCacheClear();
 
      void checkESProducerSharing(
          EventSetupProvider& precedingESProvider,
          std::set<ParameterSetIDHolder>& sharingCheckDone,
          std::map<EventSetupRecordKey, std::vector<ComponentDescription const*>>& referencedESProducers,
          EventSetupsController& esController);
 
      bool doRecordsMatch(EventSetupProvider& precedingESProvider,
                          EventSetupRecordKey const& eventSetupRecordKey,
                          std::map<EventSetupRecordKey, bool>& allComponentsMatch,
                          EventSetupsController const& esController);
 
      void fillReferencedDataKeys(EventSetupRecordKey const& eventSetupRecordKey);
 
      void resetRecordToProxyPointers();
 
      void clearInitializationData();
 
      unsigned subProcessIndex() const { return subProcessIndex_; }
 
      static void logInfoWhenSharing(ParameterSet const& iConfiguration);
 
      void addRecord(const EventSetupRecordKey& iKey);
      void setPreferredProviderInfo(PreferredProviderInfo const& iInfo);
 
      void fillRecordsNotAllowingConcurrentIOVs(std::set<EventSetupRecordKey>& recordsNotAllowingConcurrentIOVs) const;
 
      void fillKeys(std::set<EventSetupRecordKey>& keys) const;
 
      EventSetupRecordProvider* tryToGetRecordProvider(const EventSetupRecordKey& iKey);
 
    private:
      std::shared_ptr<EventSetupRecordProvider>& recordProvider(const EventSetupRecordKey& iKey);
      void insert(EventSetupRecordKey const&, std::unique_ptr<EventSetupRecordProvider>);
 
      void determinePreferred();
 
      // ---------- member data --------------------------------
 
      using RecordKeys = std::vector<EventSetupRecordKey>;
      RecordKeys recordKeys_;
 
      using RecordProviders = std::vector<std::shared_ptr<EventSetupRecordProvider>>;
      RecordProviders recordProviders_;
 
      ActivityRegistry const* activityRegistry_;
 
      bool mustFinishConfiguration_;
      unsigned subProcessIndex_;
      propagate_const<std::shared_ptr<EventSetupImpl>> eventSetupImpl_;
 
      // The following are all used only during initialization and then cleared.
 
      std::unique_ptr<PreferredProviderInfo> preferredProviderInfo_;
      std::unique_ptr<std::vector<std::shared_ptr<EventSetupRecordIntervalFinder>>> finders_;
      std::unique_ptr<std::vector<std::shared_ptr<DataProxyProvider>>> dataProviders_;
      std::unique_ptr<std::map<EventSetupRecordKey, std::map<DataKey, ComponentDescription const*>>> referencedDataKeys_;
      std::unique_ptr<std::map<EventSetupRecordKey, std::vector<std::shared_ptr<EventSetupRecordIntervalFinder>>>>
          recordToFinders_;
      std::unique_ptr<std::map<ParameterSetIDHolder, std::set<EventSetupRecordKey>>> psetIDToRecordKey_;
      std::unique_ptr<std::map<EventSetupRecordKey, std::map<DataKey, ComponentDescription>>> recordToPreferred_;
      std::unique_ptr<std::set<EventSetupRecordKey>> recordsWithALooperProxy_;
    };
 
  }  // namespace eventsetup
}  // namespace edm
#endif