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/IDataProviderSvc.h"
#include "GaudiKernel/GaudiException.h"
#include "GaudiKernel/IRegistry.h"
#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/LinkManager.h"
#include "GaudiKernel/StreamBuffer.h"
#include "GaudiKernel/SmartRefBase.h"
#include "GaudiKernel/ContainedObject.h"
#include "GaudiKernel/ObjectContainerBase.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;
}