SmartDataObjectPtr.h

Go to the documentation of this file.

#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:
  using AccessFunction = DataObject*(*)(SmartDataObjectPtr* ptr);
  class ObjectLoader    {
  public:
    static AccessFunction access();
  };

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

public:
  SmartDataObjectPtr(AccessFunction access, IDataProviderSvc* pService, IRegistry* pDir, std::string path)
    : m_dataProvider(pService),
      m_pRegistry(pDir),
      m_path(std::move(path)),
      m_accessFunc(access)
  {
  }
  SmartDataObjectPtr(const SmartDataObjectPtr&) = default;

  virtual ~SmartDataObjectPtr()  = default;

  virtual SmartDataObjectPtr& operator=(const SmartDataObjectPtr&);

  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;
  }

  const 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 = nullptr;
  mutable IRegistry*        m_pRegistry = nullptr;
  mutable StatusCode        m_status = { StatusCode::SUCCESS, true } ;
  std::string               m_path;
  AccessFunction            m_accessFunc;

};
#endif // GAUDIKERNEL_SMARTDATAOBJECTPTR_H