---

DataSvc.cpp

Go to the documentation of this file.

// $Header: /nfs/slac/g/glast/ground/cvs/GaudiKernel/src/Lib/DataSvc.cpp,v 1.1.1.1 2001/04/18 18:14:18 tlindner Exp $
//====================================================================
//      DataSvc.cpp
//--------------------------------------------------------------------
//
//      Package    : System ( The LHCb Offline System)
//
//  Description: implementation of the Transient data service: DataSvc
//
//  Author     : M.Frank
//  History    :
// +---------+----------------------------------------------+---------
// |    Date |                 Comment                      | Who     
// +---------+----------------------------------------------+---------
// | 29/10/98| Initial version                              | M.Frank
// | 20/2/99 | Automatic data preloading introduced.        | M.Frank
// +---------+----------------------------------------------+---------
//
//====================================================================
#define  DATASVC_DATASVC_CPP

// Include files
#include <cstdlib>
#include <vector>
#include <algorithm>
// Framework include files
#include "GaudiKernel/IConverter.h"
#include "GaudiKernel/IDataDirectory.h"
#include "GaudiKernel/IOpaqueAddress.h"
#include "GaudiKernel/IConversionSvc.h"

#include "GaudiKernel/xtoa.h"
#include "GaudiKernel/SvcFactory.h"
#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/GaudiException.h"

#include "GaudiKernel/TransientStore.h"
#include "GaudiKernel/RegistryEntry.h"
#include "GaudiKernel/DataSvc.h"

extern const CLID CLID_Event;

// Instantiation of a static factory class used by clients to create
// instances of this service
static SvcFactory<DataSvc> s_factory;
const ISvcFactory& DataSvcFactory = s_factory;

StatusCode DataSvc::clearSubTree(const std::string& sub_tree_path)    {
  if ( checkRoot() )  {
    RegistryEntry* node_entry = m_root->findLeaf(sub_tree_path);
    if ( 0 != node_entry )   {
      RegistryEntry* parent = node_entry->parentEntry();
      if ( 0 != parent )  {
        parent->remove(node_entry);
        return SUCCESS;
      }
      return INVALID_PARENT;
    }
    return INVALID_OBJECT;
  }
  return INVALID_ROOT;
}

StatusCode DataSvc::clearSubTree(DataObject* pObject)    {
  if ( checkRoot() )  {
    RegistryEntry* entry = dynamic_cast<RegistryEntry*>(pObject->directory());
    if ( 0 != entry )   {
      RegistryEntry* parent = entry->parentEntry();
      if ( 0 != parent )  {
        parent->remove(entry);
        return SUCCESS;
      }
      return INVALID_PARENT;
    }
    return INVALID_OBJECT;
  }
  return INVALID_ROOT;
}

StatusCode DataSvc::clearStore()   {
  if ( checkRoot() )    {
    m_root->release();
    m_root = 0;
    return SUCCESS;
  }
  return INVALID_ROOT;
}

StatusCode DataSvc::traverseSubTree ( const std::string& sub_tree_path,IDataStoreAgent* pAgent )  {
  if ( checkRoot() )  {
    RegistryEntry* entry = m_root->findLeaf(sub_tree_path);
    if ( 0 != entry )   {
      return entry->traverseTree(pAgent);
    }
    return INVALID_OBJECT;
  }
  return INVALID_ROOT;
}

StatusCode DataSvc::traverseSubTree ( DataObject* pObject,IDataStoreAgent* pAgent )  {
  if ( checkRoot() )    {
    RegistryEntry* entry = dynamic_cast<RegistryEntry*>(pObject->directory());
    if ( 0 != entry )   {
      return entry->traverseTree(pAgent);
    }
    return INVALID_OBJECT;
  }
  return INVALID_ROOT;
}

StatusCode DataSvc::traverseTree(IDataStoreAgent* pAgent)   {
  if ( checkRoot() )    {
    return m_root->traverseTree(pAgent);
  }
  return INVALID_ROOT;
}

