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