art::Ptr< T > Class Template Reference

#include <fwd.h>

Public Types
using	key_type = std::size_t
using	value_type = T
using	const_pointer = T const *
using	const_reference = T const &

Public Member Functions
	Ptr ()=default
template<typename H >
	Ptr (H const &handle, typename Ptr< T >::key_type key)
	Ptr (ProductID const &productID)
	Ptr (ProductID const &productID, key_type itemKey, EDProductGetter const *prodGetter)
template<typename U >
	Ptr (Ptr< U > const &pu, std::enable_if_t< std::is_base_of_v< T, U >> *=nullptr)
template<typename U >
	Ptr (Ptr< U > const &pu, std::enable_if_t< std::is_base_of_v< U, T >> *=nullptr)
	Ptr (ProductID const &productID, T const *item, key_type const itemKey)
T const &	operator* () const
T const *	get () const
T const *	operator-> () const
bool	isNonnull () const noexcept
bool	isNull () const noexcept
	operator bool () const
RefCore const &	refCore () const noexcept
ProductID	id () const noexcept
EDProductGetter const *	productGetter () const noexcept
bool	isAvailable () const
bool	hasCache () const noexcept
key_type	key () const noexcept

Static Public Member Functions
static constexpr short	Class_Version () noexcept

Private Member Functions
EDProduct const *	parentProduct_ () const

Private Attributes
RefCore	core_ {}
key_type	key_ {key_traits<key_type>::value}

Detailed Description

template<typename T>
class art::Ptr< T >

Definition at line 31 of file fwd.h.

Member Typedef Documentation

template<typename T>

using art::Ptr< T >::const_pointer = T const*

Definition at line 81 of file Ptr.h.

template<typename T>

using art::Ptr< T >::const_reference = T const&

Definition at line 82 of file Ptr.h.

template<typename T>

using art::Ptr< T >::key_type = std::size_t

Definition at line 79 of file Ptr.h.

template<typename T>

using art::Ptr< T >::value_type = T

Definition at line 80 of file Ptr.h.

Constructor & Destructor Documentation

template<typename T>

art::Ptr< T >::Ptr ( )

default

template<typename T>

template<typename H >

art::Ptr< T >::Ptr ( H const &  handle, typename Ptr< T >::key_type  key  )

inline

Definition at line 88 of file Ptr.h.

      : core_{handle.id(),
              detail::ItemGetter<T,
                                 std::remove_const_t<std::remove_pointer_t<
                                   decltype(handle.product())>>>()(
                handle.product(),
                key),
              nullptr}
      , key_{key}
    {
      if (core_.isNull()) {
        throw Exception(errors::InvalidReference)
          << "Attempt to construct a Ptr from a Handle with invalid ProductID. "
             "Perhaps a\n"
             "default-constructed Ptr is what you want?";
      }
    }

template<typename T>

art::Ptr< T >::Ptr ( ProductID const &  productID )

inlineexplicit

Definition at line 107 of file Ptr.h.

      : core_{productID, nullptr, nullptr}
    {}

template<typename T>

art::Ptr< T >::Ptr ( ProductID const &  productID, key_type  itemKey, EDProductGetter const *  prodGetter  )

inline

Definition at line 112 of file Ptr.h.

      : core_{productID, nullptr, prodGetter}, key_{itemKey}
    {}

template<typename T>

template<typename U >

art::Ptr< T >::Ptr ( Ptr< U > const &  pu, std::enable_if_t< std::is_base_of_v< T, U >> *  = nullptr  )

inline

Definition at line 120 of file Ptr.h.

      : core_{pu.id(),
              (pu.hasCache() ? static_cast<T const*>(pu.get()) : nullptr),
              pu.productGetter()}
      , key_{pu.key()}
    {}

template<typename T>

template<typename U >

art::Ptr< T >::Ptr ( Ptr< U > const &  pu, std::enable_if_t< std::is_base_of_v< U, T >> *  = nullptr  )

inline

Definition at line 128 of file Ptr.h.

      : core_{pu.id(), static_cast<T const*>(pu.get()), nullptr}, key_{pu.key()}
    {}

template<typename T>

art::Ptr< T >::Ptr ( ProductID const &  productID, T const *  item, key_type const  itemKey  )

