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/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 {

    //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;
    }
  }
  class ESProducer : public ESProxyFactoryProducer
  {

  public:
    ESProducer();
    ~ESProducer() noexcept(false) override;

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

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

    // ---------- member functions ---------------------------
  protected:
    template<typename T>
    void setWhatProduced(T* iThis, const es::Label& iLabel = es::Label()) {
      setWhatProduced(iThis , &T::produce, iLabel);
    }

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

    template<typename T, typename TDecorator >
    void setWhatProduced(T* iThis, const TDecorator& iDec, const es::Label& iLabel = es::Label()) {
      setWhatProduced(iThis , &T::produce, iDec, iLabel);
    }
    template<typename T, typename TReturn, typename TRecord>
    void setWhatProduced(T* iThis,
                         TReturn (T ::* iMethod)(const TRecord&),
                         const es::Label& iLabel = es::Label()) {
      setWhatProduced(iThis, iMethod, eventsetup::CallbackSimpleDecorator<TRecord>(),iLabel);
    }
    template<typename T, typename TReturn, typename TRecord, typename TArg>
    void setWhatProduced(T* iThis,
                         TReturn (T ::* iMethod)(const TRecord&),
                         const TArg& iDec,
                         const es::Label& iLabel = es::Label()) {
      auto callback = std::make_shared<eventsetup::Callback<T,
                                                            TReturn,
                                                            TRecord,
                                                            typename eventsetup::DecoratorFromArg<T,TRecord,TArg>::Decorator_t>>(iThis,
                                                                                                                                 iMethod,
                                                                                                                                 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);
      //static_assert((std::is_base_of<ED, T>::type));
    }

    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]);
    }

  };
}
#endif