ValidHandle.h

Go to the documentation of this file.

#ifndef DataFormats_Common_ValidHandle_h
#define DataFormats_Common_ValidHandle_h

/*----------------------------------------------------------------------
  
Handle: Non-owning "smart pointer" for reference to products and
their provenances.

The data product is always guaranteed to be valid for this handle type.
----------------------------------------------------------------------*/

#include <utility>
#include "DataFormats/Provenance/interface/ProductID.h"

namespace edm {
  namespace vhhelper {
    void throwIfNotValid(const void*) noexcept(false);
  }
  template<typename T>
  class ValidHandle {
  public:
    using element_type = T;
    
    ValidHandle() = delete;
    ValidHandle(T const* prod, ProductID id) noexcept(false) :
    product_(prod), id_(std::move(id)) {
      vhhelper::throwIfNotValid(prod);
    }
    
    //NOTE: C++ disallows references to null
    ValidHandle(T const& prod, ProductID id) noexcept(true):
    product_(&prod), id_(std::move(id)) {
    }
    ValidHandle( const ValidHandle<T>& ) = default;
    ValidHandle<T>& operator=(ValidHandle<T> const& rhs) = default;
    ~ValidHandle() = default;
    

    ProductID const&  id() const noexcept(true) { return id_; }

    T const* product() const noexcept(true) {
      return product_;
    }
    
    T const* operator->() const noexcept(true) { return product();}
    T const& operator*() const noexcept(true) { return *product();}
    
  private:
    T const* product_;
    ProductID id_;
  };
  
  template<typename U>
  auto
  makeValid(const U& iOtherHandleType) noexcept(false) {
    vhhelper::throwIfNotValid(iOtherHandleType.product());
    //because of the check, we know this is valid and do not have to check again
    return ValidHandle<typename U::element_type>(*iOtherHandleType.product(), iOtherHandleType.id());
  }
}

#endif