StatusCode DataSvc::setRoot(const std::string& root_path, DataObject* pRootObj)    {
  clearStore();
  if ( 0 != pRootObj )  {
    m_root = new RegistryEntry(root_path);
    m_root->makeHard(pRootObj);
    preLoad();
  }
  return SUCCESS;
}

StatusCode DataSvc::setRoot(const std::string& root_path, IOpaqueAddress* pRootAddr)    {
  clearStore();
  if ( 0 != pRootAddr )  {
    m_root = new RegistryEntry(root_path);
    m_root->makeHard(pRootAddr);
    preLoad();
  }
  return SUCCESS;
}

StatusCode DataSvc::setDataLoader(IConversionSvc* pDataLoader)    {
  if ( 0 != pDataLoader  ) pDataLoader->addRef();
  if ( 0 != m_dataLoader ) m_dataLoader->release();
  m_dataLoader = pDataLoader;
  return SUCCESS;
}

StatusCode DataSvc::registerObject(const std::string& fullPath, DataObject* pObject)   {
  if ( checkRoot() )  {
    RegistryEntry* node_entry = m_root->findParent(fullPath);
    if ( 0 != node_entry )   {
      int loc = fullPath.rfind(IDataDirectory::SEPARATOR);
      std::string obj_name(fullPath, loc, fullPath.length()-loc);
      StatusCode status = node_entry->add( obj_name, pObject );
      return status.isSuccess() ? status.getCode() : DOUBL_OBJ_PATH;
    }
    return INVALID_PARENT;
  }
  return INVALID_ROOT;
}


StatusCode DataSvc::registerObject(const std::string& parentPath, const std::string& objPath, DataObject* pObject)   {
  if ( checkRoot() )  {
    RegistryEntry* node_entry = m_root->findLeaf(parentPath);
    if ( 0 != node_entry )   {
      StatusCode status = node_entry->add( objPath, pObject );
      return status.isSuccess() ? status.getCode() : DOUBL_OBJ_PATH;
    }
    return INVALID_PARENT;
  }
  return INVALID_ROOT;
}

StatusCode DataSvc::registerObject(const std::string& parentPath, int item, DataObject* pObject)   {
  if ( checkRoot() )    {
    RegistryEntry* node_entry = m_root->findLeaf(parentPath);
    if ( 0 != node_entry )   {
      char buffer[32] = "/";
      _itoa( item, &buffer[1] , 10 );
      StatusCode status = node_entry->add( buffer, pObject );
      return status.isSuccess() ? status.getCode() : DOUBL_OBJ_PATH;
    }
    return INVALID_PARENT;
  }
  return INVALID_ROOT;
}

StatusCode DataSvc::registerObject(DataObject* parentObj, const std::string& objPath, DataObject* pObject)   {
  if ( checkRoot() )  {
    RegistryEntry* node_entry = m_root->findLeaf(parentObj);
    if ( 0 != node_entry )   {
      StatusCode status;
      int sep = objPath.rfind(IDataDirectory::SEPARATOR);
      if ( sep > 0 )    {
        std::string p_path (objPath, 0, sep);
        std::string o_path (objPath, sep, objPath.length());
        node_entry = m_root->findLeaf(p_path);
        if ( 0 != node_entry )    {
          status = registerObject( node_entry->object(), o_path, pObject );
        }
        else  {
          status = INVALID_PARENT;
        }
      }
      else   {
        status = node_entry->add( objPath, pObject );
      }
      return status.isSuccess() ? status.getCode() : DOUBL_OBJ_PATH;
    }
    return INVALID_PARENT;
  }
  return INVALID_ROOT;
}

