---

SmartRef.h

Go to the documentation of this file.

//      ====================================================================
//      SmartRef.h
//      --------------------------------------------------------------------
//
//      Package   : Kernel
//
//      Author    : Markus Frank
//
//      ====================================================================
#ifndef KERNEL_SMARTREF_H
#define KERNEL_SMARTREF_H 1

// Include files
#include "GaudiKernel/SmartRefBase.h"

// Forward declarations
template <class TYPE> class SmartRefArray;
template <class TYPE> class SmartRefList;
template <class TYPE> class SmartRefMap;

template <class TYPE> class SmartRef : protected SmartRefBase   {
  friend class SmartRefArray<TYPE>;
  friend class SmartRefList<TYPE>;
  friend class SmartRefMap<TYPE>;

public:
  enum { VALID = StreamBuffer::VALID, INVALID = StreamBuffer::INVALID };
  typedef TYPE   entry_type;
protected:
  mutable const TYPE* m_target;
protected:
public:
  SmartRef()  {
    m_hintID = INVALID; 
    m_linkID = INVALID;
    m_target = 0;
    _setEnvironment(0, 0);
  }
  SmartRef(TYPE* pObject)  {
    m_hintID = INVALID; 
    m_linkID = INVALID;
    m_target = pObject;
    _setEnvironment(0, 0);
  }
  SmartRef(const TYPE* pObject)  {
    m_hintID = INVALID; 
    m_linkID = INVALID;
    m_target = const_cast<TYPE*>(pObject);
    _setEnvironment(0, 0);
  }
  SmartRef(const SmartRef& copy)   {
    m_hintID = copy.m_hintID;
    m_linkID = copy.m_linkID;
    m_target = copy.m_target;
    _setEnvironment(copy.m_data, copy.m_contd);
  }
  SmartRef(long hint, long link, TYPE* obj = 0)   {
    m_hintID = hint;
    m_linkID = link;
    m_target = obj;
    _setEnvironment(0, 0);
  }
  SmartRef(const ContainedObject* pObj, long hint, long link, TYPE* obj = 0)   {
    m_hintID = hint;
    m_linkID = link;
    m_target = obj;
    const DataObject* src = (0==pObj) ? 0 : pObj->parent();
    _setEnvironment(src, pObj);
  }
  SmartRef(const DataObject* pObj, long hint, long link, TYPE* obj = 0)   {
    m_hintID = hint;
    m_linkID = link;
    m_target = obj;
    _setEnvironment(pObj, 0);
  }
  SmartRef(const DataObject* pObj, long hint, TYPE* obj = 0)   {
    m_hintID = hint;
    m_linkID = INVALID;
    m_target = obj;
    _setEnvironment(pObj, 0);
  }
  //virtual ~SmartRef()                  {
  //}
  bool shouldFollowLink(const DataObject* typ)    const   {
    return (0 == m_target && m_hintID != INVALID );
  }
  bool shouldFollowLink(const ContainedObject* typ)    const   {
    return (0 == m_target && m_hintID != INVALID && m_linkID != INVALID );
  }
  long hintID()   const   {
    return m_hintID;
  }
  long linkID()   const   {
    return m_linkID;
  }
  TYPE* data()    {
    return m_target;
  }
  const TYPE* data()  const   {
    return m_target;
  }
  const TYPE* target()  const;
  TYPE* target();
  bool operator==(const SmartRef<TYPE>& c)   const   {
    return SmartRefBase::isEqual(m_target,c) || (m_target== c.m_target && 0 != m_target);
  }
  const SmartRef<TYPE>& _setEnvironment(const DataObject* pObj, const ContainedObject* pContd)  const   {
    m_data  = pObj;
    m_contd = pContd;
    return *this;
  }
  SmartRef<TYPE>& _setEnvironment(const DataObject* pObj, const ContainedObject* pContd)    {
    m_data  = pObj;
    m_contd = pContd;
    return *this;
  }
  SmartRef<TYPE>& operator() (ContainedObject* pObj)    {
    const DataObject* src = (0==pObj) ? 0 : pObj->parent();
    return _setEnvironment(src, pObj);
  }
  const SmartRef<TYPE>& operator() (const ContainedObject* pObj)  const  {
    const DataObject* src = (0==pObj) ? 0 : pObj->parent();
    return _setEnvironment(src, pObj);
  }
  SmartRef<TYPE>& operator() (DataObject* pObj)    {
    return _setEnvironment(pObj,0);
  }
  const SmartRef<TYPE>& operator() (const DataObject* pObj)  const  {
    return _setEnvironment(pObj,0);
  }
  SmartRef<TYPE>& operator=(const SmartRef<TYPE>& c)  {
    m_target = c.m_target;
    m_hintID = c.m_hintID;
    m_linkID = c.m_linkID;
    return _setEnvironment(c.m_data, c.m_contd);
  }
  SmartRef<TYPE>& operator=(TYPE* pObject)   {  m_target = pObject;    return *this;  }
  TYPE& operator*()                 {  return *SmartRef<TYPE>::target(); }
  const TYPE& operator*()   const   {  return *SmartRef<TYPE>::target(); }
  TYPE* operator->()                {  return SmartRef<TYPE>::target();  }
  const TYPE* operator->()  const   {  return SmartRef<TYPE>::target();  }
  operator const TYPE* ()  const    {  return SmartRef<TYPE>::target();  }
  operator TYPE* ()                 {  return SmartRef<TYPE>::target();  }
  StreamBuffer& writeRef(StreamBuffer& s)  const;
  StreamBuffer& readRef(StreamBuffer& s);
  friend StreamBuffer& operator<< (StreamBuffer& s, const SmartRef<TYPE>& ptr)  {
    return ptr.writeRef(s);
  }
  friend StreamBuffer& operator>> (StreamBuffer& s, SmartRef<TYPE>& ptr)    {
    return ptr.readRef(s);
  }
};

//
// Inline function necessary to be outside the class definition.
// Mostly this stuff cannot go into the class definition because
// G++ has problems recognizing proper templates if they are not
// completely defined.
//
// M.Frank
//

template <class TYPE> inline 
TYPE* SmartRef<TYPE>::target()  {
  if ( 0 == m_target )    {
    m_target = dynamic_cast<const TYPE*>(SmartRefBase::accessData(m_target));
  }
  return const_cast<TYPE*>(m_target);
}

template <class TYPE> inline 
const TYPE* SmartRef<TYPE>::target()  const  {
  if ( 0 == m_target )    {
    m_target = dynamic_cast<const TYPE*>(SmartRefBase::accessData(m_target));
  }
  return m_target;
}

template <class TYPE> inline 
StreamBuffer& SmartRef<TYPE>::writeRef (StreamBuffer& s)    const   {
  SmartRefBase::writeObject(m_target, s);
  return s;
}

template <class TYPE> inline 
StreamBuffer& SmartRef<TYPE>::readRef (StreamBuffer& s)   {
  m_target = dynamic_cast<TYPE*>( SmartRefBase::readObject(m_target, s) );
  return s;
}

template <class TYPE> inline
bool operator != (const SmartRef<TYPE>& ref, int)   {
  const TYPE* obj = ref;
  return obj != 0;
}

template <class TYPE> inline 
bool operator != (int, const SmartRef<TYPE>& ref)   {
  const TYPE* obj = ref;
  return obj != 0;
}

#endif // KERNEL_SMARTREF_H

---