RegistryEntry.h

Go to the documentation of this file.

// $Id: RegistryEntry.h,v 1.8 2005/07/18 16:34:05 hmd Exp $
#ifndef GAUDIKERNEL_REGISTRYENTRY_H
#define GAUDIKERNEL_REGISTRYENTRY_H

// STL include files
#include <vector>

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

// Forward declarations
class DataSvc;
class DataObject;
class IDataProviderSvc;
class IOpaqueAddress;
class IDataStoreAgent;


namespace DataSvcHelpers   {
  class GAUDI_API RegistryEntry : public IRegistry  {
  private:
    typedef std::vector<IRegistry*> Store;
  public:
    friend class ::DataSvc;
    typedef Store::const_iterator Iterator;
  private:
    unsigned long     m_refCount;
    bool              m_isSoft;
    std::string       m_fullpath;
    std::string       m_path;
    RegistryEntry*    m_pParent;
    IOpaqueAddress*   m_pAddress;
    DataObject*       m_pObject;
    IDataProviderSvc* m_pDataProviderSvc;
    Store             m_store;

  private:

    void  assemblePath(std::string& buffer)  const;
    IRegistry* i_find ( const IRegistry* pDirectory )  const;
    RegistryEntry* i_find ( const std::string& path )  const;
    RegistryEntry* i_find ( const DataObject* pObject )  const;
    RegistryEntry* i_add ( const std::string& name );
    void setParent(RegistryEntry* pParent);
    void setDataSvc(IDataProviderSvc* s)    {
      m_pDataProviderSvc = s;
    }
    virtual RegistryEntry* parentEntry()   {
      return m_pParent;
    }
    RegistryEntry* findLeaf(const std::string& path)  const    {
      return i_find(path);
    }
    RegistryEntry* findLeaf(const DataObject* key)  const  {
      return i_find(key);
    }
    void makeHard (DataObject* pObject);
    void makeHard (IOpaqueAddress* pAddress);
    void makeSoft (DataObject* pObject);
    void makeSoft (IOpaqueAddress* pAddress);
  public:
    RegistryEntry(const std::string& path, RegistryEntry* parent = 0);
    virtual ~RegistryEntry();
    virtual unsigned long release();
    virtual unsigned long addRef()    {
      return ++m_refCount;
    }
    const std::string& name()  const  {
      return m_path;
    }
    virtual const std::string& identifier()   const  {
      return m_fullpath;
    }
    virtual IDataProviderSvc* dataSvc()  const {
      return m_pDataProviderSvc;
    }
    virtual DataObject*     object()  const {
      return m_pObject;
    }
    virtual IOpaqueAddress* address()   const  {
      return m_pAddress;
    }
    virtual IRegistry* parent()   const  {
      return m_pParent;
    }
    virtual bool isSoft()   const     {
      return m_isSoft;
    }
    const Store& leaves()  const   {
      return m_store;
    }
    virtual int             size()  const   {
      return m_store.size();
    }
    virtual bool            isEmpty()  const    {
      return m_store.size() == 0;
    }
    virtual Iterator   begin   ()   const  {
      return m_store.begin();
    }
    virtual Iterator   end     ()   const  {
      return m_store.end();
    }
    virtual IRegistry* find ( const IRegistry* obj )  const  {
      return i_find(obj);
    }
    virtual IRegistry* find ( const std::string& path )  const  {
      return i_find(path);
    }
    void setAddress(IOpaqueAddress* pAddress);
    void setObject(DataObject* obj);

    virtual long add(const std::string& name,
                     DataObject* pObject,
                     bool is_soft = false);
    virtual long add(const std::string& name,
                     IOpaqueAddress* pAddress,
                     bool is_soft = false);
    virtual long remove(const std::string& name);
    virtual long add(IRegistry* obj);
    virtual long remove(IRegistry* obj);
    virtual long deleteElements();
    virtual long traverseTree(IDataStoreAgent* pAgent, int level = 0);
  };
}
#endif  // GAUDIKERNEL_REGISTRYENTRY_H