StatusCode DataSvc::registerObject(DataObject* parentObj, int item, DataObject* pObject)   {
  if ( checkRoot() )  {
    RegistryEntry* node_entry = m_root->findLeaf(parentObj);
    if ( 0 != node_entry )   {
      char buffer[32] = "/";
      _itoa( item, &buffer[1] , 10 );
      StatusCode status = node_entry->add( buffer, pObject );
      return status.isSuccess() ? status.getCode() : DOUBL_OBJ_PATH;
    }
    return INVALID_PARENT;
  }
  return INVALID_ROOT;
}

StatusCode DataSvc::unregisterObject(const std::string& fullPath)   {
  if ( checkRoot() )  {
    RegistryEntry* parent = m_root->findParent(fullPath);
    if ( 0 != parent )   {
      int loc = fullPath.rfind(IDataDirectory::SEPARATOR);
      std::string obj(fullPath, loc, fullPath.length()-loc);
      RegistryEntry* entry = parent->findLeaf(obj);
      if ( 0 != entry )   {
        if ( entry->isEmpty() )    {
          if ( 0 != entry->object() )    {
            entry->object()->addRef();
          }
          parent->remove(entry);
          return SUCCESS;
        }
        return DIR_NOT_EMPTY;
      }
      return INVALID_OBJECT;
    }
    return INVALID_PARENT;
  }
  return INVALID_ROOT;
}

StatusCode DataSvc::unregisterObject(const std::string& parentPath, const std::string& objPath)   {
  if ( checkRoot() )  {
    RegistryEntry* parent = m_root->findLeaf(parentPath);
    if ( 0 != parent )   {
      RegistryEntry* entry = parent->findLeaf(objPath);
      if ( 0 != entry )   {
        if ( entry->isEmpty() )    {
          if ( 0 != entry->object() )    {
            entry->object()->addRef();
          }
          parent->remove(entry);
          return SUCCESS;
        }
        return DIR_NOT_EMPTY;
      }
      return INVALID_OBJECT;
    }
    return INVALID_PARENT;
  }
  return INVALID_ROOT;
}

StatusCode DataSvc::unregisterObject(const std::string& parentPath, int item)   {
  if ( checkRoot() )  {
    RegistryEntry* parent = m_root->findLeaf(parentPath);
    if ( 0 != parent )   {
      char objPath[32] = "/";
      _itoa( item, &objPath[1] , 10 );
      RegistryEntry* entry = parent->findLeaf(objPath);
      if ( 0 != entry )   {
        if ( entry->isEmpty() )    {
          if ( 0 != entry->object() )    {
            entry->object()->addRef();
          }
          parent->remove(entry);
          return SUCCESS;
        }
        return DIR_NOT_EMPTY;
      }
      return INVALID_OBJECT;
    }
    return INVALID_PARENT;
  }
  return INVALID_ROOT;
}

StatusCode DataSvc::unregisterObject(DataObject* pObject)    {
  if ( checkRoot() )  {
    RegistryEntry* parent = m_root->findParent(pObject);
    if ( 0 != parent )   {
      RegistryEntry* entry = parent->findLeaf(pObject);
      if ( 0 != entry )   {
        if ( entry->isEmpty() )    {
          if ( 0 != entry->object() )    {
            entry->object()->addRef();
          }
          parent->remove(entry);
          return SUCCESS;
        }
        return DIR_NOT_EMPTY;
      }
      return INVALID_OBJECT;
    }
    return INVALID_PARENT;
  }
  return INVALID_ROOT;
}

StatusCode DataSvc::unregisterObject(DataObject* pParentObj, const std::string& objectPath)    {
  if ( checkRoot() )  {
    try   {
      RegistryEntry* parent = dynamic_cast<RegistryEntry*>(pParentObj->directory());
      if ( 0 != parent )   {
        RegistryEntry* entry = parent->findLeaf(objectPath);
        if ( 0 != entry )   {
          if ( entry->isEmpty() )    {
            if ( 0 != entry->object() )    {
              entry->object()->addRef();
            }
            parent->remove(entry);
            return SUCCESS;
          }
          return DIR_NOT_EMPTY;
        }
        return INVALID_OBJECT;
      }
    }
    catch(...) {
    }   
    return INVALID_PARENT;
  }
  return INVALID_ROOT;
}

