---

Ref.h

Go to the documentation of this file.

#ifndef DataFormats_Common_Ref_h
#define DataFormats_Common_Ref_h

/*----------------------------------------------------------------------
  
Ref: A template for a interproduct reference to a member of a product.

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

----------------------------------------------------------------------*/
/*----------------------------------------------------------------------
//  This defines the public interface to the class Ref<C, T, F>.
//  C                         is the collection type.
//  T (default C::value_type) is the type of an element in the collection.
//
//  ProductID productID       is the product ID of the collection.
//  key_type itemKey          is the key of the element in the collection.
//  C::value_type *itemPtr    is a C++ pointer to the element 
//  Ref<C, T, F> const& ref   is another Ref<C, T, F>

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

    Ref(Handle<C> const& handle, key_type itemKey);
    Ref(ProductID pid, key_type itemKey, EDProductGetter const* prodGetter);

//  Destructor
    virtual ~Ref() {}

    // Operators and methods
    Ref<C, T>& operator=(Ref<C, T> const&);             // assignment (default, not explicitly specified)
    T const& operator*() const;                 // dereference
    T const* const operator->() const;          // member dereference
    bool operator==(Ref<C, T> const& ref) const; // equality
    bool operator!=(Ref<C, T> const& ref) const; // inequality
    bool operator<(Ref<C, 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 "boost/functional.hpp"
#include "boost/call_traits.hpp"
#include "boost/type_traits.hpp"
#include "boost/mpl/has_xxx.hpp"
#include "boost/utility/enable_if.hpp"

#include "DataFormats/Provenance/interface/ProductID.h"
#include "DataFormats/Common/interface/EDProductGetter.h"
#include "DataFormats/Common/interface/EDProductfwd.h"
#include "DataFormats/Common/interface/RefBase.h"
#include "DataFormats/Common/interface/traits.h"
#include "DataFormats/Common/interface/Handle.h"
#include "DataFormats/Common/interface/OrphanHandle.h"
#include "DataFormats/Common/interface/TestHandle.h"

BOOST_MPL_HAS_XXX_TRAIT_DEF(key_compare)

  template <typename C, typename K>
  typename boost::enable_if<has_key_compare<C>, bool>::type
  compare_key(K const& lhs, K const& rhs) {
    typedef typename C::key_compare comparison_functor;
    return comparison_functor()(lhs, rhs);
  }

  template <typename C, typename K>
  typename boost::disable_if<has_key_compare<C>, bool>::type
  compare_key(K const& lhs, K const& rhs) {
    return lhs < rhs;
  }

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

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

  template<typename T>
  class RefToBaseVector;

  template <typename C, 
            typename T = typename refhelper::ValueTrait<C>::value, 
            typename F = typename refhelper::FindTrait<C, T>::value>
  class Ref {
  private:
    typedef refhelper::FindRefVectorUsingAdvance<RefVector<C, T, F> > VF;
    typedef refhelper::FindRefVectorUsingAdvance<RefToBaseVector<T> > VBF;
    friend class RefVectorIterator<C, T, F>;
    friend class RefVector<C, T, F>;
    friend class RefVector<RefVector<C, T, F>, T, VF>;
    friend class RefVector<RefVector<RefVector<C, T, F>, T, VF>, T, VF>;
    friend class RefVector<RefVector<C, T, F>, T, VBF>;
    friend class RefVector<RefVector<RefVector<C, T, F>, T, VBF>, T, VBF>;

  public:
    typedef C product_type;
    typedef T value_type; 
    typedef T const element_type; //used for generic programming
    typedef F finder_type;
    typedef typename boost::binary_traits<F>::second_argument_type argument_type;
    typedef typename boost::remove_cv<typename boost::remove_reference<argument_type>::type>::type key_type;   

    Ref() : ref_() {}

    Ref(Handle<C> const& handle, key_type itemKey, bool setNow=true);

    Ref(OrphanHandle<C> const& handle, key_type itemKey, bool setNow=true);

    //  Note. refvector[index] returns a Ref where index is the index into
    //  the RefVector. This index argument is the index into the COLLECTION,
    //  not the index into the RefVector.
    Ref(RefVector<C, T, F> const& refvector, key_type itemKey, bool setNow=true);

    //  An exception will be thrown if an attempt is made to persistify
    //  any object containing this Ref.  Also, in the future work will
    //  be done to throw an exception if an attempt is made to put any object
    //  containing this Ref into an event(or run or lumi).
    Ref(C const* product, key_type itemKey, bool setNow=true);

    //  An exception will be thrown if an attempt is made to persistify
    //  any object containing this Ref.  Also, in the future work will
    Ref(TestHandle<C> const& handle, key_type itemKey, bool setNow=true);

    Ref(ProductID const& productID, key_type itemKey, EDProductGetter const* prodGetter) :
      ref_(productID, 0, itemKey, 0, mustBeNonZero(prodGetter, "Ref", productID), false) {
    }

    //  It is an error (not diagnosable at compile- or run-time) to call
    //  this constructor with a pointer to a T unless the pointed-to T
    //  object is already in a collection of type C stored in the
    //  Event. The given ProductID must be the id of the collection in
    //  the Event.
    
    Ref(ProductID const& productID, T const* item, key_type item_key, C const* product ) :
      ref_(productID, product, item_key, item, 0, false) { 
    }


    explicit Ref(ProductID const& id) :
      ref_(id, 0, key_traits<key_type>::value, 0, 0, false)
    { }

    Ref(RefProd<C> const& refProd, key_type itemKey);

    ~Ref() {}

    T const&
    operator*() const;

    T const*
    operator->() const;

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

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

    //bool isNonnull() const {return id().isValid(); }
    bool isNonnull() const { return ref_.isNonnull(); }

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

    ProductID id() const {return ref_.refCore().id();}

    EDProductGetter const* productGetter() const {return ref_.refCore().productGetter();}

    // Accessor must get the product if necessary
    C const* product() const;

    key_type key() const {return ref_.item().key();}

    // This one just for backward compatibility.  Will be removed soon.
    key_type index() const {return ref_.item().key();}

    RefBase<key_type> const& ref() const {return ref_;}

    bool hasProductCache() const {return ref_.refCore().productPtr() != 0;}

    bool hasCache() const {return ref_.item().ptr() != 0;}

    bool isAvailable() const {return ref_.refCore().isAvailable();}

    bool isTransient() const {return ref_.refCore().isTransient();}

  private:
    // Constructor from member of RefVector
    Ref(RefCore const& refCore, RefItem<key_type> const& item) : 
      ref_(refCore, item) {
      }

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

    RefBase<key_type> ref_;
  };
}

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

namespace edm {
  template <typename C, typename T, typename F>
  inline
  Ref<C, T, F>::Ref(Handle<C> const& handle, key_type itemKey, bool setNow) :
      ref_(handle.id(), handle.product(), itemKey, 0, 0, false) {
    checkTypeAtCompileTime(handle.product());
    assert(ref_.item().key() == itemKey);
        
    if (setNow) {ref_.item().setPtr(getPtr_<C, T, F>(ref_.refCore(), ref_.item()));}
  }

  template <typename C, typename T, typename F>
  inline
  Ref<C, T, F>::Ref(OrphanHandle<C> const& handle, key_type itemKey, bool setNow) :
      ref_(handle.id(), handle.product(), itemKey, 0, 0, false) {
    checkTypeAtCompileTime(handle.product());
    assert(ref_.item().key() == itemKey);
        
    if (setNow) {ref_.item().setPtr(getPtr_<C, T, F>(ref_.refCore(), ref_.item()));}
  }

  template <typename C, typename T, typename F>
  inline
  Ref<C, T, F>::Ref(RefVector<C, T, F> const& refvector, key_type itemKey, bool setNow) :
      ref_(refvector.id(), refvector.product(), itemKey, 0, 0, refvector.isTransient()) {
    checkTypeAtCompileTime(refvector.product());
    assert(ref_.item().key() == itemKey);
        
    if (setNow) {ref_.item().setPtr(getPtr_<C, T, F>(ref_.refCore(), ref_.item()));}
  }

  //  An exception will be thrown if an attempt is made to persistify
  //  any object containing this Ref.  Also, in the future work will
  //  be done to throw an exception if an attempt is made to put any object
  //  containing this Ref into an event(or run or lumi).
  //  Note:  It is legal for the referenced object to be put into the event
  //  and persistified.  It is this Ref itself that cannot be persistified.
  template <typename C, typename T, typename F>
  inline
  Ref<C, T, F>::Ref(C const* product, key_type itemKey, bool setNow) :
      ref_(ProductID(), product, product != 0 ? itemKey : key_traits<key_type>::value, 0, 0, true) {
    checkTypeAtCompileTime(product);
    assert(ref_.item().key() == (product != 0 ? itemKey : key_traits<key_type>::value));
        
    if (setNow && product != 0) {ref_.item().setPtr(getPtr_<C, T, F>(ref_.refCore(), ref_.item()));}
  }

  //  An exception will be thrown if an attempt is made to persistify any object containing this Ref.
  template <typename C, typename T, typename F>
  inline
  Ref<C, T, F>::Ref(TestHandle<C> const& handle, key_type itemKey, bool setNow) :
      ref_(handle.id(), handle.product(), itemKey, 0, 0, true) {
    checkTypeAtCompileTime(handle.product());
    assert(ref_.item().key() == itemKey);
        
    if (setNow) {ref_.item().setPtr(getPtr_<C, T, F>(ref_.refCore(), ref_.item()));}
  }

  template <typename C, typename T, typename F>
  inline
  Ref<C, T, F>::Ref(RefProd<C> const& refProd, key_type itemKey) :
      ref_(refProd.id(), refProd.refCore().productPtr(), itemKey, 0, refProd.refCore().productGetter(), refProd.refCore().isTransient()) {
    assert(ref_.item().key() == itemKey);
    if (0 != refProd.refCore().productPtr()) {
      ref_.item().setPtr(getPtr_<C, T, F>(ref_.refCore(), ref_.item()));
    }
  }

  // Accessor must get the product if necessary
  template <typename C, typename T, typename F>
  inline
  C const*
  Ref<C, T, F>::product() const {
      return isNull() ? 0 : edm::template getProduct<C>(ref_.refCore());
  }

  template <typename C, typename T, typename F>
  inline
  T const&
  Ref<C, T, F>::operator*() const {
    return *getPtr<C, T, F>(ref_.refCore(), ref_.item());
  }

  template <typename C, typename T, typename F>
  inline
  T const*
  Ref<C, T, F>::operator->() const {
    return getPtr<C, T, F>(ref_.refCore(), ref_.item());
  }

  template <typename C, typename T, typename F>
  inline
  bool
  operator==(Ref<C, T, F> const& lhs, Ref<C, T, F> const& rhs) {
    return lhs.ref() == rhs.ref();
  }

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

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

}

#include "DataFormats/Common/interface/HolderToVectorTrait.h"
#include "DataFormats/Common/interface/Holder.h"
#include "DataFormats/Common/interface/VectorHolder.h"
#include "DataFormats/Common/interface/RefVector.h"

namespace edm {
  namespace reftobase {

    template <typename T, typename REF>
    struct RefHolderToVector {
      static  std::auto_ptr<BaseVectorHolder<T> > makeVectorHolder() {
        typedef RefVector<typename REF::product_type,
                          typename REF::value_type, 
                          typename REF::finder_type> REFV;
        return std::auto_ptr<BaseVectorHolder<T> >( new VectorHolder<T, REFV> );
      }
      static  std::auto_ptr<RefVectorHolderBase> makeVectorBaseHolder() {
        typedef RefVector<typename REF::product_type,
                          typename REF::value_type, 
                          typename REF::finder_type> REFV;
        return std::auto_ptr<RefVectorHolderBase>( new RefVectorHolder<REFV> );
      }
    };

    template<typename T1, typename C, typename T, typename F>
    struct HolderToVectorTrait<T1, Ref<C, T, F> > {
      typedef RefHolderToVector<T1, Ref<C, T, F> > type;
    };

    template <typename REF>
    struct RefRefHolderToRefVector {
      static std::auto_ptr<RefVectorHolderBase> makeVectorHolder() {
        typedef RefVector<typename REF::product_type,
                          typename REF::value_type, 
                                typename REF::finder_type> REFV;
        return std::auto_ptr<RefVectorHolderBase>( new RefVectorHolder<REFV> );
      }
    };

    template<typename C, typename T, typename F>
    struct RefHolderToRefVectorTrait<Ref<C, T, F> > {
      typedef RefRefHolderToRefVector<Ref<C, T, F> > type;
    };

  }
}
  
#endif

---