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