StatusCode DataSvc::unregisterObject(DataObject* pParentObj, int item)    {
  if ( checkRoot() )  {
    try   {
      RegistryEntry* parent = dynamic_cast<RegistryEntry*>(pParentObj->directory());
      if ( 0 != parent )   {
        char objPath[32] = "/";
        _itoa( item, &objPath[1] , 10 );
        RegistryEntry* entry = parent->findLeaf(objPath);
        if ( 0 != entry )   {
          if ( entry->isEmpty() )    {
            if ( 0 != entry->object() )    {
              entry->object()->addRef();
            }
            parent->remove(entry);
            return SUCCESS;
          }
          return DIR_NOT_EMPTY;
        }
        return INVALID_OBJECT;
      }
    }
    catch(...) {
   }   
    return INVALID_PARENT;
  }
  return INVALID_ROOT;
}

StatusCode DataSvc::loadObject(IDataDirectory* pDirectory)   {
  StatusCode status = INVALID_OBJ_ADDR;
  DataObject* obj = 0;
  if ( 0 == m_dataLoader )   {                                  // Precondition:
    return NO_DATA_LOADER;                                      // Data loader must be present
  }
  if ( 0 == pDirectory->address() )  {                          // Precondition:
    return INVALID_OBJ_ADDR;                                    // Addres must be valid
  }
  try   {
    RegistryEntry *pEntry = dynamic_cast<RegistryEntry*>(pDirectory);
    pEntry->address()->setDirectory( pEntry );                  // Update object address
    status = m_dataLoader->createObj(pEntry->address(), obj);   // Call data loader
    if ( status.isSuccess() )    {                              // Check result
      obj->setDirectory (pEntry);                               // Update object directory
      pEntry->setObject(obj);                                   // Update registry entry
    }
  }
  catch( const GaudiException& exc ) {
    throw GaudiException("GaudiException in loadObject() " + pDirectory->name(), 
        name(), StatusCode::FAILURE, exc); 
  } 
  catch( const std::exception& ) {
    throw GaudiException("std::exception in loadObject() " + pDirectory->name(), 
      name(), StatusCode::FAILURE); 
  }
  catch(...) {
    throw GaudiException("UNKN exception in loadObject() " + pDirectory->name(), 
      name(), StatusCode::FAILURE); 
  }   
  return status;
}

StatusCode DataSvc::retrieveEntry(RegistryEntry* parentObj, const std::string& path, RegistryEntry*& pEntry)  {
  int        sep    = path.find(IDataDirectory::SEPARATOR,1);
  StatusCode status = INVALID_ROOT;
 
  pEntry = 0;
  if ( sep > 0 )  {
    std::string p_path (path,0,sep);
    std::string o_path (path,sep,path.length());
    RegistryEntry* root_entry = parentObj->findLeaf(p_path);
    if ( 0 != root_entry )    {
      if ( 0 == root_entry->object() )   {
        // Object is not loaded: load the object if at all possible
        status = loadObject(root_entry);
        if ( !status.isSuccess() )  {
          return status;
        }
      }
      status = retrieveEntry (root_entry, o_path, pEntry);
    }
    return status;
  }
  // last leave in search: find leaf and load
  if ( 0 == (pEntry=parentObj->findLeaf(path)) )
    status = INVALID_OBJ_PATH;
  else if ( 0 == pEntry->object() )
    status = loadObject(pEntry);
  else
    status = SUCCESS;
  return status;
}

