---

RefBase.h

Go to the documentation of this file.

#ifndef DataFormats_Common_RefBase_h
#define DataFormats_Common_RefBase_h

/*----------------------------------------------------------------------
  
RefBase: Base class for a single interproduct reference.

$Id: RefBase.h,v 1.11 2008/02/15 05:57:03 wmtan Exp $

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

#include "DataFormats/Common/interface/EDProductfwd.h"
#include "DataFormats/Common/interface/RefCore.h"

namespace edm {

  template<typename KEY>
  class RefBase {
  public:
    typedef KEY key_type;

    RefBase() : product_(), item_() {}

    RefBase(ProductID const& productID, void const* prodPtr, key_type itemKey,
            void const* itemPtr, EDProductGetter const* prodGetter, bool transient):
      product_(productID, prodPtr, prodGetter, transient), item_(itemKey, itemPtr) {}

    RefBase(RefCore const& prod, RefItem<KEY> const& itm) :
      product_(prod), item_(itm) {}


    RefCore const& refCore() const { return product_;}

    RefItem<KEY> const& item() const {return item_;}

    // /// Return the index for the referenced element.
    // key_type key() const { return item_.key(); }
    

    bool isValid() const { return item_.isValid(); }
    bool isNull() const { return item_.isNull(); }
    bool isNonnull() const { return item_.isNonnull(); }

  private:
    RefCore product_;
    RefItem<KEY> item_;
  };

  template <typename KEY>
  bool
  operator==(RefBase<KEY> const& lhs, RefBase<KEY> const& rhs) {
    return lhs.refCore() == rhs.refCore() && lhs.item() == rhs.item();
  }
  
  template <typename KEY>
  bool
  operator!=(RefBase<KEY> const& lhs, RefBase<KEY> const& rhs) {
    return !(lhs == rhs);
  }

  template <typename KEY>
  bool
  operator<(RefBase<KEY> const& lhs, RefBase<KEY> const& rhs) {
    return (lhs.refCore() == rhs.refCore() ?  lhs.item() < rhs.item() : lhs.refCore() < rhs.refCore());
  }
}
  
#endif

---