Ptr.h

Go to the documentation of this file.

#ifndef DataFormats_Common_Ptr_h
#define DataFormats_Common_Ptr_h
// -*- C++ -*-
//
// Package:     Common
// Class  :     Ptr
//
//
// Original Author:  Chris Jones
//         Created:  Thu Oct 18 14:41:33 CEST 2007
//

// user include files
#include "DataFormats/Common/interface/CMS_CLASS_VERSION.h"
#include "DataFormats/Common/interface/WrapperBase.h"
#include "DataFormats/Common/interface/EDProductGetter.h"
#include "DataFormats/Common/interface/FillViewHelperVector.h"
#include "DataFormats/Common/interface/GetProduct.h"
#include "DataFormats/Common/interface/Handle.h"
#include "DataFormats/Common/interface/OrphanHandle.h"
#include "DataFormats/Common/interface/RefCore.h"
#include "DataFormats/Common/interface/TestHandle.h"
#include "DataFormats/Common/interface/traits.h"
#include "DataFormats/Provenance/interface/ProductID.h"

// system include files
#include <type_traits>

// forward declarations
namespace edm {
  template<typename T>
  class Ptr {
     friend class PtrVectorBase;
  public:

    typedef unsigned long key_type;
    typedef T value_type;

    // General purpose constructor from handle.
    template<typename C>
    Ptr(Handle<C> const& handle, key_type itemKey, bool /*setNow*/ = true):
    core_(handle.id(), getItem_(handle.product(), itemKey), nullptr, false), key_(itemKey) {}

    // General purpose constructor from orphan handle.
    template<typename C>
    Ptr(OrphanHandle<C> const& handle, key_type itemKey, bool /*setNow*/ = true):
    core_(handle.id(), getItem_(handle.product(), itemKey), nullptr, false), key_(itemKey) {}

    // General purpose "constructor" from a Ref.
    // Use the conversion function template:
    // ptr = refToPtr(ref)
    // defined in DataFormats/Common/interface/RefToPtr.h
    // to construct a Ptr<T> from a Ref<C>, where T is C::value_type.

    // Constructors for ref to object that is not in an event.
    // An exception will be thrown if an attempt is made to persistify
    // any object containing this Ptr.  Also, in the future work will
    // be done to throw an exception if an attempt is made to put any object
    // containing this Ptr into an event(or run or lumi).

    template<typename C>
    Ptr(C const* iProduct, key_type iItemKey, bool /*setNow*/ = true):
      core_(ProductID(), iProduct != nullptr ? getItem_(iProduct,iItemKey) : nullptr, nullptr, true),
      key_(iProduct != nullptr ? iItemKey : key_traits<key_type>::value) {}

    Ptr(T const* item, key_type iItemKey):
      core_(ProductID(), item, nullptr, true),
      key_(item != nullptr ? iItemKey : key_traits<key_type>::value) {}

    // Constructor from test handle.
    // An exception will be thrown if an attempt is made to persistify
    // any object containing this Ptr.
    template<typename C>
    Ptr(TestHandle<C> const& handle, key_type itemKey, bool /*setNow*/ = true):
    core_(handle.id(), getItem_(handle.product(), itemKey), 0, true), key_(itemKey) {}

    Ptr(ProductID const& productID, key_type itemKey, EDProductGetter const* prodGetter) :
    core_(productID, nullptr, mustBeNonZero(prodGetter, "Ptr", productID), false), key_(itemKey) {
    }

    Ptr(ProductID const& productID, T const* item, key_type item_key) :
    core_(productID, item, nullptr, false),
    key_(item_key) {
    }

    Ptr(ProductID const& productID, T const* item, key_type item_key, bool transient) :
      core_(productID, item, nullptr, transient),
      key_(item_key) {
    }

    explicit Ptr(ProductID const& iId) :
    core_(iId, nullptr, nullptr, false),
    key_(key_traits<key_type>::value)
    { }

    Ptr():
    core_(),
    key_(key_traits<key_type>::value)
    {}

    template<typename U>
    Ptr(Ptr<U> const& iOther, std::enable_if_t<std::is_base_of<T, U>::value> * = nullptr):
    core_(iOther.id(),
          (iOther.hasProductCache() ? static_cast<T const*>(iOther.get()): static_cast<T const*>(nullptr)),
          iOther.productGetter(),
          iOther.isTransient()),
    key_(iOther.key()) {
      //make sure a race condition didn't happen where between the call to hasProductCache() and
      // productGetter() the object was gotten
      if(iOther.hasProductCache() and not hasProductCache()) {
        core_.setProductPtr(static_cast<T const*>(iOther.get()) );
      }
    }

