RegistryEntry.cpp

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2025 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#include <GaudiKernel/DataObject.h>
#include <GaudiKernel/IDataStoreAgent.h>
#include <GaudiKernel/IOpaqueAddress.h>
#include <GaudiKernel/RegistryEntry.h>
#include <algorithm>
 
// If you absolutely need optimization: switch off dynamic_cast.
// This improves access to the data store roughly by more than 10 %
// for balanced trees.
//
// M.Frank
//
#define CAST_REGENTRY( x, y ) dynamic_cast<x>( y )
// #define CAST_REGENTRY(x,y) (x)(y)
constexpr char SEPARATOR{ '/' };
 
DataSvcHelpers::RegistryEntry::RegistryEntry( std::string path, RegistryEntry* parent )
    : m_path( std::move( path ) ), m_pParent( parent ) {
  std::string::size_type sep = m_path.rfind( SEPARATOR );
  if ( m_path.front() != SEPARATOR ) m_path.insert( 0, 1, SEPARATOR );
  if ( sep != std::string::npos ) m_path.erase( 0, sep );
  assemblePath( m_fullpath );
  addRef();
}
 
DataSvcHelpers::RegistryEntry::~RegistryEntry() {
  deleteElements();
  if ( m_pObject ) {
    if ( !m_isSoft ) m_pObject->setRegistry( nullptr );
    m_pObject->release();
  }
  if ( m_pAddress ) {
    if ( !m_isSoft ) m_pAddress->setRegistry( nullptr );
    m_pAddress->release();
  }
}
 
unsigned long DataSvcHelpers::RegistryEntry::release() {
  unsigned long cnt = --m_refCount;
  if ( !m_refCount ) delete this;
  return cnt;
}
 
void DataSvcHelpers::RegistryEntry::setParent( RegistryEntry* pParent ) {
  m_pParent = pParent;
  m_fullpath.clear();
  assemblePath( m_fullpath );
}
 
void DataSvcHelpers::RegistryEntry::makeSoft( DataObject* pObject ) {
  m_isSoft = true;
  setObject( pObject );
  //  if ( 0 != m_pObject )   { // Useless: This justs sets my own address again...
  //    setAddress(m_pObject->address());
  //  }
}
 
void DataSvcHelpers::RegistryEntry::makeSoft( IOpaqueAddress* pAddress ) {
  m_isSoft = true;
  setAddress( pAddress );
}
 
void DataSvcHelpers::RegistryEntry::makeHard( DataObject* pObject ) {
  makeSoft( pObject );
  m_isSoft = false;
  if ( m_pObject ) m_pObject->setRegistry( this );
  if ( m_pAddress ) m_pAddress->setRegistry( this );
}
 
void DataSvcHelpers::RegistryEntry::makeHard( IOpaqueAddress* pAddress ) {
  m_isSoft = false;
  setAddress( pAddress );
}
 
void DataSvcHelpers::RegistryEntry::setAddress( IOpaqueAddress* pAddress ) {
  if ( pAddress ) {
    pAddress->addRef();
    pAddress->setRegistry( this );
  }
  if ( m_pAddress ) m_pAddress->release();
  m_pAddress = pAddress;
}
 
void DataSvcHelpers::RegistryEntry::setObject( DataObject* pObject ) {
  if ( pObject ) {
    pObject->addRef();
    if ( !isSoft() ) pObject->setRegistry( this );
  }
  if ( m_pObject ) m_pObject->release();
  m_pObject = pObject;
}
 
long DataSvcHelpers::RegistryEntry::remove( IRegistry* obj ) {
  try {
    RegistryEntry* pEntry = dynamic_cast<RegistryEntry*>( obj );
    auto           i      = std::remove( std::begin( m_store ), std::end( m_store ), pEntry );
    if ( i != std::end( m_store ) ) {
      pEntry->release();
      m_store.erase( i, std::end( m_store ) );
    }
  } catch ( ... ) {}
  return m_store.size();
}
 
StatusCode DataSvcHelpers::RegistryEntry::remove( std::string_view nam ) {
  if ( nam.front() == SEPARATOR ) nam.remove_prefix( 1 );
  auto i = std::find_if( m_store.begin(), m_store.end(), [&]( const auto* entry ) {
    // skip leading SEPARATOR
    return entry->name().compare( 1, std::string::npos, nam.data(), nam.size() ) == 0;
  } );
  // if the requested object is not present, this is an error....
  if ( i == m_store.end() ) return StatusCode::FAILURE;
  remove( *i );
  return StatusCode::SUCCESS;
}
 
DataSvcHelpers::RegistryEntry* DataSvcHelpers::RegistryEntry::i_create( std::string nam ) {
  if ( nam.front() != SEPARATOR ) nam.insert( 0, 1, SEPARATOR );
  // if this object is already present, this is an error....
  auto not_present =
      std::none_of( std::begin( m_store ), std::end( m_store ), [&]( IRegistry* i ) { return nam == i->name(); } );
  return not_present ? new RegistryEntry( std::move( nam ), this ) : nullptr;
}
 
long DataSvcHelpers::RegistryEntry::add( IRegistry* obj ) {
  RegistryEntry* pEntry = CAST_REGENTRY( RegistryEntry*, obj );
  return i_add( pEntry );
}
 
