SmartRefBase.cpp

Go to the documentation of this file.

//  ====================================================================
//  SmartRefBase.cpp
//  --------------------------------------------------------------------
//
//  Package   : Root conversion example
//
//  Author    : Markus Frank
//
//  ====================================================================
#define KERNEL_SMARTREFBASE_CPP 1

// Framework include files
#include "GaudiKernel/SmartRefBase.h"
#include "GaudiKernel/ContainedObject.h"
#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/GaudiException.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/IRegistry.h"
#include "GaudiKernel/LinkManager.h"
#include "GaudiKernel/ObjectContainerBase.h"
#include "GaudiKernel/StreamBuffer.h"

typedef ObjectContainerBase _Container;

void SmartRefBase::set( DataObject* pObj, long hint_id, long link_id )
{
  m_data   = pObj;
  m_hintID = hint_id;
  m_linkID = link_id;
}

const ContainedObject* SmartRefBase::accessData( const ContainedObject* ) const
{
  if ( m_hintID != StreamBuffer::INVALID && m_linkID != StreamBuffer::INVALID ) {
    const _Container* cnt = dynamic_cast<const _Container*>( accessData( m_data ) );
    if ( cnt ) return cnt->containedObject( m_linkID );
  }
  return nullptr;
}

const DataObject* SmartRefBase::accessData( const DataObject* ) const
{
  DataObject* target               = nullptr;
  DataObject* source               = nullptr;
  if ( !m_data && m_contd ) m_data = m_contd->parent();
  source                           = const_cast<DataObject*>( m_data );
  if ( m_hintID != StreamBuffer::INVALID && source ) {
    LinkManager* mgr = source->linkMgr();
    if ( mgr ) {
      LinkManager::Link* link = mgr->link( m_hintID );
      if ( link ) {
        target = link->object();
        if ( !target ) {
          IRegistry* reg = source->registry();
          if ( reg ) {
            IDataProviderSvc* datasvc = reg->dataSvc();
            if ( datasvc && datasvc->retrieveObject( link->path(), target ).isSuccess() ) {
              link->setObject( target );
            }
          }
        }
      }
    }
  }
  return target;
}

// Extended equality check
bool SmartRefBase::isEqualEx( const DataObject* pObj, const SmartRefBase& c ) const
{
  if ( c.m_hintID != StreamBuffer::INVALID && pObj ) {
    DataObject* source = const_cast<DataObject*>( c.m_data );
    if ( source ) {
      LinkManager* mgr = source->linkMgr();
      if ( mgr ) {
        LinkManager::Link* link = mgr->link( c.m_hintID );
        if ( link ) {
          IRegistry* pReg = pObj->registry();
          return pReg && link->path() == pReg->identifier();
        }
      }
    }
  }
  return false;
}

// Extended equality check
bool SmartRefBase::isEqualEx( const ContainedObject* pObj, const SmartRefBase& c ) const
{
  return isEqualEx( pObj->parent(), c ) && pObj->index() == c.m_linkID;
}

const std::string& SmartRefBase::path() const
{
  static std::string s_empty_string{};
  DataObject*        source        = nullptr;
  if ( !m_data && m_contd ) m_data = m_contd->parent();
  source                           = const_cast<DataObject*>( m_data );
  if ( m_hintID != StreamBuffer::INVALID && source ) {
    LinkManager* mgr = source->linkMgr();
    if ( mgr ) {
      LinkManager::Link* link = mgr->link( m_hintID );
      if ( link ) return link->path();
    }
  }
  return s_empty_string;
}