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, 0, 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(), 0, 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() ? 0 : 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_;
  };
}

#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);
  }
}

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

#endif