---

SmartDataObjectPtr.h

Go to the documentation of this file.

//      ====================================================================
//      SmartDataObjectPtr.h
//      --------------------------------------------------------------------
//
//      Package    : Gaudi/DataSvc ( The LHCb Offline System)
//
//  Description: Implementation of the "worker" part of the 
//               smart pointer classes used to access
//               easily (and efficiently) data stores.
//
//      Author     : M.Frank
//      ====================================================================
#ifndef DATASVC_SMARTDATAOBJECTPTR_H
#define DATASVC_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 IDataDirectory;
class DataObject;

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

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

protected:

  mutable IDataProviderSvc* m_dataProvider;
  mutable IDataDirectory*   m_pDirectory;
  mutable DataObject*       m_pObject;
  std::string       m_path;
  StatusCode        m_status;
  AccessFunction    m_accessFunc;

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

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

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

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

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

  operator IDataDirectory*()    {
    return m_pDirectory;
  }

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

  IDataDirectory* directory()    {
    return m_pDirectory;
  }

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

  IDataProviderSvc* service()    {
    return m_dataProvider;
  }

  operator int()   {
    return 0 != accessData();
  }

  bool operator !()   {
    return 0 == accessData();
  }

  operator void*()   {
    accessData();
    return m_pObject;
  }

  operator DataObject*&()   {
    return m_pObject;
  }

  operator DataObject**()   {
    return &m_pObject;
  }

  StatusCode getLastError()   const   {
    return m_status;
  }

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

  static DataObject* retrieve(SmartDataObjectPtr* ptr)   {
    return (ptr->m_pObject == 0) ? ptr->retrieveObject() : ptr->m_pObject;
  }

  static DataObject* find(SmartDataObjectPtr* ptr)   {
    return (ptr->m_pObject == 0) ? ptr->findObject() : ptr->m_pObject;
  }

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

  DataObject* retrieveObject();

  DataObject* findObject();

  DataObject* updateObject();
};

bool operator&& (SmartDataObjectPtr& object_1, SmartDataObjectPtr& object_2);

bool operator|| (SmartDataObjectPtr& object_1, SmartDataObjectPtr& object_2);

#endif // DATASVC_SmartDataObjectPtr_H

---