RegistryEntry.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_REGISTRYENTRY_H
#define GAUDIKERNEL_REGISTRYENTRY_H

// STL include files
#include <vector>

// Framework include files
#include "GaudiKernel/Kernel.h"
#include "GaudiKernel/IRegistry.h"
#include <boost/utility/string_ref.hpp>

// Forward declarations
class DataSvc;
// DP add this fwd decl for thread safety
class TsDataSvc;
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;
    // DP add friend class: the thread safe version of the DataSvc
    friend class ::TsDataSvc;
    typedef Store::const_iterator Iterator;
  private:
    unsigned long     m_refCount = 0;
    bool              m_isSoft = false;
    std::string       m_fullpath;
    std::string       m_path;
    RegistryEntry*    m_pParent = nullptr;
    IOpaqueAddress*   m_pAddress = nullptr;
    DataObject*       m_pObject = nullptr;
    IDataProviderSvc* m_pDataProviderSvc = nullptr;
    Store             m_store;

  private:
    void  assemblePath(std::string& buffer)  const;
    IRegistry* i_find ( const IRegistry* pDirectory )  const;
    RegistryEntry* i_find ( boost::string_ref path )  const;
    RegistryEntry* i_find ( const DataObject* pObject )  const;
    RegistryEntry* i_create ( std::string name );
    long i_add ( RegistryEntry* entry );
    void setParent(RegistryEntry* pParent);
    void setDataSvc(IDataProviderSvc* s)    {
      m_pDataProviderSvc = s;
    }
    virtual RegistryEntry* parentEntry()   {
      return m_pParent;
    }
    RegistryEntry* findLeaf(boost::string_ref 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(std::string path, RegistryEntry* parent = nullptr);
    ~RegistryEntry() override;
    unsigned long release() override;
    unsigned long addRef() override   {
      return ++m_refCount;
    }
    const std::string& name()  const  override {
      return m_path;
    }
    const std::string& identifier()   const  override {
      return m_fullpath;
    }
    IDataProviderSvc* dataSvc()  const override {
      return m_pDataProviderSvc;
    }
    DataObject*     object()  const override {
      return m_pObject;
    }
    IOpaqueAddress* address()   const  override {
      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) override;
    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