ESHandle.h

Go to the documentation of this file.

#ifndef FWCore_Framework_ESHandle_h
#define FWCore_Framework_ESHandle_h
// -*- C++ -*-
//
// Package:     Framework
// Class  :     ESHandle
// 
//
// Author:      Chris Jones
// Created:     Fri Apr  1 14:47:35 EST 2005
//

// system include files

// user include files
#include "FWCore/Framework/interface/ComponentDescription.h"
#include "FWCore/Framework/interface/ESHandleExceptionFactory.h"

#include <exception>
#include <memory>
#include <utility>

namespace edm {

class ESHandleBase {
   public:
      ESHandleBase() : data_(nullptr), description_(nullptr) {}
      ESHandleBase(void const* iData, edm::eventsetup::ComponentDescription const* desc) 
           : data_(iData), description_(desc) {}

      ESHandleBase(std::shared_ptr<ESHandleExceptionFactory>&& iWhyFailed) :
        data_(nullptr),
        description_(nullptr),
        whyFailedFactory_(std::move(iWhyFailed)) {}

      edm::eventsetup::ComponentDescription const* description() const;
      
      bool isValid() const { return 0 != data_ && 0 != description_; }

      bool failedToGet() const { return bool(whyFailedFactory_); }

      void swap(ESHandleBase& iOther) {
         std::swap(data_, iOther.data_);
         std::swap(description_, iOther.description_);
         std::swap(whyFailedFactory_, iOther.whyFailedFactory_);
      }

      std::shared_ptr<ESHandleExceptionFactory> const&
      whyFailedFactory() const { return whyFailedFactory_;}

   protected:
      void const *productStorage() const {
        if (whyFailedFactory_) {
          std::rethrow_exception(whyFailedFactory_->make());
        }
        return data_;
      }

   private:
      // ---------- member data --------------------------------
      void const* data_; 
      edm::eventsetup::ComponentDescription const* description_;
      std::shared_ptr<ESHandleExceptionFactory> whyFailedFactory_;
};

template<typename T>
class ESHandle : public ESHandleBase {
   public:
      typedef T value_type;
   
      ESHandle() : ESHandleBase() {}
      ESHandle(T const* iData) : ESHandleBase(iData, 0) {}
      ESHandle(T const* iData, edm::eventsetup::ComponentDescription const* desc) : ESHandleBase(iData, desc) {}
      ESHandle(std::shared_ptr<ESHandleExceptionFactory> &&);

      // ---------- const member functions ---------------------
      T const* product() const { return static_cast<T const *>(productStorage()); }
      T const* operator->() const { return product(); }
      T const& operator*() const { return *product(); }
      // ---------- static member functions --------------------
      static const bool transientAccessOnly = false;

      // ---------- member functions ---------------------------
      
   private:
};

template <class T>
ESHandle<T>::ESHandle(std::shared_ptr<edm::ESHandleExceptionFactory> && iWhyFailed) :
  ESHandleBase(std::move(iWhyFailed))
{ }

  // Free swap function
  inline
  void
  swap(ESHandleBase& a, ESHandleBase& b) 
  {
    a.swap(b);
  }
}
#endif