ESProducer.h

Go to the documentation of this file.

#ifndef Framework_ESProducer_h
#define Framework_ESProducer_h
// -*- C++ -*-
//
// Package:     Framework
// Class  :     ESProducer
//
//
// Author:      Chris Jones
// Created:     Thu Apr  7 17:08:14 CDT 2005
//

// system include files
#include <memory>
#include <string>

// user include files
#include "FWCore/Framework/interface/ESConsumesCollector.h"
#include "FWCore/Framework/interface/ESProxyFactoryProducer.h"
#include "FWCore/Framework/interface/ProxyArgumentFactoryTemplate.h"

#include "FWCore/Framework/interface/CallbackProxy.h"
#include "FWCore/Framework/interface/Callback.h"
#include "FWCore/Framework/interface/produce_helpers.h"
#include "FWCore/Framework/interface/eventsetup_dependsOn.h"
#include "FWCore/Framework/interface/es_Label.h"

// forward declarations
namespace edm {
  namespace eventsetup {

    class ESRecordsToProxyIndices;
    //used by ESProducer to create the proper Decorator based on the
    //  argument type passed.  The default it to just 'pass through'
    //  the argument as the decorator itself
    template <typename T, typename TRecord, typename TDecorator>
    inline const TDecorator& createDecoratorFrom(T*, const TRecord*, const TDecorator& iDec) {
      return iDec;
    }
  }  // namespace eventsetup
  class ESProducer : public ESProxyFactoryProducer {
  public:
    ESProducer();
    ~ESProducer() noexcept(false) override;

    // ---------- const member functions ---------------------

    // ---------- static member functions --------------------

    // ---------- member functions ---------------------------
    void updateLookup(eventsetup::ESRecordsToProxyIndices const&) final;
    ESProxyIndex const* getTokenIndices(unsigned int iIndex) const {
      if (itemsToGetFromRecords_.empty()) {
        return nullptr;
      }
      return (itemsToGetFromRecords_[iIndex].empty()) ? static_cast<ESProxyIndex const*>(nullptr)
                                                      : &(itemsToGetFromRecords_[iIndex].front());
    }

  protected:
    template <typename T>
    auto setWhatProduced(T* iThis, const es::Label& iLabel = {}) {
      return setWhatProduced(iThis, &T::produce, iLabel);
    }

    template <typename T>
    auto setWhatProduced(T* iThis, const char* iLabel) {
      return setWhatProduced(iThis, es::Label(iLabel));
    }
    template <typename T>
    auto setWhatProduced(T* iThis, const std::string& iLabel) {
      return setWhatProduced(iThis, es::Label(iLabel));
    }

    template <typename T, typename TDecorator>
    auto setWhatProduced(T* iThis, const TDecorator& iDec, const es::Label& iLabel = {}) {
      return setWhatProduced(iThis, &T::produce, iDec, iLabel);
    }
    template <typename T, typename TReturn, typename TRecord>
    auto setWhatProduced(T* iThis, TReturn (T ::*iMethod)(const TRecord&), const es::Label& iLabel = {}) {
      return setWhatProduced(iThis, iMethod, eventsetup::CallbackSimpleDecorator<TRecord>(), iLabel);
    }
    template <typename T, typename TReturn, typename TRecord, typename TArg>
    ESConsumesCollectorT<TRecord> setWhatProduced(T* iThis,
                                                  TReturn (T ::*iMethod)(const TRecord&),
                                                  const TArg& iDec,
                                                  const es::Label& iLabel = {}) {
      const auto id = consumesInfos_.size();
      auto callback = std::make_shared<
          eventsetup::Callback<T, TReturn, TRecord, typename eventsetup::DecoratorFromArg<T, TRecord, TArg>::Decorator_t>>(
          iThis, iMethod, id, createDecoratorFrom(iThis, static_cast<const TRecord*>(nullptr), iDec));
      registerProducts(callback,
                       static_cast<const typename eventsetup::produce::product_traits<TReturn>::type*>(nullptr),
                       static_cast<const TRecord*>(nullptr),
                       iLabel);
      consumesInfos_.push_back(std::make_unique<ESConsumesInfo>());
      return ESConsumesCollectorT<TRecord>(consumesInfos_.back().get(), id);
    }

    ESProducer(const ESProducer&) = delete;                   // stop default
    ESProducer const& operator=(const ESProducer&) = delete;  // stop default

  private:
    template <typename CallbackT, typename TList, typename TRecord>
    void registerProducts(std::shared_ptr<CallbackT> iCallback,
                          const TList*,
                          const TRecord* iRecord,
                          const es::Label& iLabel) {
      registerProduct(iCallback, static_cast<const typename TList::tail_type*>(nullptr), iRecord, iLabel);
      registerProducts(iCallback, static_cast<const typename TList::head_type*>(nullptr), iRecord, iLabel);
    }

    template <typename T, typename TRecord>
    void registerProducts(std::shared_ptr<T>, const eventsetup::produce::Null*, const TRecord*, const es::Label&) {
      //do nothing
    }

    template <typename T, typename TProduct, typename TRecord>
    void registerProduct(std::shared_ptr<T> iCallback, const TProduct*, const TRecord*, const es::Label& iLabel) {
      typedef eventsetup::CallbackProxy<T, TRecord, TProduct> ProxyType;
      typedef eventsetup::ProxyArgumentFactoryTemplate<ProxyType, std::shared_ptr<T>> FactoryType;
      registerFactory(std::make_unique<FactoryType>(iCallback), iLabel.default_);
    }

    template <typename T, typename TProduct, typename TRecord, int IIndex>
    void registerProduct(std::shared_ptr<T> iCallback,
                         const es::L<TProduct, IIndex>*,
                         const TRecord*,
                         const es::Label& iLabel) {
      if (iLabel.labels_.size() <= IIndex || iLabel.labels_[IIndex] == es::Label::def()) {
        Exception::throwThis(errors::Configuration,
                             "Unnamed Label\nthe index ",
                             IIndex,
                             " was never assigned a name in the 'setWhatProduced' method");
      }
      typedef eventsetup::CallbackProxy<T, TRecord, es::L<TProduct, IIndex>> ProxyType;
      typedef eventsetup::ProxyArgumentFactoryTemplate<ProxyType, std::shared_ptr<T>> FactoryType;
      registerFactory(std::make_unique<FactoryType>(iCallback), iLabel.labels_[IIndex]);
    }

    std::vector<std::unique_ptr<ESConsumesInfo>> consumesInfos_;
    std::vector<std::vector<ESProxyIndex>> itemsToGetFromRecords_;
    //need another structure to say which record to get the data from in
    // order to make prefetching work
    std::vector<std::vector<ESRecordIndex>> recordsUsedDuringGet_;
  };
}  // namespace edm
#endif