ProducerBase.h

Go to the documentation of this file.

#ifndef FWCore_Framework_ProducerBase_h
#define FWCore_Framework_ProducerBase_h

/*----------------------------------------------------------------------
  
EDProducer: The base class of all "modules" that will insert new
EDProducts into an Event.

----------------------------------------------------------------------*/

#include "FWCore/Framework/interface/ProductRegistryHelper.h"
#include "FWCore/Utilities/interface/ProductResolverIndex.h"

#include <functional>
#include <unordered_map>
#include <string>
#include <vector>
#include <array>

namespace edm {
  class BranchDescription;
  class ModuleDescription;
  class ProductRegistry;
  class Event;
  class LuminosityBlock;
  class Run;
  
  class EDProducer;
  class EDFilter;
  namespace one {
    class EDProducerBase;
    class EDFilterBase;
  }
  namespace global {
    class EDProducerBase;
    class EDFilterBase;
  }
  namespace limited {
    class EDProducerBase;
    class EDFilterBase;
  }
  namespace stream {
    template<typename T> class ProducingModuleAdaptorBase;
  }
  
  namespace producerbasehelper{
    template<typename P> struct PrincipalTraits;
    template<> struct PrincipalTraits<Run> {
      static constexpr int kBranchType = InRun;
    };
    template<> struct PrincipalTraits<LuminosityBlock> {
      static constexpr int kBranchType = InLumi;
    };
    template<> struct PrincipalTraits<Event> {
      static constexpr int kBranchType = InEvent;
    };
  }
  
  class ProducerBase : private ProductRegistryHelper {
  public:
    typedef ProductRegistryHelper::TypeLabelList TypeLabelList;
    ProducerBase ();
    ~ProducerBase() noexcept(false) override;
 
    std::function<void(BranchDescription const&)> registrationCallback() const;

    void registerProducts(ProducerBase*,
            ProductRegistry*,
            ModuleDescription const&);

    using ProductRegistryHelper::produces;
    using ProductRegistryHelper::typeLabelList;
    using ProductRegistryHelper::recordProvenanceList;

    void callWhenNewProductsRegistered(std::function<void(BranchDescription const&)> const& func) {
       callWhenNewProductsRegistered_ = func;
    }
    
    using ModuleToResolverIndicies = std::unordered_multimap<std::string,
    std::tuple<edm::TypeID const*, const char*, edm::ProductResolverIndex>>;
    void resolvePutIndicies(BranchType iBranchType,
                            ModuleToResolverIndicies const& iIndicies,
                            std::string const& moduleLabel);
    
    std::vector<edm::ProductResolverIndex> const& indiciesForPutProducts(BranchType iBranchType) const {
      return putIndicies_[iBranchType];
    }
    
    std::vector<edm::ProductResolverIndex> const&
    putTokenIndexToProductResolverIndex() const {
      return putTokenToResolverIndex_;
    }
  private:
    friend class EDProducer;
    friend class EDFilter;
    friend class one::EDProducerBase;
    friend class one::EDFilterBase;
    friend class global::EDProducerBase;
    friend class global::EDFilterBase;
    friend class limited::EDProducerBase;
    friend class limited::EDFilterBase;
    friend class PuttableSourceBase;
    template<typename T> friend class stream::ProducingModuleAdaptorBase;
    
    template< typename P>
    void commit_(P& iPrincipal) {
      iPrincipal.commit_(putIndicies_[producerbasehelper::PrincipalTraits<P>::kBranchType]);
    }

    template< typename P, typename I>
    void commit_(P& iPrincipal, I* iID) {
      iPrincipal.commit_(putIndicies_[producerbasehelper::PrincipalTraits<P>::kBranchType], iID);
    }

    std::function<void(BranchDescription const&)> callWhenNewProductsRegistered_;
    std::array<std::vector<edm::ProductResolverIndex>, edm::NumBranchTypes> putIndicies_;
    std::vector<edm::ProductResolverIndex> putTokenToResolverIndex_;
  };
}
#endif