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 one
  namespace global {
    class EDProducerBase;
    class EDFilterBase;
  }  // namespace global
  namespace limited {
    class EDProducerBase;
    class EDFilterBase;
  }  // namespace limited
  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;
    };
  }  // namespace producerbasehelper

  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::recordProvenanceList;
    using ProductRegistryHelper::typeLabelList;

    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_;
  };
}  // namespace edm
#endif