SmartRef.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2025 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#pragma once
 
#include <GaudiKernel/ContainedObject.h>
#include <GaudiKernel/SmartRefBase.h>
#include <typeinfo>
#include <utility>
 
template <class TYPE>
class SmartRefArray;
template <class TYPE>
class SmartRefList;
template <class TYPE>
class SmartRefMap;

template <class TYPE>
class SmartRef final {
  friend class SmartRefArray<TYPE>;
  friend class SmartRefList<TYPE>;
  friend class SmartRefMap<TYPE>;
 
  SmartRefBase m_base;
  mutable const TYPE* m_target = nullptr;
 
public:
  enum { VALID = StreamBuffer::VALID, INVALID = StreamBuffer::INVALID };
  typedef TYPE entry_type;

  SmartRef( const TYPE* pObject = nullptr ) {
    m_base.m_hintID = INVALID;
    m_base.m_linkID = INVALID;
    m_target        = pObject;
    _setEnvironment( nullptr, nullptr );
  }

  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, const TYPE* obj = nullptr ) {
    m_base.m_hintID = hint;
    m_base.m_linkID = link;
    m_target        = obj;
    _setEnvironment( nullptr, nullptr );
  }

  SmartRef( const ContainedObject* pObj, long hint, long link, const TYPE* obj = nullptr ) {
    m_base.m_hintID       = hint;
    m_base.m_linkID       = link;
    m_target              = obj;
    const DataObject* src = ( pObj ? pObj->parent() : nullptr );
    _setEnvironment( src, pObj );
  }

  SmartRef( const DataObject* pObj, long hint, long link, const TYPE* obj = nullptr ) {
    m_base.m_hintID = hint;
    m_base.m_linkID = link;
    m_target        = obj;
    _setEnvironment( pObj, nullptr );
  }

  SmartRef( const DataObject* pObj, long hint, const TYPE* obj = nullptr ) {
    m_base.m_hintID = hint;
    m_base.m_linkID = INVALID;
    m_target        = obj;
    _setEnvironment( pObj, nullptr );
  }

  bool shouldFollowLink( const DataObject* ) const { return !m_target && m_base.m_hintID != INVALID; }
  bool shouldFollowLink( const ContainedObject* ) 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 {
    if ( !m_target ) { m_target = dynamic_cast<const TYPE*>( m_base.accessData( m_target ) ); }
    return m_target;
  }

  TYPE* target() {
    if ( !m_target ) { m_target = dynamic_cast<const TYPE*>( m_base.accessData( m_target ) ); }
    return const_cast<TYPE*>( m_target );
  }

  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==( SmartRef<TYPE>& rhs ) { return std::as_const( *this ) == std::as_const( rhs ); }
 
  friend bool operator==( SmartRef<TYPE>& lhs, TYPE* rhs ) { return lhs.target() == rhs; }
  friend bool operator==( const SmartRef<TYPE>& lhs, const TYPE* rhs ) { return lhs.target() == rhs; }

  explicit operator bool() const { return target() != nullptr; }

  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=( const 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 {
    m_base.writeObject( m_target, s );
    return s;
  }

  StreamBuffer& readRef( StreamBuffer& s ) {
    m_target = dynamic_cast<const TYPE*>( m_base.readObject( m_target, s ) );
    return 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 ); }
};