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

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