StatusCode DataSvc::retrieveObject(IDataDirectory* pDirectory, const std::string& path, DataObject*& pObject)   {
  StatusCode status = StatusCode::FAILURE;
  pObject = 0;
  if ( 0 != pDirectory )    {
    if ( path.length() == 0)    {
      if ( pDirectory->object() == 0 )
        status = loadObject(pDirectory);
      else
        status = StatusCode::SUCCESS;
    }
    else    {
      RegistryEntry* parent = dynamic_cast<RegistryEntry*>(pDirectory);
      RegistryEntry* result = 0;
      status = retrieveEntry(parent, path, result);
      pDirectory = result;
    }
    if ( status.isSuccess() )   {
      pObject = pDirectory->object();
    }
  }
  return status;
}

StatusCode DataSvc::retrieveObject(const std::string& fullPath, DataObject*& pObject)   {
  DataObject* pNullObject = 0;
  return retrieveObject(pNullObject, fullPath, pObject);
}

StatusCode DataSvc::retrieveObject(const std::string& parentPath, const std::string& objectPath, DataObject*& pObject)   {
  DataObject* parent = 0;
  StatusCode status = retrieveObject(parentPath, parent);
  if ( status.isSuccess() )   {
    status = retrieveObject (parent, objectPath, pObject);
  }
  return status;
}

StatusCode DataSvc::retrieveObject(const std::string& parentPath, int item, DataObject*& pObject)   {
  DataObject* parent = 0;
  StatusCode status = retrieveObject(parentPath, parent);
  if ( status.isSuccess() )   {
    status = retrieveObject (parent, item, pObject);
  }
  return status;
}

StatusCode DataSvc::retrieveObject(DataObject* parentObj,const std::string& path,DataObject*& pObject)  {
  StatusCode status = INVALID_ROOT;
  RegistryEntry *root_entry = 0, *entry = 0;
  pObject = 0;
  if ( checkRoot() )  {
    try   {
      root_entry = (0==parentObj) ? m_root.door() : dynamic_cast<RegistryEntry*>(parentObj->directory());
    }
    catch (...)   {
      return INVALID_PARENT;
    }
    status = retrieveEntry(root_entry,path,entry);
    if ( status.isSuccess() ) {
      pObject = entry->object();
    }
  }
  return status;
}

StatusCode DataSvc::retrieveObject(DataObject* parentObj, int item, DataObject*& pObject)  {
  char buffer[32] = "/";
  _itoa(item,&buffer[1],10);
  return retrieveObject(parentObj, buffer, pObject);
}

StatusCode DataSvc::findObject(IDataDirectory* pDirectory, const std::string& path, DataObject*& pObject)   {
  pObject = 0;
  if ( 0 != pDirectory )    {
    if ( path.length() > 0 )  {
      pDirectory = pDirectory->find(path);
    }
    if ( 0 != pDirectory )    {
      pObject = pDirectory->object();
    }
  }
  return (0 == pObject) ? OBJ_NOT_LOADED : SUCCESS;
}

StatusCode DataSvc::findObject(const std::string& path, DataObject*& pObject)   {
  pObject = 0;
  if ( checkRoot() )  {
    RegistryEntry* entry = m_root->findLeaf(path);
    if ( 0 != entry )   {
      pObject = entry->object();
      return (0 == pObject) ? OBJ_NOT_LOADED : SUCCESS;
    }
    return INVALID_OBJ_PATH;
  }
  return INVALID_ROOT;
}

StatusCode DataSvc::findObject(const std::string& parentPath, const std::string& objectPath, DataObject*& pObject)   {
  DataObject* parent = 0;
  StatusCode status = findObject(parentPath, parent);
  if ( status.isSuccess() )   {
    status = findObject (parent, objectPath, pObject);
  }
  return status;
}

StatusCode DataSvc::findObject(const std::string& parentPath, int item, DataObject*& pObject)   {
  DataObject* parent = 0;
  StatusCode status = findObject(parentPath, parent);
  if ( status.isSuccess() )   {
    status = findObject (parent, item, pObject);
  }
  return status;
}

StatusCode DataSvc::findObject(DataObject* parentObj, int item, DataObject*& pObject)    {
  char buffer[32] = "/";
  _itoa(item,&buffer[1],10);
  return findObject(parentObj, buffer, pObject);
}

