In This Package:

DataSvc.h

Go to the documentation of this file.

// $Id: DataSvc.h,v 1.14 2006/11/30 14:43:13 mato Exp $
#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;
// Service factory
template <class TYPE> class SvcFactory;

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


class DataSvc  : public Service,
                             virtual public IDataProviderSvc, 
                 virtual public IDataManagerSvc
{
  friend class SvcFactory<DataSvc>;

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 queryInterface( const InterfaceID& riid, void** ppvUnknown );

  virtual StatusCode initialize();

  virtual StatusCode reinitialize();

  virtual StatusCode finalize();

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

  virtual ~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

---