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());
  }
}  // namespace edm

#endif