StatusCode DataSvc::findObject(DataObject* parentObj, const std::string& path, DataObject*& pObject)    {
  pObject = 0;
  if ( checkRoot() )  {
    RegistryEntry* node_entry = (0==parentObj) 
      ? m_root.door() 
      : dynamic_cast<RegistryEntry*>(parentObj->directory());
    if ( 0 != node_entry )    {
      RegistryEntry *leaf = node_entry->findLeaf(path);
      if ( 0 == leaf )  {
        return INVALID_OBJ_PATH;
      }
      pObject = leaf->object();
      return (0 == pObject) ? OBJ_NOT_LOADED : SUCCESS;
    }
    return INVALID_PARENT;
  }
  return INVALID_ROOT;
}

StatusCode DataSvc::updateObject(const std::string& updatePath)   {
  if ( checkRoot() )  {
    RegistryEntry* entry = m_root->findLeaf(updatePath);
    if ( 0 != entry )   {
      if ( 0 != entry->object() )   {
        return updateObject( entry->object() );
      }
      return INVALID_OBJECT;
    }
    return INVALID_OBJ_PATH;
  }
  return INVALID_ROOT;
}

StatusCode DataSvc::updateObject(IDataDirectory* pDirectory)    {
  if ( 0 == pDirectory )  {                                     // Precondition:
    return INVALID_OBJ_ADDR;                                    // Addres must be valid
  }
  DataObject* toUpdate = pDirectory->object();
  if ( 0 == toUpdate )  {                                       // Try first to load
    return loadObject(pDirectory);
  }
  return updateObject(toUpdate);
}

StatusCode DataSvc::updateObject(DataObject* toUpdate)    {
  StatusCode status = INVALID_OBJ_ADDR;
  if ( 0 == m_dataLoader )   {                                  // Precondition:
    return NO_DATA_LOADER;                                      // Data loader must be present
  }
  if ( 0 == toUpdate )  {                                       // Precondition:
    return INVALID_OBJECT;                                      // Address must be valid
  }
  IDataDirectory* pDirectory = toUpdate->directory();
  if ( 0 == pDirectory )    {
    return INVALID_OBJ_ADDR;
  }
  try   {
    status = m_dataLoader->updateObj(pDirectory->address(), toUpdate);// Call data loader
  }
  catch( const GaudiException& exc ) {
    throw GaudiException("GaudiException in updateObject() " + toUpdate->directory()->name(), 
        name(), StatusCode::FAILURE, exc); 
  } 
  catch( const std::exception& ) {
    throw GaudiException("std::exception in updateObject() " + toUpdate->directory()->name(), 
      name(), StatusCode::FAILURE); 
  }
  catch(...) {
    throw GaudiException("UNKN exception in updateObject() " + toUpdate->directory()->name(), 
      name(), StatusCode::FAILURE); 
  }   
  return status;
}

StatusCode DataSvc::updateObject(const std::string& parentPath, const std::string& updatePath)    {
  DataObject* pParent = 0;
  StatusCode status = findObject(parentPath, pParent);
  if ( status.isSuccess() )   {
    status = updateObject( pParent, updatePath);
  }
  return status;
}

StatusCode DataSvc::updateObject(DataObject* parent, const std::string& updatePath)   {
  DataObject* pObject = 0;
  StatusCode status = findObject(parent, updatePath, pObject);
  if ( status.isSuccess() )   {
    status = updateObject(pObject);
  }
  return status;
}

// Link object
StatusCode DataSvc::linkObject(IDataDirectory* from, const std::string& objPath, DataObject* to)    {
  try   {
    RegistryEntry* from_entry = dynamic_cast<RegistryEntry*>(from);
    if ( 0 != from_entry )    {
      // First check if both objects are already registered to the store
      RegistryEntry* to_entry   = m_root->findLeaf(to);
      if ( 0 == to_entry )   {
        return INVALID_OBJECT;
      }
      else  {
        // Now register the soft link
        StatusCode status = from_entry->add( objPath, to, true);
        return status.isSuccess() ? StatusCode::SUCCESS : DOUBL_OBJ_PATH;
      }
    }
  }
  catch (...) {
  }
  return INVALID_PARENT;
}