    template<typename U>
    explicit
    Ptr(Ptr<U> const& iOther, std::enable_if_t<std::is_base_of<U, T>::value> * = nullptr):
    core_(iOther.id(),
          dynamic_cast<T const*>(iOther.get()),
          nullptr,
          iOther.isTransient()),
    key_(iOther.key()) {
    }

    ~Ptr() {}

    T const&
    operator*() const;

    T const*
    operator->() const;

    T const* get() const {
      return isNull() ? nullptr : this->operator->();
    }

    bool isNull() const {return !isNonnull(); }

    //bool isNonnull() const {return id().isValid(); }
    bool isNonnull() const {return key_traits<key_type>::value != key_;}
    bool operator!() const {return isNull();}

    bool isAvailable() const;

    bool isTransient() const {return core_.isTransient();}

    ProductID id() const {return core_.id();}

    EDProductGetter const* productGetter() const {return core_.productGetter();}

    key_type key() const {return key_;}

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

    RefCore const& refCore() const {return core_;}
    // ---------- member functions ---------------------------

    void const* product() const {return nullptr;}

    //Used by ROOT storage
    CMS_CLASS_VERSION(10)

  private:

    template<typename C>
    T const* getItem_(C const* product, key_type iKey);

    void getData_(bool throwIfNotFound = true) const {
      EDProductGetter const* getter = productGetter();
      if(getter != nullptr) {
        WrapperBase const* prod = getter->getIt(core_.id());
        unsigned int iKey = key_;
        if(prod == nullptr) {
          prod = getter->getThinnedProduct(core_.id(), iKey);
          if(prod == nullptr) {
            if(throwIfNotFound) {
              core_.productNotFoundException(typeid(T));
            } else {
              return;
            }
          }
        }
        void const* ad = nullptr;
        prod->setPtr(typeid(T), iKey, ad);
        core_.setProductPtr(ad);
      }
    }
    // ---------- member data --------------------------------
    RefCore core_;
    key_type key_;
  };

  template<typename T>
  template<typename C>
  T const* Ptr<T>::getItem_(C const* iProduct, key_type iKey) {
    assert (iProduct != nullptr);
    typename C::const_iterator it = iProduct->begin();
    std::advance(it,iKey);
    T const* address = detail::GetProduct<C>::address(it);
    return address;
  }

  template<typename T>
  inline
  T const&
  Ptr<T>::operator*() const {
    getData_();
    return *reinterpret_cast<T const*>(core_.productPtr());
  }

  template<typename T>
  inline
  T const*
  Ptr<T>::operator->() const {
    getData_();
    return reinterpret_cast<T const*>(core_.productPtr());
  }

  template<typename T>
  inline
  bool
  Ptr<T>::isAvailable() const {
    getData_(false);
    return hasProductCache();
  }

  template<typename T>
  inline
  bool
  operator==(Ptr<T> const& lhs, Ptr<T> const& rhs) {
    return lhs.refCore() == rhs.refCore() && lhs.key() == rhs.key();
  }

  template<typename T>
  inline
  bool
  operator!=(Ptr<T> const& lhs, Ptr<T> const& rhs) {
    return !(lhs == rhs);
  }

  template<typename T>
  inline
  bool
  operator<(Ptr<T> const& lhs, Ptr<T> const& rhs) {
    return (lhs.refCore() == rhs.refCore() ? lhs.key() < rhs.key() : lhs.refCore() < rhs.refCore());
  }
}

//The following is needed to get RefToBase to work with an edm::Ptr
//Handle specialization here
#include "DataFormats/Common/interface/HolderToVectorTrait_Ptr_specialization.h"
#include <vector>

namespace edm {
  template <typename T>
  inline
  void
  fillView(std::vector<edm::Ptr<T> > const& obj,
           ProductID const& id,
           std::vector<void const*>& pointers,
           FillViewHelperVector& helpers) {
    pointers.reserve(obj.size());
    helpers.reserve(obj.size());
    for (auto const& p: obj) {
      if(p.isAvailable()) {
        pointers.push_back(p.get());
      }else {
        pointers.push_back(nullptr);
      }
      helpers.emplace_back(p.id(),p.key());
    }
  }
}

#endif