ConsumesCollector.h

Go to the documentation of this file.

#ifndef FWCore_Framework_ConsumesCollector_h
#define FWCore_Framework_ConsumesCollector_h
// -*- C++ -*-
//
// Package:     FWCore/Framework
// Class  :     edm::ConsumesCollector
// 
//
// Original Author:  Chris Jones
//         Created:  Fri, 07 Jun 2013 12:44:47 GMT
//

// system include files

// user include files
#include "FWCore/Framework/interface/EDConsumerBase.h"
#include "FWCore/Utilities/interface/propagate_const.h"

// forward declarations
namespace edm {
  class EDConsumerBase;
  
  class ConsumesCollector
  {
    
  public:

    ConsumesCollector() = delete;
    ConsumesCollector(ConsumesCollector const&) = default;
    ConsumesCollector(ConsumesCollector&&) = default;
    ConsumesCollector& operator=(ConsumesCollector const&) = default;
    ConsumesCollector& operator=(ConsumesCollector&&) = default;

    // ---------- member functions ---------------------------
    template <typename ProductType, BranchType B=InEvent>
    EDGetTokenT<ProductType> consumes(edm::InputTag const& tag) {
      return m_consumer->consumes<ProductType,B>(tag);
    }
    
    EDGetToken consumes(const TypeToGet& id, edm::InputTag const& tag) {
      return m_consumer->consumes(id,tag);
    }
    
    template <BranchType B>
    EDGetToken consumes(TypeToGet const& id, edm::InputTag const& tag) {
      return m_consumer->consumes<B>(id,tag);
    }
    
    template <typename ProductType, BranchType B=InEvent>
    EDGetTokenT<ProductType> mayConsume(edm::InputTag const& tag) {
      return m_consumer->mayConsume<ProductType,B>(tag);
    }
    
    
    EDGetToken mayConsume(const TypeToGet& id, edm::InputTag const& tag) {
      return m_consumer->mayConsume(id,tag);
    }
    
    template <BranchType B>
    EDGetToken mayConsume(const TypeToGet& id, edm::InputTag const& tag) {
      return m_consumer->mayConsume<B>(id,tag);
    }
    
    template <typename ProductType, BranchType B=InEvent>
    void consumesMany() {
      m_consumer->consumesMany<ProductType,B>();
    }
    
    
    void consumesMany(const TypeToGet& id) {
      m_consumer->consumesMany(id);
    }
    
    template <BranchType B>
    void consumesMany(const TypeToGet& id) {
      m_consumer->consumesMany<B>(id);
    }
    
    // For consuming event-setup products
    template <typename ESProduct, typename ESRecord, Transition Tr = Transition::Event>
    auto esConsumes()
    {
      return esConsumes<ESProduct, ESRecord, Tr>(ESInputTag{});
    }

    template <typename ESProduct, typename ESRecord, Transition Tr = Transition::Event>
    auto esConsumes(ESInputTag const& tag)
    {
      return m_consumer->esConsumes<ESProduct, ESRecord, Tr>(tag);
    }

    template <typename ESProduct, Transition Tr = Transition::Event>
    auto esConsumes(eventsetup::EventSetupRecordKey const& key, ESInputTag const& tag)
    {
      return m_consumer->esConsumes<ESProduct, Tr>(key, tag);
    }

  private:
    //only EDConsumerBase is allowed to make an instance of this class
    friend class EDConsumerBase;
    
    ConsumesCollector(EDConsumerBase* iConsumer):
    m_consumer(iConsumer) {}

    // ---------- member data --------------------------------
    edm::propagate_const<EDConsumerBase*> m_consumer;
    
  };
}


#endif