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();
      virtual ~ESProducer() noexcept(false);

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

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

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

      template<typename T>
         void setWhatProduced(T* iThis, const char* iLabel) {
            //static_assert((typename std::is_base_of<ED, T>::type));
            setWhatProduced(iThis , es::Label(iLabel));
         }
      template<typename T>
         void setWhatProduced(T* iThis, const std::string& iLabel) {
            //static_assert((typename std::is_base_of<ED, T>::type));
            setWhatProduced(iThis , es::Label(iLabel));
         }
      
      template<typename T, typename TDecorator >
         void setWhatProduced(T* iThis, const TDecorator& iDec, const es::Label& iLabel = es::Label()) {
            //static_assert((typename std::is_base_of<ED, T>::type));
            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));
         }

      /*
      template<typename T, typename TReturn, typename TArg>
         void setWhatProduced(T* iThis, TReturn (T ::* iMethod)(const TArg&)) {
            registerProducts(iThis, static_cast<const typename produce::product_traits<TReturn>::type *>(nullptr));
            registerGet(iThis, static_cast<const TArg*>(nullptr));
            //static_assert((std::is_base_of<ED, T>::type));
         }
      */
   private:
      ESProducer(const ESProducer&); // stop default

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

      /*
      template<typename T, typename TProduct>
         void registerGet(T* i, const TProduct* iProd) {
            std::cout <<"registered 'get' for product type "
            << test::name(iProd) <<
            std::endl;
         };
      */
      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]);
         }
      
      // ---------- member data --------------------------------
      // NOTE: the factories share ownership of the callback
      //std::vector<std::shared_ptr<CallbackBase> > callbacks_;
      
};
}
#endif