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/IRegistry.h"
#include "GaudiKernel/Kernel.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