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() != 0; }
 
    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