SmartDataObjectPtr.h

Go to the documentation of this file.

// $Header: /tmp/svngaudi/tmp.jEpFh25751/Gaudi/GaudiKernel/GaudiKernel/SmartDataObjectPtr.h,v 1.7 2007/11/21 09:29:31 marcocle Exp $
#ifndef GAUDIKERNEL_SMARTDATAOBJECTPTR_H
#define GAUDIKERNEL_SMARTDATAOBJECTPTR_H 1

// STL include files
#include <string>

// Framework include files
#include "GaudiKernel/Kernel.h"
#include "GaudiKernel/StatusCode.h"

// Forward declarations
class SmartDataObjectPtr;
class IDataProviderSvc;
class IRegistry;
class DataObject;

class GAUDI_API SmartDataObjectPtr {
public:
  typedef DataObject* (* AccessFunction) (SmartDataObjectPtr* ptr);
  class ObjectLoader    {
  public:
    static AccessFunction access();
  };

  class ObjectFinder    {
  public:
    static AccessFunction access();
  };

public:
  SmartDataObjectPtr(AccessFunction access, IDataProviderSvc* pService, IRegistry* pDir, const std::string& path)
    : m_dataProvider(pService),
      m_pRegistry(pDir),
      m_status(StatusCode::SUCCESS,true),
      m_path(path),
      m_accessFunc(access)
  {
  }
  SmartDataObjectPtr(const SmartDataObjectPtr& copy)
    : m_dataProvider(copy.m_dataProvider),
      m_pRegistry(copy.m_pRegistry),
      m_status(copy.m_status),
      m_path(copy.m_path),
      m_accessFunc(copy.m_accessFunc)
  {
  }
  virtual ~SmartDataObjectPtr()  {
  }
  virtual SmartDataObjectPtr& operator=(const SmartDataObjectPtr& copy);

  operator IRegistry*()    {
    return m_pRegistry;
  }

  const std::string& path()   const   {
    return m_path;
  }

  IRegistry* directory()    {
    return m_pRegistry;
  }

  void setService( IDataProviderSvc* svc )    {
    m_dataProvider = svc;
  }

  IDataProviderSvc* service()    {
    return m_dataProvider;
  }

  StatusCode getLastError()   const   {
    return m_status;
  }

  DataObject* accessData()    {
    return m_accessFunc(this);
  }

  static DataObject* retrieve(SmartDataObjectPtr* ptr)   {
    return ptr->retrieveObject();
  }

  static DataObject* find(SmartDataObjectPtr* ptr)   {
    return ptr->findObject();
  }

  static DataObject* update(SmartDataObjectPtr* ptr)   {
    return ptr->updateObject();
  }

  DataObject* retrieveObject();

  DataObject* findObject();

  DataObject* updateObject();

protected:

  StatusCode find(IRegistry* pDirectory, const std::string& path, DataObject*& refpObject);

  StatusCode find(const std::string& fullPath, DataObject*& refpObject);

  StatusCode retrieve(IRegistry* pDirectory, const std::string& path, DataObject*& refpObject);
  StatusCode retrieve(const std::string& fullPath, DataObject*& refpObject);

  StatusCode update(IRegistry* pDirectory);
  StatusCode update(const std::string& fullPath);

protected:
  mutable IDataProviderSvc* m_dataProvider;
  mutable IRegistry*        m_pRegistry;
  mutable StatusCode        m_status;
  std::string               m_path;
  AccessFunction            m_accessFunc;

};
#endif // GAUDIKERNEL_SMARTDATAOBJECTPTR_H