---

RegistryEntry.cpp

Go to the documentation of this file.

// $Header: /nfs/slac/g/glast/ground/cvs/GaudiKernel/src/Lib/RegistryEntry.cpp,v 1.1.1.1 2001/04/18 18:14:18 tlindner Exp $
//====================================================================
//      RegistryEntry.cpp
//--------------------------------------------------------------------
//
//      Package    : DataSvc ( The LHCb Offline System)
//
//  Description: implementation of the Transient data store
//
//      Author     : M.Frank
//  History    :
// +---------+----------------------------------------------+---------
// |    Date |                 Comment                      | Who     
// +---------+----------------------------------------------+---------
// | 29/10/98| Initial version                              | MF
// | 03/02/99| Protect dynamic_cast with try-catch clauses  | MF
// +---------+----------------------------------------------+---------
//
//====================================================================
#define  DATASVC_REGISTRYENTRY_CPP

// STL include files
#include <algorithm>

// Interfaces
#include "GaudiKernel/IDataStoreAgent.h"
#include "GaudiKernel/IOpaqueAddress.h"

// Framework include files
#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/RegistryEntry.h"

RegistryEntry::RegistryEntry(const std::string& path, RegistryEntry* parent)
: m_refCount(0), 
  m_isSoft(false), 
  m_path(path),
  m_parent(parent),
  m_address(0),
  m_object(0), 
  m_transientStore(0)
{
  int sep = m_path.rfind(SEPARATOR);
  if ( path[0] != SEPARATOR )   {
    m_path = SEPARATOR;
    m_path += path;
  }
  if ( sep > 0 )    {
    m_path.erase(0,sep);
  }
  addRef();
}

RegistryEntry::~RegistryEntry()  {
  deleteElements();
  if ( 0 != m_object  )   {
    if ( !m_isSoft ) m_object->setDirectory(0);
    m_object->release();
  }
  if ( 0 != m_address )   {
    if ( !m_isSoft ) m_address->setDirectory(0);
    m_address->release();
  }
}

void RegistryEntry::makeSoft(DataObject* pObject)   {
  m_isSoft = true;
  setObject(pObject);
  if ( 0 != m_object )   {
    setAddress(m_object->address());
  }
}

void RegistryEntry::makeSoft(IOpaqueAddress* pAddress)   {
  m_isSoft = true;
  setAddress(pAddress);
}

void RegistryEntry::makeHard(DataObject* pObject)   {
  makeSoft(pObject);
  m_isSoft = false;
  if ( 0 != m_object )   {
    m_object->setDirectory(this);
  }
  if ( 0 != m_address )   {
    m_address->setDirectory(this);
  }
}

void RegistryEntry::makeHard(IOpaqueAddress* pAddress)   {
  makeSoft(pAddress);
  m_isSoft = false;
  if ( 0 != m_address )   {
    m_address->setDirectory(this);
  }
}

void RegistryEntry::setAddress( IOpaqueAddress* pAddress )    {
  if ( 0 != pAddress  ) pAddress->addRef();
  if ( 0 != m_address ) m_address->release();
  m_address = pAddress;
}

void RegistryEntry::setObject( DataObject* pObject )   {
  if ( 0 != pObject  ) pObject->addRef();
  if ( 0 != m_object ) m_object->release();
  m_object = pObject;
}

unsigned long RegistryEntry::release()  {
  unsigned long cnt = --m_refCount;
  if ( 0 == m_refCount )   {
    delete this;
  }
  return cnt;
}

const CLID& RegistryEntry::clID   ()  const  {
  if ( 0 == m_object )   {
    return CLID_NULL;
  }
  else  {
    return m_object->clID();
  }
}

long RegistryEntry::remove  ( IDataDirectory* obj )    {
  try   {
    RegistryEntry* pEntry = dynamic_cast<RegistryEntry*>(obj);
    Store::iterator i = std::remove(m_store.begin(), m_store.end(), pEntry);
    if (i != m_store.end())   {
      pEntry->release();
      m_store.erase( i, m_store.end() );
    }
  }
  catch ( ... )   {     }
  return m_store.size();
}

long RegistryEntry::remove ( const std::string& name )  {
  std::string path = name;
  if ( path[0] != SEPARATOR )   {
    path  = SEPARATOR;
    path += name;
  }
  // if this object is already present, this is an error....
  for (Store::iterator i = m_store.begin(); i != m_store.end(); i++ )   {
    if ( path == (*i)->name() )   {
      //      (*i)->release();
      remove(*i);
      return StatusCode::SUCCESS;
    }
  }
  return StatusCode::FAILURE;
}

RegistryEntry* RegistryEntry::i_add(const std::string& name)    {
  std::string path = name;
  if ( path[0] != SEPARATOR )   {
    path  = SEPARATOR;
    path += name;
  }
  // if this object is already present, this is an error....
  for (Store::iterator i = m_store.begin(); i != m_store.end(); i++ )   {
    if ( path == (*i)->name() )  {
      return 0;
    }
  }
  return new RegistryEntry( path, this );
}

long RegistryEntry::add( IDataDirectory* obj )    {
  try   {
    RegistryEntry* pEntry = dynamic_cast<RegistryEntry*>(obj);
    pEntry->setStore(m_transientStore);
    m_store.push_back(pEntry);
    pEntry->m_parent = this;
    if ( !pEntry->isSoft() && pEntry->address() != 0 )   {
      pEntry->address()->setDirectory(pEntry);
    }
  }
  catch ( ... )   {     }
  return m_store.size();
}

