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) {}
  
    ~FwdRef() {}

    T const&
    operator*() const;

    T const*
    operator->() const;

    T const* get() const {
      if ( ref_.isNonnull() ) {
    return ref_.get();
      } else if ( backRef_.isNonnull() ) {
    return backRef_.get();
      } else {
    return 0;
      }
    }

    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 {
      if ( ref_.productGetter() ) return ref_.productGetter();
      else return backRef_.productGetter();
    }

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

    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_;
  };
}

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

namespace edm {


  // Accessor must get the product if necessary
  template <typename C, typename T, typename F>
  inline
  C const*
  FwdRef<C, T, F>::product() const {
    return ref_.isNonnull() && ref_.isAvailable() ? 
      ref_.product() :
      backRef_.product();
  }

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

}

  
#endif