DataSvc.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_DATASVC_H
#define GAUDIKERNEL_DATASVC_H

// Include files
#include "GaudiKernel/Service.h"
#include "GaudiKernel/DataStoreItem.h"
#include "GaudiKernel/IDataManagerSvc.h"
#include "GaudiKernel/IDataProviderSvc.h"

// Forward declarations
// Incident service
class IIncidentSvc;
// Generic address
class IOpaqueAddress;
// Generic interface to data object class
class DataObject;
// Data store agent
class IDataStoreAgent;

// Do not clutter global namespace for helpers...
namespace DataSvcHelpers    {
  // Map of objects where loading is inhibited
  class InhibitMap;
  // Generic registry entry
  class RegistryEntry;
}


class GAUDI_API DataSvc: public extends2<Service, IDataProviderSvc, IDataManagerSvc>
{
public:
  typedef std::vector<DataStoreItem> LoadItems;

protected:
  CLID                            m_rootCLID;
  std::string                     m_rootName;
  IConversionSvc*                 m_dataLoader;
  IIncidentSvc*                   m_incidentSvc;
  LoadItems                       m_preLoads;
  bool                            m_forceLeaves;
  bool                            m_enableAccessHdlr;
  bool                            m_enableFaultHdlr;
  DataSvcHelpers::RegistryEntry*  m_root;
  DataSvcHelpers::InhibitMap*     m_inhibitMap;
  std::vector<std::string>        m_inhibitPathes;
  std::string                     m_accessName;
  std::string                     m_faultName;
public:

  virtual CLID rootCLID() const;

  virtual std::string rootName() const;

  virtual StatusCode registerAddress( const std::string& fullPath,
                                      IOpaqueAddress* pAddress);

  virtual StatusCode registerAddress( DataObject* parentObj,
                                      const std::string& objectPath,
                                      IOpaqueAddress* pAddress);

  virtual StatusCode registerAddress( IRegistry* parentObj,
                                      const std::string& objectPath,
                                      IOpaqueAddress* pAddress);

  virtual StatusCode unregisterAddress(const std::string& fullPath);

  virtual StatusCode unregisterAddress( DataObject* pParent,
                                        const std::string& objPath);

  virtual StatusCode unregisterAddress( IRegistry* pParent,
                                        const std::string& objPath);

  virtual StatusCode objectLeaves( const DataObject*  pObject,
                                  std::vector<IRegistry*>& refLeaves);
  virtual StatusCode objectLeaves( const IRegistry*   pRegistry,
                                  std::vector<IRegistry*>& refLeaves);

  virtual StatusCode objectParent( const DataObject*  pObject,
                                   IRegistry*& refpParent);
  virtual StatusCode objectParent( const IRegistry*   pRegistry,
                                   IRegistry*& refpParent);

  virtual StatusCode clearSubTree( const std::string& sub_tree_path );

  virtual StatusCode clearSubTree( DataObject* pObject );

  virtual StatusCode clearStore();

  virtual StatusCode traverseSubTree( const std::string& sub_tree_path,
                                      IDataStoreAgent* pAgent );

  virtual StatusCode traverseSubTree( DataObject* pObject,
                                      IDataStoreAgent* pAgent );

  virtual StatusCode traverseTree( IDataStoreAgent* pAgent );

  virtual StatusCode setRoot( const std::string& root_name,
                              DataObject* pRootObj);

  virtual StatusCode i_setRoot( const std::string& root_name,
                                DataObject* pRootObj);

  virtual StatusCode setRoot (const std::string& root_path,
                              IOpaqueAddress* pRootAddr);

  virtual StatusCode i_setRoot (const std::string& root_path,
                                IOpaqueAddress* pRootAddr);

  virtual StatusCode setDataLoader( IConversionSvc* svc );

  virtual StatusCode addPreLoadItem( const DataStoreItem& item );

  virtual StatusCode addPreLoadItem( const std::string& itemPath );

  virtual StatusCode removePreLoadItem( const DataStoreItem& item );

  virtual StatusCode removePreLoadItem( const std::string& itemPath );

  virtual StatusCode resetPreLoad();

  virtual StatusCode preLoad( int depth,
                              int load_depth,
                              DataObject* pObject );

  virtual StatusCode preLoad();

  virtual StatusCode registerObject(  const std::string& fullPath,
                                      DataObject* pObject );

  virtual StatusCode registerObject(  const std::string& parentPath,
                                      const std::string& objPath,
                                      DataObject* pObject );

