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"
#include "GaudiKernel/ContainedObject.h"

#include <typeinfo>

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

template <class TYPE> class SmartRef  {
  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:
  SmartRefBase        m_base;
  mutable const TYPE* m_target = nullptr;
protected:
public:
  SmartRef()  {
    m_base.m_hintID = INVALID; 
    m_base.m_linkID = INVALID;
    _setEnvironment(0, 0);
  }
  SmartRef(TYPE* pObject)  {
    m_base.m_hintID = INVALID; 
    m_base.m_linkID = INVALID;
    m_target = pObject;
    _setEnvironment(0, 0);
  }
  SmartRef(const TYPE* pObject)  {
    m_base.m_hintID = INVALID; 
    m_base.m_linkID = INVALID;
    m_target = const_cast<TYPE*>(pObject);
    _setEnvironment(0, 0);
  }
  SmartRef(const SmartRef& copy)   {
    m_base.m_hintID = copy.m_base.m_hintID;
    m_base.m_linkID = copy.m_base.m_linkID;
    m_target = copy.m_target;
    _setEnvironment(copy.m_base.m_data, copy.m_base.m_contd);
  }
  SmartRef(long hint, long link, TYPE* obj = nullptr)   {
    m_base.m_hintID = hint;
    m_base.m_linkID = link;
    m_target = obj;
    _setEnvironment(0, 0);
  }
  SmartRef(const ContainedObject* pObj, long hint, long link, TYPE* obj = nullptr)   {
    m_base.m_hintID = hint;
    m_base.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 = nullptr)   {
    m_base.m_hintID = hint;
    m_base.m_linkID = link;
    m_target = obj;
    _setEnvironment(pObj, 0);
  }
  SmartRef(const DataObject* pObj, long hint, TYPE* obj = nullptr)   {
    m_base.m_hintID = hint;
    m_base.m_linkID = INVALID;
    m_target = obj;
    _setEnvironment(pObj, 0);
  }
  //virtual ~SmartRef()                  {
  //}
  bool shouldFollowLink(const DataObject* /* typ */) const   {
    return (!m_target && m_base.m_hintID != INVALID );
  }
  bool shouldFollowLink(const ContainedObject* /* typ */) const   {
    return (!m_target && m_base.m_hintID != INVALID && m_base.m_linkID != INVALID );
  }
  long hintID()   const   {
    return m_base.m_hintID;
  }
  long linkID()   const   {
    return m_base.m_linkID;
  }
  void set(DataObject* pObj, long hint_id, long link_id) {
     m_base.set(pObj, hint_id, link_id);
  }
  const std::type_info* type()  const   {
    return &typeid(TYPE);
  }
  TYPE* data()    {
    return const_cast<TYPE*>(m_target);
  }
  const TYPE* data()  const   {
    return m_target;
  }
  const TYPE* target()  const;
  TYPE* target();
  inline const std::string &path() const { return m_base.path(); }
  bool operator==(const SmartRef<TYPE>& c)   const   {
    if (  m_target &&  c.m_target ) return m_target == c.m_target;
    if ( !m_target && !c.m_target ) return m_base.isEqual(m_target,c.m_base);
    if (  m_target && !c.m_target ) return m_base.isEqualEx(m_target, c.m_base);
    if ( !m_target &&  c.m_target ) return c.m_base.isEqualEx(c.m_target, m_base);
    return false;
  }
  bool operator!=(const SmartRef<TYPE>& c)   const   {
    return !(this->operator==(c));
  }
  const SmartRef<TYPE>& _setEnvironment(const DataObject* pObj, const ContainedObject* pContd)  const   {
    m_base.m_data  = pObj;
    m_base.m_contd = pContd;
    m_base.setObjectType(data());
    return *this;
  }
  SmartRef<TYPE>& _setEnvironment(const DataObject* pObj, const ContainedObject* pContd)    {
    m_base.m_data  = pObj;
    m_base.m_contd = pContd;
    m_base.setObjectType(data());
    return *this;
  }
  SmartRef<TYPE>& operator() (ContainedObject* pObj)    {
    const DataObject* src = ( pObj  ? pObj->parent() : nullptr );
    return _setEnvironment(src, pObj);
  }
  const SmartRef<TYPE>& operator() (const ContainedObject* pObj)  const  {
    const DataObject* src = ( pObj ? pObj->parent() : nullptr );
    return _setEnvironment(src, pObj);
  }
  SmartRef<TYPE>& operator() (DataObject* pObj)    {
    return _setEnvironment(pObj,nullptr);
  }
  const SmartRef<TYPE>& operator() (const DataObject* pObj)  const  {
    return _setEnvironment(pObj,nullptr);
  }
  SmartRef<TYPE>& operator=(const SmartRef<TYPE>& c)  {
    m_target = c.m_target;
    m_base.m_hintID = c.m_base.m_hintID;
    m_base.m_linkID = c.m_base.m_linkID;
    return _setEnvironment(c.m_base.m_data, c.m_base.m_contd);  }
  SmartRef<TYPE>& operator=(TYPE* pObject)   {  
    m_target = pObject;    
    m_base.m_hintID = INVALID;
    m_base.m_linkID = INVALID;
    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);
  // MCl: it is "_s" instead of the most common "s" to avoid a fake icc remark #1599
  friend StreamBuffer& operator<< (StreamBuffer& _s, const SmartRef<TYPE>& ptr)  {
    return ptr.writeRef(_s);
  }
  // MCl: it is "_s" instead of the most common "s" to avoid a fake icc remark #1599
  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 ( !m_target )    {
    m_target = dynamic_cast<const TYPE*>(m_base.accessData(m_target));
  }
  return const_cast<TYPE*>(m_target);
}

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

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

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

template <class TYPE> inline
bool operator == (const SmartRef<TYPE>& ref, int)   {
  return ref.target() == nullptr;
}

template <class TYPE> inline 
bool operator == (int, const SmartRef<TYPE>& ref)   {
  return ref.target() == nullptr;
}

template <class TYPE> inline
bool operator != (const SmartRef<TYPE>& ref, int)   {
  return ref.target() != nullptr;
}

template <class TYPE> inline 
bool operator != (int, const SmartRef<TYPE>& ref)   {
  return ref.target() != nullptr;
}

#endif // KERNEL_SMARTREF_H