CollHandle.h

Go to the documentation of this file.

/*
 */
 
#ifndef EcalDigis_CollHandle_h
#define EcalDigis_CollHandle_h
 
#include "FWCore/Utilities/interface/InputTag.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/ConsumesCollector.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
 
template <class T>
class CollHandle {
  //constructor(s) and destructor(s)
public:
  CollHandle(const edm::InputTag& tag, bool failIfNotFound = true, bool notFoundWarn = true)
      : tag_(tag),
        token_(),
        currentColl_(&emptyColl_),
        notFoundAlreadyWarned_(false),
        failIfNotFound_(failIfNotFound),
        notFoundWarn_(notFoundWarn) {}
 
  //method(s)
public:
  /*
    Receives the "ConsumesCollector" from the EDAnalyzer and declares the usage
     of the collection, as well as storing the token for it.
  */
 
  void setToken(edm::ConsumesCollector& collector) { token_ = collector.consumes<T>(tag_); }
 
  void read(const edm::Event& event) {
    //    try{
    edm::Handle<T> hColl;
    event.getByToken(token_, hColl);
 
    //If we must be tolerant to product absence, then
    //we must check validaty before calling Handle::operator*
    //to prevent exception throw:
    if (!failIfNotFound_                               // product-not-found tolerant mode
        && !hColl.isValid()) {                         // and the product was not found
      if (notFoundWarn_ && !notFoundAlreadyWarned_) {  //warning logged only once
        edm::LogWarning("ProductNotFound") << tag_
                                           << " product "
                                              "of type '"
                                           << typeid(T).name() << "' was not found!";
        notFoundAlreadyWarned_ = true;
      }
      currentColl_ = &emptyColl_;
    } else {
      currentColl_ = &(*hColl);
    }
  }
 
  const T* operator->() const { return currentColl_; }
 
  const T& operator*() const { return *currentColl_; }
 
  edm::InputTag tag() const { return tag_; }
 
private:
  //attribute(s)
protected:
private:
  const edm::InputTag tag_;
 
  /* EDM "Token" that is used in the actual data retrieval */
  edm::EDGetTokenT<T> token_;
 
  const T* currentColl_;
 
  const T emptyColl_;
 
  bool notFoundAlreadyWarned_;
 
  bool failIfNotFound_;
 
  bool notFoundWarn_;
};
 
#endif