  virtual StatusCode registerObject(  const std::string& parentPath,
                                      int item,
                                      DataObject* pObject );

  virtual StatusCode registerObject(  DataObject* parentObj,
                                      const std::string& objPath,
                                      DataObject* pObject );

  virtual StatusCode registerObject(  DataObject* parentObj,
                                      int item,
                                      DataObject* pObject );

  virtual StatusCode unregisterObject(const std::string& fullPath );

  virtual StatusCode unregisterObject(const std::string& parentPath,
                                      const std::string& objectPath );

  virtual StatusCode unregisterObject(const std::string& parentPath,
                                      int item );

  virtual StatusCode unregisterObject(DataObject* pObject );

  virtual StatusCode unregisterObject(DataObject* pObject,
                                      const std::string& objectPath );

  virtual StatusCode unregisterObject(DataObject* pObject,
                                      int item );

  virtual StatusCode retrieveObject(  IRegistry* pDirectory,
                                      const std::string& path,
                                      DataObject*& pObject );

  virtual StatusCode retrieveObject(  const std::string& fullPath,
                                      DataObject*& pObject );

  virtual StatusCode retrieveObject(  const std::string& parentPath,
                                      const std::string& objPath,
                                      DataObject*& pObject );

  virtual StatusCode retrieveObject(  const std::string& parentPath,
                                      int item,
                                      DataObject*& pObject );

  virtual StatusCode retrieveObject(  DataObject* parentObj,
                                      const std::string& objPath,
                                      DataObject*& pObject );

  virtual StatusCode retrieveObject(  DataObject* parentObj,
                                      int item,
                                      DataObject*& pObject );

  virtual StatusCode findObject(  const std::string& fullPath,
                                  DataObject*& pObject );

  virtual StatusCode findObject(  IRegistry* pDirectory,
                                  const std::string& path,
                                  DataObject*& pObject );

  virtual StatusCode findObject(  const std::string& parentPath,
                                  const std::string& objPath,
                                  DataObject*& pObject );

  virtual StatusCode findObject(  const std::string& parentPath,
                                  int item,
                                  DataObject*& pObject );

  virtual StatusCode findObject(  DataObject* parentObj,
                                  const std::string& objPath,
                                  DataObject*& pObject );

  virtual StatusCode findObject(  DataObject* parentObj,
                                  int item,
                                  DataObject*& pObject );

  virtual StatusCode linkObject(  IRegistry* from,
                                  const std::string& objPath,
                                  DataObject* to );

  virtual StatusCode linkObject(  const std::string& fromPath,
                                  const std::string& objPath,
                                  DataObject* to );

  virtual StatusCode linkObject(  DataObject* from,
                                  const std::string& objPath,
                                  DataObject* to );

  virtual StatusCode linkObject(  const std::string& fullPath,
                                  DataObject* to );

  virtual StatusCode unlinkObject(IRegistry* from,
                                  const std::string& objPath );

  virtual StatusCode unlinkObject(const std::string& fromPath,
                                  const std::string& objPath );

  virtual StatusCode unlinkObject(DataObject* fromObj,
                                  const std::string& objPath );

  virtual StatusCode unlinkObject(const std::string& fullPath );

  virtual StatusCode updateObject(IRegistry* pDirectory );

  virtual StatusCode updateObject(const std::string& updatePath );

  virtual StatusCode updateObject(DataObject* toUpdate );

  virtual StatusCode updateObject(const std::string& parentPath,
                                  const std::string& updatePath );

  virtual StatusCode updateObject(DataObject* pParent,
                                  const std::string& updatePath );

  virtual StatusCode initialize();

  virtual StatusCode reinitialize();

  virtual StatusCode finalize();

  DataSvc( const std::string& name, ISvcLocator* svc );

  virtual ~DataSvc();

private:
  DataSvc(const DataSvc&);
  DataSvc& operator= (const DataSvc&);

protected:
  bool checkRoot()    {
    return 0 != m_root;
  }

  virtual IConversionSvc* getDataLoader(IRegistry* pReg);

  virtual DataObject* createDefaultObject()   const;

  virtual StatusCode loadObject( IRegistry* pNode );

  virtual StatusCode loadObject( IConversionSvc* pLoader,
                                 IRegistry* pNode );

  StatusCode retrieveEntry( DataSvcHelpers::RegistryEntry* pNode,
                            const std::string& path,
                            DataSvcHelpers::RegistryEntry*& pEntry );
  DataObject* handleDataFault(IRegistry* pReg, const std::string& path="");
};
#endif // GAUDIKERNEL_DATASVC_H