/data/doxygen/doxygen-1.7.3/gen/CMSSW_4_2_8/src/DataFormats/Common/interface/RefBase.h

Go to the documentation of this file.

#ifndef DataFormats_Common_RefBase_h
#define DataFormats_Common_RefBase_h

#error "This header should no longer be included"
/*----------------------------------------------------------------------
  
RefBase: Base class for a single interproduct reference.

$Id: RefBase.h,v 1.12 2011/02/24 20:20:48 wmtan Exp $

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

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

namespace edm {

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

    RefBase() : product_(), index_(key_traits<key_type>::value), cache_(0) {}

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

    RefBase(RefCore const& prod, KEY const& itm) :
      product_(prod), index_(itm),cache_(0) {}


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


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

    bool isValid() const { return index_!=edm::key_traits<key_type>::value; }
    bool isNull() const { return !isValid(); }
    bool isNonnull() const { return isValid(); }

  private:
    RefCore product_;
    key_type index_;
    mutable ConstPtrCache cache_; //Type handles the transient
  };

  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