RefProd.h

Go to the documentation of this file.

#ifndef DataFormats_Common_RefProd_h
#define DataFormats_Common_RefProd_h

/*----------------------------------------------------------------------

Ref: A template for an interproduct reference to a product.

----------------------------------------------------------------------*/

/*----------------------------------------------------------------------
//  This defines the public interface to the class RefProd<T>.
//
//  ProductID productID     is the product ID of the collection. (0 is invalid)
//  RefProd<T> const& ref   is another RefProd<T>

//  Constructors
    RefProd(); // Default constructor
    RefProd(RefProd<T> const& ref); // Copy constructor  (default, not explicitly specified)

    RefProd(Handle<T> const& handle);
    RefProd(ProductID pid, EDProductGetter const* prodGetter);

//  Destructor
    virtual ~RefProd() {}

// Operators and methods
    RefProd<T>& operator=(RefProd<T> const&);   // assignment (default, not explicitly specified)
    T const& operator*() const;         // dereference
    T const* operator->() const;        // member dereference
    bool operator==(RefProd<T> const& ref) const;   // equality
    bool operator!=(RefProd<T> const& ref) const;   // inequality
    bool operator<(RefProd<T> const& ref) const;    // ordering
    bool isNonnull() const;         // true if an object is referenced
    bool isNull() const;            // equivalent to !isNonnull()
    bool operator!() const;         // equivalent to !isNonnull()
----------------------------------------------------------------------*/

#include "DataFormats/Common/interface/CMS_CLASS_VERSION.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/Provenance/interface/ProductID.h"

// Not really needed but things depend on it being here ...
#include "DataFormats/Common/interface/Ref.h"

#include <utility>

namespace edm {

  class EDProductGetter;

  template <typename C>
  class RefProd {
  public:
    typedef C product_type;
    typedef C value_type;

    RefProd() : product_() {}

    explicit RefProd(Handle<C> const& handle) : product_(handle.id(), handle.product(), nullptr, false) {
      checkTypeAtCompileTime(handle.product());
    }

    explicit RefProd(OrphanHandle<C> const& handle) : product_(handle.id(), handle.product(), nullptr, false) {
      checkTypeAtCompileTime(handle.product());
    }

    //  An exception will be thrown if an attempt is made to persistify
    //  any object containing this RefProd.  Also, in the future work will
    //  be done to throw an exception if an attempt is made to put any object
    //  containing this RefProd into an event(or run or lumi).
    RefProd(C const* iProduct) : product_(ProductID(), iProduct, nullptr, true) { checkTypeAtCompileTime(iProduct); }

    //  An exception will be thrown if an attempt is made to persistify
    //  any object containing this RefProd.  Also, in the future work will
    //  be done to throw an exception if an attempt is made to put any object
    //  containing this RefProd into an event(or run or lumi).
    explicit RefProd(TestHandle<C> const& handle) : product_(handle.id(), handle.product(), nullptr, true) {
      checkTypeAtCompileTime(handle.product());
    }

    // Constructor for those users who do not have a product handle,
    // but have a pointer to a product getter (such as the EventPrincipal).
    // prodGetter will ususally be a pointer to the event principal.
    RefProd(ProductID const& productID, EDProductGetter const* prodGetter)
        : product_(productID, nullptr, mustBeNonZero(prodGetter, "RefProd", productID), false) {}

    ~RefProd() {}

    product_type const& operator*() const;

    product_type const* operator->() const;

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

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

    RefCore const& refCore() const { return product_; }

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

    bool isNonnull() const { return product_.isNonnull(); }

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

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

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

    bool hasCache() const { return product_.productPtr() != nullptr; }

    bool hasProductCache() const { return hasCache(); }

    bool isAvailable() const { return product_.isAvailable(); }

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

    void swap(RefProd<C>&);

    //Needed for ROOT storage
    CMS_CLASS_VERSION(10)

  private:
    // Compile time check that the argument is a C* or C const*
    // or derived from it.
    void checkTypeAtCompileTime(C const* /*ptr*/) {}

    RefCore product_;
  };
}  // namespace edm

#include "DataFormats/Common/interface/RefCoreGet.h"

namespace edm {

  template <typename C>
  inline C const& RefProd<C>::operator*() const {
    return *(edm::template getProduct<C>(product_));
  }

  template <typename C>
  inline C const* RefProd<C>::operator->() const {
    return edm::template getProduct<C>(product_);
  }

  template <typename C>
  inline void RefProd<C>::swap(RefProd<C>& other) {
    edm::swap(product_, other.product_);
  }

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

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

  template <typename C>
  inline bool operator<(RefProd<C> const& lhs, RefProd<C> const& rhs) {
    return (lhs.refCore() < rhs.refCore());
  }

  template <typename C>
  inline void swap(RefProd<C> const& lhs, RefProd<C> const& rhs) {
    lhs.swap(rhs);
  }
}  // namespace edm

//Handle specialization here
#include "DataFormats/Common/interface/HolderToVectorTrait_RefProd_specialization.h"

#endif