FwdRef.h

Go to the documentation of this file.

#ifndef DataFormats_Common_FwdRef_h
#define DataFormats_Common_FwdRef_h
 
/*----------------------------------------------------------------------
  
FwdRef: A template for a interproduct reference to a member of a product.
 
----------------------------------------------------------------------*/
/*----------------------------------------------------------------------
//  This defines the public interface to the class FwdRef<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 
//  FwdRef<C, T, F> const& ref   is another FwdRef<C, T, F>
 
//  Constructors
    FwdRef(); // Default constructor
    FwdRef(FwdRef<C, T> const& ref);    // Copy constructor  (default, not explicitly specified)
 
    FwdRef(Ref<C,T,F> const & fwdRef, Ref<C,T,F> const & backRef);
 
//  Destructor
    virtual ~FwdRef() {}
 
    // Operators and methods
    FwdRef<C, T>& operator=(FwdRef<C, T> const&);       // assignment (default, not explicitly specified)
    T const& operator*() const;         // dereference
    T const* const operator->() const;      // member dereference
    bool operator==(FwdRef<C, T> const& ref) const; // equality
    bool operator!=(FwdRef<C, T> const& ref) const; // inequality
    bool operator<(FwdRef<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 "DataFormats/Common/interface/CMS_CLASS_VERSION.h"
#include "DataFormats/Common/interface/Ref.h"
 
namespace edm {
 
  template <typename C,
            typename T = typename refhelper::ValueTrait<C>::value,
            typename F = typename refhelper::FindTrait<C, T>::value>
  class FwdRef {
  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;
 
    FwdRef() : ref_(), backRef_() {}
 
    FwdRef(Ref<C, T, F> const& ref, Ref<C, T, F> const& backRef) : ref_(ref), backRef_(backRef) {
      assert(ref.isNull() == backRef.isNull());
    }
 
    ~FwdRef() {}
 
    T const& operator*() const;
 
    T const* operator->() const;
 
    T const* get() const {
      if (ref_.isAvailable()) {
        return ref_.get();
      } else {
        return backRef_.get();
      }
    }
 
    bool isNull() const { return !isNonnull(); }
 
    //bool isNonnull() const {return id().isValid(); }
    bool isNonnull() const { return ref_.isNonnull() || backRef_.isNonnull(); }
 
    bool operator!() const { return isNull(); }
 
    Ref<C, T, F> const& ref() const { return ref_; }
    Ref<C, T, F> const& backRef() const { return backRef_; }
 
    EDProductGetter const* productGetter() const {
      //another thread might cause productGetter() to change its value
      EDProductGetter const* getter = ref_.productGetter();
      if (getter)
        return getter;
      else
        return backRef_.productGetter();
    }
 
    ProductID id() const { return ref_.isNonnull() ? ref_.id() : backRef_.id(); }
 
    key_type key() const { return ref_.isNonnull() ? ref_.key() : backRef_.key(); }
 
    bool hasProductCache() const { return ref_.hasProductCache() || backRef_.hasProductCache(); }
 
    bool isAvailable() const { return ref_.isAvailable() || backRef_.isAvailable(); }
 
    bool isTransient() const { return ref_.isTransient(); }
 
    //Used by ROOT storage
    CMS_CLASS_VERSION(10)
 
  private:
    Ref<C, T, F> ref_;
    Ref<C, T, F> backRef_;
  };
}  // namespace edm
 
#include "DataFormats/Common/interface/RefProd.h"
 
namespace edm {
 
  template <typename C, typename T, typename F>
  inline T const& FwdRef<C, T, F>::operator*() const {
    return ref_.isNonnull() && ref_.isAvailable() ? ref_.operator*() : backRef_.operator*();
  }
 
  template <typename C, typename T, typename F>
  inline T const* FwdRef<C, T, F>::operator->() const {
    return ref_.isNonnull() && ref_.isAvailable() ? ref_.operator->() : backRef_.operator->();
  }
 
  template <typename C, typename T, typename F>
  inline bool operator==(FwdRef<C, T, F> const& lhs, FwdRef<C, T, F> const& rhs) {
    return (lhs.ref() == rhs.ref()) && (lhs.backRef() == rhs.backRef());
  }
 
  template <typename C, typename T, typename F>
  inline bool operator==(Ref<C, T, F> const& lhs, FwdRef<C, T, F> const& rhs) {
    return (lhs == rhs.ref()) || (lhs == rhs.backRef());
  }
 
  template <typename C, typename T, typename F>
  inline bool operator==(FwdRef<C, T, F> const& lhs, Ref<C, T, F> const& rhs) {
    return (lhs.ref() == rhs) || (lhs.backRef() == rhs);
  }
 
  template <typename C, typename T, typename F>
  inline bool operator!=(FwdRef<C, T, F> const& lhs, FwdRef<C, T, F> const& rhs) {
    return !(lhs == rhs);
  }
 
  template <typename C, typename T, typename F>
  inline bool operator!=(Ref<C, T, F> const& lhs, FwdRef<C, T, F> const& rhs) {
    return !(lhs == rhs);
  }
 
  template <typename C, typename T, typename F>
  inline bool operator!=(FwdRef<C, T, F> const& lhs, Ref<C, T, F> const& rhs) {
    return !(lhs == rhs);
  }
 
  template <typename C, typename T, typename F>
  inline bool operator<(FwdRef<C, T, F> const& lhs, FwdRef<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, FwdRef<C, T, F> const& rhs) {
    return (lhs < rhs.ref());
  }
 
  template <typename C, typename T, typename F>
  inline bool operator<(FwdRef<C, T, F> const& lhs, Ref<C, T, F> const& rhs) {
    return (lhs.ref() < rhs);
  }
 
}  // namespace edm
 
#endif