inline

Definition at line 133 of file Ptr.h.

      : core_{productID, item, nullptr}, key_{itemKey}
    {}

Member Function Documentation

template<typename T>

static constexpr short art::Ptr< T >::Class_Version ( )

inlinestaticnoexcept

Definition at line 223 of file Ptr.h.

    {
      return 10;
    }

template<typename T>

T const* art::Ptr< T >::get ( ) const

inline

Definition at line 149 of file Ptr.h.

    {
      return isNull() ? nullptr : operator->();
    }

template<typename T>

bool art::Ptr< T >::hasCache ( ) const

inlinenoexcept

Definition at line 210 of file Ptr.h.

    {
      return core_.productPtr() != nullptr;
    }

template<typename T>

ProductID art::Ptr< T >::id ( ) const

inlinenoexcept

Definition at line 190 of file Ptr.h.

    {
      return core_.id();
    }

template<typename T>

bool art::Ptr< T >::isAvailable ( ) const

inline

Definition at line 204 of file Ptr.h.

    {
      return core_.isAvailable();
    }

template<typename T>

bool art::Ptr< T >::isNonnull ( ) const

inlinenoexcept

Definition at line 166 of file Ptr.h.

    {
      return key_ != key_traits<key_type>::value;
    }

template<typename T>

bool art::Ptr< T >::isNull ( ) const

inlinenoexcept

Definition at line 173 of file Ptr.h.

    {
      return !isNonnull();
    }

template<typename T>

key_type art::Ptr< T >::key ( ) const

inlinenoexcept

Definition at line 216 of file Ptr.h.

    {
      return key_;
    }

template<typename T>

art::Ptr< T >::operator bool ( ) const

inlineexplicit

Definition at line 178 of file Ptr.h.

    {
      return (key_ != key_traits<key_type>::value) && core_.isAvailable();
    }

template<typename T>

T const& art::Ptr< T >::operator* ( ) const

inline

Definition at line 141 of file Ptr.h.

    {
      // FIXME: This causes an nullptr dereference if isNull!
      // return isNull() ? nullptr : operator->();
      return *get();
    }

template<typename T>

T const* art::Ptr< T >::operator-> ( ) const

inline

Definition at line 154 of file Ptr.h.

    {
      if (core_.productPtr() == nullptr) {
        EDProduct const* prod = parentProduct_();
        void const* ad = prod->getElementAddress(typeid(T), key_);
        core_.setProductPtr(ad);
      }
      return reinterpret_cast<T const*>(core_.productPtr());
    }

template<typename T>

EDProduct const* art::Ptr< T >::parentProduct_ ( ) const

inlineprivate

Definition at line 230 of file Ptr.h.

    {
      EDProduct const* product{nullptr};
      if (productGetter()) {
        product = productGetter()->getIt();
      }
      if (product == nullptr) {
        Exception e(errors::ProductNotFound);
        e << "A request to resolve an Ptr to a product containing items of "
             "type: "
          << cet::demangle_symbol(typeid(T).name()) << " with ProductID "
          << core_.id()
          << "\ncannot be satisfied because the product cannot be found.\n";
        if (productGetter() == nullptr) {
          e << "The productGetter was not set -- are you trying to "
               "dereference a Ptr during mixing?\n";
        } else {
          e << "Probably the branch containing the product is not stored in "
               "the input file.\n";
        }
        throw e;
      }
      return product;
    }

template<typename T>

EDProductGetter const* art::Ptr< T >::productGetter ( ) const

inlinenoexcept

Definition at line 196 of file Ptr.h.

    {
      return core_.productGetter();
    }

template<typename T>

RefCore const& art::Ptr< T >::refCore ( ) const

inlinenoexcept

Definition at line 184 of file Ptr.h.

    {
      return core_;
    }

Member Data Documentation

template<typename T>

RefCore art::Ptr< T >::core_ {}

private

Definition at line 256 of file Ptr.h.

template<typename T>

key_type art::Ptr< T >::key_ {key_traits<key_type>::value}

private

Definition at line 259 of file Ptr.h.

---

The documentation for this class was generated from the following files:

• canvas/canvas/Persistency/Common/fwd.h
• canvas/canvas/Persistency/Common/Ptr.h