FFTJetRcdMapper.h

Go to the documentation of this file.

#ifndef JetMETCorrections_FFTJetObjects_FFTJetRcdMapper_h
#define JetMETCorrections_FFTJetObjects_FFTJetRcdMapper_h
 
//
// A factory to combat the proliferation of ES record types
// (multiple record types are necessary due to deficiencies
// in the record dependency tracking mechanism). Templated
// upon the data type which records hold.
//
// Igor Volobouev
// 08/03/2012
 
#include <map>
#include <string>
 
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Utilities/interface/Exception.h"
 
template <class DataType>
struct AbsFFTJetRcdMapper {
  virtual ~AbsFFTJetRcdMapper() {}
 
  virtual void load(const edm::EventSetup& iSetup, edm::ESHandle<DataType>& handle) const = 0;
 
  virtual void load(const edm::EventSetup& iSetup, const std::string& label, edm::ESHandle<DataType>& handle) const = 0;
};
 
template <class DataType, class RecordType>
struct ConcreteFFTJetRcdMapper : public AbsFFTJetRcdMapper<DataType> {
  ~ConcreteFFTJetRcdMapper() override {}
 
  inline void load(const edm::EventSetup& iSetup, edm::ESHandle<DataType>& handle) const override {
    iSetup.get<RecordType>().get(handle);
  }
 
  inline void load(const edm::EventSetup& iSetup,
                   const std::string& label,
                   edm::ESHandle<DataType>& handle) const override {
    iSetup.get<RecordType>().get(label, handle);
  }
};
 
template <class DataType>
struct DefaultFFTJetRcdMapper : public std::map<std::string, AbsFFTJetRcdMapper<DataType>*> {
  typedef DataType data_type;
 
  inline DefaultFFTJetRcdMapper() : std::map<std::string, AbsFFTJetRcdMapper<DataType>*>() {}
 
  virtual ~DefaultFFTJetRcdMapper() {
    for (typename std::map<std::string, AbsFFTJetRcdMapper<DataType>*>::iterator it = this->begin(); it != this->end();
         ++it)
      delete it->second;
  }
 
  inline void load(const edm::EventSetup& iSetup, const std::string& record, edm::ESHandle<DataType>& handle) const {
    typename std::map<std::string, AbsFFTJetRcdMapper<DataType>*>::const_iterator it = this->find(record);
    if (it == this->end())
      throw cms::Exception("KeyNotFound") << "Record \"" << record << "\" is not registered\n";
    it->second->load(iSetup, handle);
  }
 
  inline void load(const edm::EventSetup& iSetup,
                   const std::string& record,
                   const std::string& label,
                   edm::ESHandle<DataType>& handle) const {
    typename std::map<std::string, AbsFFTJetRcdMapper<DataType>*>::const_iterator it = this->find(record);
    if (it == this->end())
      throw cms::Exception("KeyNotFound") << "Record \"" << record << "\" is not registered\n";
    it->second->load(iSetup, label, handle);
  }
 
  DefaultFFTJetRcdMapper(const DefaultFFTJetRcdMapper&) = delete;
  DefaultFFTJetRcdMapper& operator=(const DefaultFFTJetRcdMapper&) = delete;
};
 
//
// Singleton for the mapper
//
template <class Mapper>
class StaticFFTJetRcdMapper {
public:
  typedef typename Mapper::Base::data_type data_type;
 
  static const Mapper& instance() {
    static Mapper obj;
    return obj;
  }
 
  template <class Record>
  static void registerRecord(const std::string& record) {
    Mapper& rd = const_cast<Mapper&>(instance());
    delete rd[record];
    rd[record] = new ConcreteFFTJetRcdMapper<data_type, Record>();
  }
 
  StaticFFTJetRcdMapper() = delete;
};
 
#endif  // JetMETCorrections_FFTJetObjects_FFTJetRcdMapper_h