long DataSvcHelpers::RegistryEntry::i_add( RegistryEntry* pEntry ) {
  // TODO: if this is the sole place where items are added to m_store,
  //      and we know here that they must be RegisteryEntry, can we
  //      drop the dynamic_cast every where else???
  // TODO: if so, can we also change m_store to be std::vector<RegistryEntry*>
  //      instead
  // TODO: if so, can we not make it std::vector<RegistryEntry> instead?
  // TODO: if so, should make sure that a RegistryEntry can be std::move'ed
  try {
    pEntry->setDataSvc( m_pDataProviderSvc );
    m_store.push_back( pEntry );
    pEntry->setParent( this );
    if ( !pEntry->isSoft() && pEntry->address() ) { pEntry->address()->setRegistry( pEntry ); }
  } catch ( ... ) {}
  return m_store.size();
}
 
StatusCode DataSvcHelpers::RegistryEntry::add( std::string name, DataObject* pObject, bool is_soft ) {
  RegistryEntry* entry = i_create( std::move( name ) );
  if ( !entry ) return StatusCode::FAILURE;
  ( is_soft ) ? entry->makeSoft( pObject ) : entry->makeHard( pObject );
  i_add( entry );
  return StatusCode::SUCCESS;
}
 
StatusCode DataSvcHelpers::RegistryEntry::add( std::string name, IOpaqueAddress* pAddress, bool is_soft ) {
  RegistryEntry* entry = i_create( std::move( name ) );
  if ( !entry ) return StatusCode::FAILURE;
  ( is_soft ) ? entry->makeSoft( pAddress ) : entry->makeHard( pAddress );
  i_add( entry );
  return StatusCode::SUCCESS;
}
 
long DataSvcHelpers::RegistryEntry::deleteElements() {
  for ( auto& i : m_store ) {
    RegistryEntry* entry = CAST_REGENTRY( RegistryEntry*, i );
    if ( entry ) {
      entry->deleteElements();
      entry->release();
    }
  }
  m_store.erase( m_store.begin(), m_store.end() );
  return 0;
}
 
IRegistry* DataSvcHelpers::RegistryEntry::i_find( const IRegistry* obj ) const {
  auto i = std::find( m_store.begin(), m_store.end(), obj );
  return ( i != m_store.end() ) ? ( *i ) : nullptr;
}
 
DataSvcHelpers::RegistryEntry* DataSvcHelpers::RegistryEntry::i_find( std::string_view path ) const {
  if ( path.front() == SEPARATOR ) path.remove_prefix( 1 ); // strip leading '/', if present
  while ( !path.empty() ) {
    // check that the chars of path prior to / are the same as regEnt->name()
    // (i.e. match { nam:"/Ab"  path:"/Ab/C"}
    // but not     { nam:"/Abc" path:"/Ab/C"})
    auto loc1  = path.find( SEPARATOR );
    auto cpath = path.substr( 0, loc1 );
    if ( loc1 != std::string_view::npos ) {
      path.remove_prefix( loc1 + 1 );
    } else {
      path = std::string_view{};
    }
    auto i = std::find_if( std::begin( m_store ), std::end( m_store ),
                           [&]( const auto& reg ) { return cpath == std::string_view{ reg->name() }.substr( 1 ); } );
    if ( i != std::end( m_store ) ) {
      RegistryEntry* regEnt = CAST_REGENTRY( RegistryEntry*, *i );
      return path.empty() ? regEnt : regEnt->i_find( path );
    }
    // If this node is "/NodeA", this part allows to find "/NodeA/NodeB" as
    // our "/NodeB" child.
    if ( cpath != std::string_view{ m_path }.substr( 1 ) ) break;
  }
  return nullptr;
}
 
DataSvcHelpers::RegistryEntry* DataSvcHelpers::RegistryEntry::i_find( const DataObject* key ) const {
  if ( key ) {
    if ( key == m_pObject ) return const_cast<RegistryEntry*>( this );
    // Look in the immediate level:
    RegistryEntry* result = CAST_REGENTRY( RegistryEntry*, i_find( key->registry() ) );
    if ( result ) return result;
    // Go levels down
    for ( const auto& i : m_store ) {
      try {
        const RegistryEntry* entry = CAST_REGENTRY( RegistryEntry*, i );
        result                     = entry->i_find( key );
        if ( result ) return result;
      } catch ( ... ) {}
    }
  }
  return nullptr;
}
 
// Traverse registry tree
StatusCode DataSvcHelpers::RegistryEntry::traverseTree( IDataStoreAgent* pAgent, int level ) {
  bool       go_down = pAgent->analyse( this, level );
  StatusCode status;
  if ( go_down ) {
    for ( auto& i : m_store ) {
      try {
        RegistryEntry* entry = CAST_REGENTRY( RegistryEntry*, i );
        entry->traverseTree( pAgent, level + 1 ).ignore();
      } catch ( ... ) { status = StatusCode::FAILURE; }
    }
  }
  return status;
}
 
// Recursive helper to assemble the full path name of the entry
void DataSvcHelpers::RegistryEntry::assemblePath( std::string& buffer ) const {
  if ( m_pParent ) m_pParent->assemblePath( buffer );
  buffer += m_path;
}