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.

$Id: RefProd.h,v 1.19 2008/05/29 21:13:15 wmtan Exp $

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

/*----------------------------------------------------------------------
//  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/EDProductfwd.h"
#include "DataFormats/Common/interface/EDProductGetter.h"
#include "DataFormats/Common/interface/RefCore.h"
#include "DataFormats/Provenance/interface/ProductID.h"
#include "DataFormats/Common/interface/Handle.h"
#include "DataFormats/Common/interface/OrphanHandle.h"
#include "DataFormats/Common/interface/TestHandle.h"

namespace edm {

  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(), 0, false) {
      checkTypeAtCompileTime(handle.product());
    }

    explicit RefProd(OrphanHandle<C> const& handle) :
    product_(handle.id(), handle.product(), 0, 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* product) :
      product_(ProductID(), product, 0, true) {
      checkTypeAtCompileTime(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).
    explicit RefProd(TestHandle<C> const& handle) :
    product_(handle.id(), handle.product(), 0, true) {
      checkTypeAtCompileTime(handle.product());
    }

    template <typename T, typename F>
    explicit RefProd(Ref<C, T, F> const& ref);

    template <typename T, typename F>
    explicit RefProd(RefVector<C, T, F> const& ref);

    // 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, 0, mustBeNonZero(prodGetter, "RefProd", productID), false) {
    }

    ~RefProd() {}

    product_type const& operator*() const;

    product_type const* operator->() const;

    product_type const* get() const {
      return isNull() ? 0 : 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> &);

  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/Ref.h"
#include "DataFormats/Common/interface/RefCoreGet.h"

namespace edm {
  template<typename C, typename T, typename F>
  class RefVector;

  template <typename C>
  template <typename T, typename F>
  inline
  RefProd<C>::RefProd(Ref<C, T, F> const& ref) :
      product_(ref.id(), ref.hasProductCache() ?  ref.product() : 0, ref.productGetter(), ref.isTransient()) 
  {  }

  template <typename C>
  template <typename T, typename F>
  inline
  RefProd<C>::RefProd(RefVector<C, T, F> const& ref) :
      product_(ref.id(), ref.hasProductCache() ?  ref.product() : 0, ref.productGetter(), ref.isTransient()) 
  {  }

  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) {
    std::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(edm::RefProd<C> const& lhs, edm::RefProd<C> const& rhs ) {
    lhs.swap(rhs);
  }
}

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

namespace edm {
  namespace reftobase {

    template <typename T>
    struct RefProdHolderToVector {
      static  std::auto_ptr<BaseVectorHolder<T> > makeVectorHolder() {
    Exception::throwThis(errors::InvalidReference, "attempting to make a BaseVectorHolder<T> from a RefProd<C>.\n");
    return std::auto_ptr<BaseVectorHolder<T> >();
      }
      static std::auto_ptr<RefVectorHolderBase> makeVectorBaseHolder() {
    Exception::throwThis(errors::InvalidReference, "attempting to make a RefVectorHolderBase from a RefProd<C>.\n");
    return std::auto_ptr<RefVectorHolderBase>();
      }
    };

    template<typename C, typename T>
    struct HolderToVectorTrait<T, RefProd<C> > {
      typedef RefProdHolderToVector<T> type;
    };

    struct RefProdRefHolderToRefVector {
      static  std::auto_ptr<RefVectorHolderBase> makeVectorHolder() {
    Exception::throwThis(errors::InvalidReference, "attempting to make a BaseVectorHolder<T> from a RefProd<C>.\n");
    return std::auto_ptr<RefVectorHolderBase>();
      }
      static  std::auto_ptr<RefVectorHolderBase> makeVectorBaseHolder() {
    Exception::throwThis(errors::InvalidReference, "attempting to make a RefVectorHolderBase from a RefProd<C>.\n");
    return std::auto_ptr<RefVectorHolderBase>();
      }
    };

    template<typename C>
    struct RefHolderToRefVectorTrait<RefProd<C> > {
      typedef RefProdRefHolderToRefVector type;
    };

  }
}

#endif