DataProxyProvider.h

Go to the documentation of this file.

#ifndef FWCore_Framework_DataProxyProvider_h
#define FWCore_Framework_DataProxyProvider_h
// -*- C++ -*-
//
// Package:     Framework
// Class  :     DataProxyProvider
//
//
// Author:      Chris Jones
// Created:     Mon Mar 28 14:21:58 EST 2005
//
 
// system include files
#include <memory>
#include <set>
#include <string>
#include <vector>
 
// user include files
#include "FWCore/Framework/interface/DataKey.h"
#include "FWCore/Framework/interface/ComponentDescription.h"
#include "FWCore/Framework/interface/EventSetupRecordKey.h"
#include "FWCore/Utilities/interface/propagate_const.h"
 
// forward declarations
namespace edm {
  class ConfigurationDescriptions;
  class ParameterSet;
 
  namespace eventsetup {
    class DataProxy;
    class ESRecordsToProxyIndices;
 
    class DataProxyProvider {
    public:
      DataProxyProvider();
      DataProxyProvider(const DataProxyProvider&) = delete;
      const DataProxyProvider& operator=(const DataProxyProvider&) = delete;
      virtual ~DataProxyProvider() noexcept(false);
 
      class DataProxyContainer;
 
      class KeyedProxies {
      public:
        KeyedProxies(DataProxyContainer*, unsigned int recordIndex);
 
        bool unInitialized() const;
 
        EventSetupRecordKey const& recordKey() const;
 
        void insert(std::vector<std::pair<DataKey, std::shared_ptr<DataProxy>>>&&,
                    std::string const& appendToDataLabel);
 
        bool contains(DataKey const& dataKey) const;
 
        unsigned int size() const;
 
        // Not an STL iterator and cannot be used as one
        class Iterator {
        public:
          DataKey& dataKey() { return *dataKeysIter_; }
          DataProxy* dataProxy() { return dataProxiesIter_->get(); }
          Iterator& operator++();
 
          bool operator!=(Iterator const& right) const { return dataKeysIter_ != right.dataKeysIter_; }
 
          // Warning: dereference operator does not return a reference to an element in a container.
          // The return type is nonstandard because the iteration is simultaneous over 2 containers.
          // This return type is used in "ranged-based for" loops.
          struct KeyedProxy {
            KeyedProxy(DataKey& dataKey, DataProxy* dataProxy) : dataKey_(dataKey), dataProxy_(dataProxy) {}
            DataKey& dataKey_;
            DataProxy* dataProxy_;
          };
          KeyedProxy operator*() { return KeyedProxy(dataKey(), dataProxy()); }
 
        private:
          friend KeyedProxies;
          Iterator(std::vector<DataKey>::iterator dataKeysIter,
                   std::vector<edm::propagate_const<std::shared_ptr<DataProxy>>>::iterator dataProxiesIter);
 
          std::vector<DataKey>::iterator dataKeysIter_;
          std::vector<edm::propagate_const<std::shared_ptr<DataProxy>>>::iterator dataProxiesIter_;
        };
 
        Iterator begin();
        Iterator end();
 
      private:
        edm::propagate_const<DataProxyContainer*> dataProxyContainer_;
        unsigned int recordIndex_;
        unsigned int dataProxiesIndex_;
      };
 
      struct PerRecordInfo {
        PerRecordInfo(const EventSetupRecordKey&);
        bool operator<(const PerRecordInfo& right) const { return recordKey_ < right.recordKey_; }
        bool operator==(const PerRecordInfo& right) const { return recordKey_ == right.recordKey_; }
 
        EventSetupRecordKey recordKey_;
        unsigned int nDataKeys_ = 0;
        unsigned int indexToDataKeys_;
        unsigned int nIOVs_ = 0;
        unsigned int indexToKeyedProxies_ = 0;
      };
 
      class DataProxyContainer {
      public:
        void usingRecordWithKey(const EventSetupRecordKey&);
        bool isUsingRecord(const EventSetupRecordKey&) const;
        std::set<EventSetupRecordKey> usingRecords() const;
        void fillRecordsNotAllowingConcurrentIOVs(std::set<EventSetupRecordKey>& recordsNotAllowingConcurrentIOVs) const;
 
        void sortEventSetupRecordKeys();
        void createKeyedProxies(EventSetupRecordKey const& key, unsigned int nConcurrentIOVs);
 
        KeyedProxies& keyedProxies(const EventSetupRecordKey& iRecordKey, unsigned int iovIndex);
 
      private:
        friend KeyedProxies;
 
        std::vector<PerRecordInfo> perRecordInfos_;
        std::vector<KeyedProxies> keyedProxiesCollection_;
        std::vector<DataKey> dataKeys_;
        std::vector<edm::propagate_const<std::shared_ptr<DataProxy>>> dataProxies_;
      };
 
      bool isUsingRecord(const EventSetupRecordKey& key) const { return dataProxyContainer_.isUsingRecord(key); }
      std::set<EventSetupRecordKey> usingRecords() const { return dataProxyContainer_.usingRecords(); }
      void fillRecordsNotAllowingConcurrentIOVs(std::set<EventSetupRecordKey>& recordsNotAllowingConcurrentIOVs) const {
        dataProxyContainer_.fillRecordsNotAllowingConcurrentIOVs(recordsNotAllowingConcurrentIOVs);
      }
 
      virtual void initConcurrentIOVs(EventSetupRecordKey const& key, unsigned int nConcurrentIOVs) {}
 
      void createKeyedProxies(EventSetupRecordKey const& key, unsigned int nConcurrentIOVs) {
        dataProxyContainer_.createKeyedProxies(key, nConcurrentIOVs);
        initConcurrentIOVs(key, nConcurrentIOVs);
      }
 
      const ComponentDescription& description() const { return description_; }
 
      virtual void updateLookup(ESRecordsToProxyIndices const&);
 
      void setDescription(const ComponentDescription& iDescription) { description_ = iDescription; }
 
      void setAppendToDataLabel(const edm::ParameterSet&);
 
      KeyedProxies& keyedProxies(const EventSetupRecordKey& iRecordKey, unsigned int iovIndex = 0);
 
      static void prevalidate(ConfigurationDescriptions&);
 
    protected:
      template <class T>
      void usingRecord() {
        usingRecordWithKey(EventSetupRecordKey::makeKey<T>());
      }
 
      void usingRecordWithKey(const EventSetupRecordKey& key) { dataProxyContainer_.usingRecordWithKey(key); }
 
      using KeyedProxiesVector = std::vector<std::pair<DataKey, std::shared_ptr<DataProxy>>>;
      virtual KeyedProxiesVector registerProxies(const EventSetupRecordKey&, unsigned int iovIndex) = 0;
 
    private:
      // ---------- member data --------------------------------
      DataProxyContainer dataProxyContainer_;
      ComponentDescription description_;
      std::string appendToDataLabel_;
    };
 
  }  // namespace eventsetup
}  // namespace edm
#endif