long RegistryEntry::add ( const std::string& name, DataObject* pObject, bool is_soft )  {
  RegistryEntry* entry = i_add(name);
  if ( 0 != entry )   {
    ( is_soft ) ? entry->makeSoft(pObject) : entry->makeHard(pObject);
    add( entry );
    return StatusCode::SUCCESS;
  }
  return StatusCode::FAILURE;
}

long RegistryEntry::add ( const std::string& name, IOpaqueAddress* pAddress, bool is_soft )  {
  RegistryEntry* entry = i_add(name);
  if ( 0 != entry )   {
    ( is_soft ) ? entry->makeSoft(pAddress) : entry->makeHard(pAddress);
    add( entry );
    return StatusCode::SUCCESS;
  }
  return StatusCode::FAILURE;
}

long RegistryEntry::deleteElements()   {
  for (Store::iterator i = m_store.begin(); i != m_store.end(); i++ )   {
      (*i)->deleteElements();
      (*i)->release();
  }
  m_store.erase(m_store.begin(), m_store.end());
  return 0;
}

const IDataDirectory* RegistryEntry::i_find( const IDataDirectory* obj )  const  {
  Store::const_iterator i = std::find(m_store.begin(),m_store.end(),obj);
  return (i==m_store.end()) ? 0 : (*i);
}

const IDataDirectory* RegistryEntry::i_find ( const std::string& path )  const  {
  if ( path[0] == '/' )   {
    return i_findLeaf(path);
  }
  else  {
    std::string searchpath(name());
    searchpath += SEPARATOR;
    searchpath += path;
    return i_findLeaf(searchpath);
  }
}

const RegistryEntry* RegistryEntry::i_findLeaf(const std::string& path)   const    {
  if ( path == m_path )    {
    return this;
  }
  else  {
    int loc1 = path.find(SEPARATOR,1);
    std::string obj_path(path, 0, loc1>0 ? loc1 : path.length());
    if ( obj_path == m_path )   {
      std::string daughter(path, loc1>0 ? loc1 : path.length(), path.length());
      return i_findLeaf(daughter);
    }
    else  {
      for (Store::const_iterator i = m_store.begin(); i != m_store.end(); i++ )   {
        if ( obj_path == (*i)->name() )  {
          try   {
            const RegistryEntry* result = dynamic_cast<const RegistryEntry*>(*i);
            if ( loc1 > 0 )   {
              std::string search_path(path, loc1, path.length());
              result = result->i_findLeaf(search_path);
              if ( 0 != result )  return result;
            }
            else  {
              return result;
            }
          }
          catch (...)   {          }
        }
      }
    }
  }
  return 0;
}

const RegistryEntry* RegistryEntry::i_findLeaf(const DataObject* key)  const  {
  if ( 0 != key )  {
    if ( key == m_object )    {
      return this;
    }
    // Look in the immediate level:
    const RegistryEntry *result = dynamic_cast<const RegistryEntry*>(i_find(key->directory()));
    if ( 0 != result ) return result;
    // Go levels down
    for (Store::const_iterator i = m_store.begin(); i != m_store.end(); i++ )   {
      try   {
        const RegistryEntry *entry = dynamic_cast<RegistryEntry*>(*i);
        if(NULL != (result = entry->i_findLeaf(key))) 
          return result;
      }
      catch ( ... )   {    }
    }
  }
  return 0;
}

RegistryEntry* RegistryEntry::findParent(const std::string& path)    {
  int len = m_path.length();
  int loc = path.rfind(RegistryEntry::SEPARATOR);
  if ( strncmp(path.data(), m_path.data(), len) == 0 && loc >= len)   {
    std::string p_path(path, len, loc-len);
    if ( p_path.length() > 0 )  {
       RegistryEntry* entry = findLeaf(p_path);
       return entry;
    }
    return this;
  }
  return 0;
}

RegistryEntry* RegistryEntry::findParent(DataObject* pObject)    {
  if ( 0 != pObject )   {
    try   {
      RegistryEntry* entry = dynamic_cast<RegistryEntry*>(pObject->directory());
      if ( 0 != entry )   {
        RegistryEntry* parent = entry->parentEntry();
        return parent;
      }
    }
    catch (...)   {   }
  }
  return 0;
}

// Traverse registry tree
StatusCode RegistryEntry::traverseTree(IDataStoreAgent* pAgent, int level)    {
  bool go_down = pAgent->analyse(this, level);
  StatusCode status = StatusCode::SUCCESS;
  if ( go_down )    {
    for ( Store::iterator i = m_store.begin(); i != m_store.end(); i++ )   {
      try   {
        RegistryEntry* entry = dynamic_cast<RegistryEntry*>(*i);
        entry->traverseTree(pAgent, level+1);
      }
      catch (...)   {
        status = StatusCode::FAILURE;
      }
    }
  }
  return status;
}

// Retrieve the location of the object (= full path of parent)
const std::string& RegistryEntry::location()    const   {
  static std::string nullLocation("");
  return ( 0 == m_parent ) ? nullLocation : m_parent->fullpath();
}

// Recursive helper to assemble the full path name of the entry
void RegistryEntry::assemblePath(std::string& buffer)  const  {
  if ( m_parent != 0 )    {
    m_parent->assemblePath(buffer);
  }
  buffer += m_path;
}

// Retrieve the location of the object (= full path of parent)
const std::string& RegistryEntry::fullpath()    const   {
  std::string& buff = (std::string&)m_fullpath;
  buff = "";
  assemblePath(buff);
  return buff;
}

---