StatusCode DataSvc::linkObject(const std::string& fullPath, DataObject* to)    {
  if ( checkRoot() )  {
    int sep = fullPath.rfind(IDataDirectory::SEPARATOR);
    std::string objPath(fullPath,sep,fullPath.length());
    std::string fromPath(fullPath,0,sep-1);
    return linkObject( fromPath, objPath, to);
  }
  return INVALID_ROOT;
}

StatusCode DataSvc::linkObject(const std::string& from, const std::string& objPath, DataObject* to)    {
  if ( checkRoot() )  {
    IDataDirectory* from_entry = m_root->findLeaf(from);
    return linkObject( from_entry, objPath, to);
  }
  return INVALID_ROOT;
}

StatusCode DataSvc::linkObject(DataObject* from, const std::string& objPath, DataObject* to)    {
  if ( checkRoot() )  {
    IDataDirectory* from_entry = m_root->findLeaf(from);
    return linkObject( from_entry, objPath, to);
  }
  return INVALID_ROOT;
}

StatusCode DataSvc::unlinkObject(IDataDirectory* from, const std::string& objPath)    {
  try   {
    RegistryEntry* from_entry = dynamic_cast<RegistryEntry*>(from);
    if ( 0 != from_entry )    {
      return from_entry->remove( objPath );
    }
  }
  catch (...)   {
  }
  return INVALID_PARENT;
}

StatusCode DataSvc::unlinkObject(const std::string& fullPath)    {
  if ( checkRoot() )  {
    IDataDirectory* entry = m_root->findLeaf(fullPath);
    if ( 0 != entry )   {
      IDataDirectory* from = entry->parent();
      int sep = fullPath.rfind(IDataDirectory::SEPARATOR);
      std::string objPath(fullPath,sep,fullPath.length());
      return unlinkObject(from, objPath);
    }
    return INVALID_OBJ_PATH;
  }
  return INVALID_ROOT;
}

StatusCode DataSvc::unlinkObject(const std::string& from, const std::string& objPath)    {
  if ( checkRoot() )  {
    IDataDirectory* from_entry = m_root->findLeaf(from);
    return unlinkObject(from_entry, objPath);
  }
  return INVALID_ROOT;
}

StatusCode DataSvc::unlinkObject(DataObject* from, const std::string& objPath)    {
  if ( checkRoot() )  {
    IDataDirectory* from_entry = m_root->findLeaf(from);
    return unlinkObject(from_entry, objPath);
  }
  return INVALID_ROOT;
}

StatusCode DataSvc::updateRegistryEntry(IOpaqueAddress* pAddress, DataObject* pObj)    {
  if ( !(0 == pObj || 0 == pAddress) )    {
    try   {
      RegistryEntry* entry = dynamic_cast<RegistryEntry*>(pAddress->directory());
      if ( 0 != entry )   {   // We are loading the object from the persistent storage
        pObj->setDirectory(entry);
        entry->setObject(pObj);
        if ( 0 == entry->address() )  {
          if ( 0 != pAddress && !entry->isSoft() )    {
            pAddress->setDirectory(entry);
          }
          entry->setAddress(pAddress);
        }
        return StatusCode::SUCCESS;
      }
      entry = dynamic_cast<RegistryEntry*>(pObj->directory());
      if ( 0 != entry )   {   // We are storing the object to the persistent storage
        if ( 0 != pAddress && !entry->isSoft() )    {
          pAddress->setDirectory(entry);
        }
        entry->setAddress(pAddress);
        entry->setObject(pObj);
        return StatusCode::SUCCESS;
      }
    }
    catch (...)   {
    }
  }
  return INVALID_OBJECT;
}

StatusCode DataSvc::addPreLoadItem(const DataStoreItem& item)    {
  LoadItems::iterator i = std::find(m_preLoads.begin(), m_preLoads.end(), item);
  if ( i == m_preLoads.end() )    {
    m_preLoads.push_back(item);
  }
  return StatusCode::SUCCESS;
}

StatusCode DataSvc::addPreLoadItem(const std::string& itemPath)    {
  return addPreLoadItem( DataStoreItem(itemPath,1) );
}

StatusCode DataSvc::removePreLoadItem(const DataStoreItem& item)   {
  LoadItems::iterator i = std::remove(m_preLoads.begin(), m_preLoads.end(), item);
  if ( i != m_preLoads.end() )  {
    m_preLoads.erase(i, m_preLoads.end());
  }
  return StatusCode::SUCCESS;
}

StatusCode DataSvc::removePreLoadItem(const std::string& itemPath)    {
  return removePreLoadItem( DataStoreItem(itemPath,1) );
}

StatusCode DataSvc::resetPreLoad()    {
  m_preLoads.erase(m_preLoads.begin(), m_preLoads.end());
  return StatusCode::SUCCESS;
}

StatusCode DataSvc::preLoad(int depth, int load_depth, DataObject* pObject)    {
  //unused:  StatusCode sc = StatusCode::FAILURE;
  if ( 0 != pObject && depth++ < load_depth )    {
    IDataDirectory* dir = pObject->directory();
    if ( 0 != dir )   {
      for (IDataDirectory::DirIterator i = dir->begin(); i != dir->end(); i++ )    {
        DataObject *pObj = 0;
        StatusCode status = retrieveObject(pObject, (*i)->name(), pObj);
        if ( status.isSuccess() && depth < load_depth )   {
          status = preLoad(depth, load_depth, pObj);
        }
      }
    }
  }
  return StatusCode::SUCCESS;
}

StatusCode DataSvc::preLoad()   {
  DataObject* pObj = 0;
  for ( LoadItems::iterator i = m_preLoads.begin(); i != m_preLoads.end(); i++ )    {
    StatusCode sc = retrieveObject( (*i).path(), pObj);
    int load_depth = (*i).depth();
    if ( sc.isSuccess() && load_depth > 1 )   {
      sc = preLoad(1, load_depth, pObj);
    }
  }
  return StatusCode::SUCCESS;
}

StatusCode DataSvc::queryInterface(const IID& riid, void** ppvInterface)  {
  if ( IID_IDataProviderSvc.versionMatch(riid) )  {
    *ppvInterface = (IDataProviderSvc*)this;
  }
  else if ( IID_IDataManagerSvc.versionMatch(riid) )   {
    *ppvInterface = (IDataManagerSvc*)this;
  }
  else  {
    return Service::queryInterface(riid, ppvInterface);
  }
  addRef();
  return SUCCESS;
}

StatusCode DataSvc::initialize()    {
  // Nothing to do: just call base class initialisation
  return Service::initialize();
}

StatusCode DataSvc::finalize()    {
  // Nothing to do: just call base class initialisation
  setDataLoader(0);
  resetPreLoad();
  clearStore();
  return Service::finalize();
}

CLID DataSvc::rootEventCLID() const {
  return( (CLID)m_rootEventCLID );
}

std::string DataSvc::rootEventName() const {
  return( m_rootEventName );
}

DataSvc::DataSvc(const std::string& name,ISvcLocator* svc)
: Service(name,svc), m_root(0,0), m_rootEventCLID(CLID_Event),
  m_rootEventName( "/Event")
{
  m_dataLoader = 0;
  m_root.setDataSvc(this);
  declareProperty("RootEventCLID", m_rootEventCLID);
  declareProperty("RootEventName", m_rootEventName = "/Event");
}

DataSvc::~DataSvc()  {
  setDataLoader(0);
  resetPreLoad();
  clearStore();
}

---