IDataProviderSvc.h

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.                                             *
\***********************************************************************************/
#pragma once
 
#include <GaudiKernel/DataObject.h>
#include <GaudiKernel/DataStoreItem.h>
#include <GaudiKernel/IInterface.h>
#include <string>
#include <string_view>
 
class IOpaqueAddress;
class IRegistry;

class GAUDI_API IDataProviderSvc : virtual public IInterface {

  static inline std::string itemToPath( int item ) { return '/' + std::to_string( item ); }
 
public:
  DeclareInterfaceID( IDataProviderSvc, 4, 0 );
 
  enum { SEPARATOR = '/' };

  StatusCode registerObject( std::string_view fullPath, DataObject* pObject ) {
    return registerObject( nullptr, fullPath, pObject );
  }

  virtual StatusCode registerObject( std::string_view parentPath, std::string_view objectPath,
                                     DataObject* pObject ) = 0;

  StatusCode registerObject( std::string_view parentPath, int item, DataObject* pObject ) {
    return registerObject( parentPath, itemToPath( item ), pObject );
  }

  virtual StatusCode registerObject( DataObject* parentObj, std::string_view objectPath, DataObject* pObject ) = 0;

  StatusCode registerObject( DataObject* parentObj, int item, DataObject* pObject ) {
    return registerObject( parentObj, itemToPath( item ), pObject );
  }

  virtual StatusCode unregisterObject( std::string_view fullPath ) = 0;

  StatusCode unregisterObject( std::string_view parentPath, std::string_view objPath ) {
    DataObject* pO     = nullptr;
    StatusCode  status = findObject( parentPath, pO );
    return status.isSuccess() ? unregisterObject( pO, objPath ) : status;
  }

  StatusCode unregisterObject( std::string_view parentPath, int item ) {
    return unregisterObject( parentPath, itemToPath( item ) );
  }

  virtual StatusCode unregisterObject( DataObject* pObject ) = 0;

  virtual StatusCode unregisterObject( DataObject* pParent, std::string_view objPath ) = 0;

  StatusCode unregisterObject( DataObject* pParent, int item ) {
    return unregisterObject( pParent, itemToPath( item ) );
  }

  virtual StatusCode retrieveObject( IRegistry* pDirectory, std::string_view path, DataObject*& pObject ) = 0;

  StatusCode retrieveObject( std::string_view fullPath, DataObject*& pObject ) {
    return retrieveObject( static_cast<IRegistry*>( nullptr ), fullPath, pObject );
  }

  StatusCode retrieveObject( std::string_view parentPath, std::string_view objectPath, DataObject*& pObject ) {
    DataObject* parent = nullptr;
    StatusCode  status = retrieveObject( parentPath, parent );
    return status.isSuccess() ? retrieveObject( parent, objectPath, pObject ) : status;
  }

  StatusCode retrieveObject( std::string_view parentPath, int item, DataObject*& pObject ) {
    return retrieveObject( parentPath, itemToPath( item ), pObject );
  }

  StatusCode retrieveObject( DataObject* parentObj, std::string_view objectPath, DataObject*& pObject ) {
    return retrieveObject( parentObj ? parentObj->registry() : nullptr, objectPath, pObject );
  }

  StatusCode retrieveObject( DataObject* parentObj, int item, DataObject*& pObject ) {
    return retrieveObject( parentObj, itemToPath( item ), pObject );
  }

  virtual StatusCode findObject( IRegistry* pDirectory, std::string_view path, DataObject*& pObject ) = 0;

  virtual StatusCode findObject( std::string_view fullPath, DataObject*& pObject ) = 0;

  StatusCode findObject( std::string_view parentPath, std::string_view objectPath, DataObject*& pObject ) {
    DataObject* parent = nullptr;
    StatusCode  status = findObject( parentPath, parent );
    return status.isSuccess() ? findObject( parent, objectPath, pObject ) : status;
  }

  StatusCode findObject( std::string_view parentPath, int item, DataObject*& pObject ) {
    return findObject( parentPath, itemToPath( item ), pObject );
  }

  StatusCode findObject( DataObject* parentObj, std::string_view objectPath, DataObject*& pObject ) {
    return findObject( parentObj ? parentObj->registry() : nullptr, objectPath, pObject );
  }

  StatusCode findObject( DataObject* parentObj, int item, DataObject*& pObject ) {
    return findObject( parentObj, itemToPath( item ), pObject );
  }

  virtual StatusCode updateObject( IRegistry* pDirectory ) = 0;

  StatusCode updateObject( std::string_view fullPath ) {
    DataObject* pO     = nullptr;
    StatusCode  status = findObject( fullPath, pO );
    return status.isSuccess() ? updateObject( pO ) : retrieveObject( fullPath, pO );
  }

  virtual StatusCode updateObject( DataObject* toUpdate ) = 0;

  StatusCode updateObject( std::string_view parentPath, std::string_view updatePath ) {
    DataObject* pParent = nullptr;
    StatusCode  status  = findObject( parentPath, pParent );
    return status.isSuccess() ? updateObject( pParent, updatePath ) : status;
  }

  StatusCode updateObject( DataObject* pParent, std::string_view updatePath ) {
    DataObject* pObject = nullptr;
    StatusCode  status  = findObject( pParent, updatePath, pObject );
    return status.isSuccess() ? updateObject( pObject ) : status;
  }

  virtual StatusCode addPreLoadItem( const DataStoreItem& item ) = 0;

  StatusCode addPreLoadItem( std::string itemPath ) {
    return addPreLoadItem( DataStoreItem( std::move( itemPath ), 1 ) );
  }

  virtual StatusCode removePreLoadItem( const DataStoreItem& item ) = 0;

  StatusCode removePreLoadItem( std::string itemPath ) {
    return removePreLoadItem( DataStoreItem( std::move( itemPath ), 1 ) );
  }

  virtual StatusCode resetPreLoad() = 0;

  virtual StatusCode preLoad() = 0;

  virtual StatusCode linkObject( IRegistry* from, std::string_view objPath, DataObject* toObj ) = 0;

  StatusCode linkObject( std::string_view fromPath, std::string_view objPath, DataObject* toObj ) {
    DataObject* pO     = nullptr;
    StatusCode  status = retrieveObject( fromPath, pO );
    return status.isSuccess() ? linkObject( pO->registry(), objPath, toObj ) : status;
  }

  inline StatusCode linkObject( DataObject* fromObj, std::string_view objPath, DataObject* toObj );

  virtual StatusCode linkObject( std::string_view fullPath, DataObject* toObj ) = 0;

  virtual StatusCode unlinkObject( IRegistry* from, std::string_view objPath ) = 0;

  StatusCode unlinkObject( std::string_view fromPath, std::string_view objPath ) {
    DataObject* pObject = nullptr;
    StatusCode  status  = findObject( fromPath, pObject );
    return status.isSuccess() ? unlinkObject( pObject->registry(), objPath ) : status;
  }

  virtual StatusCode unlinkObject( DataObject* fromObj, std::string_view objPath ) = 0;

  virtual StatusCode unlinkObject( std::string_view fullPath ) = 0;

  enum class Status : StatusCode::code_t {
    IDataProviderSvc_NO_ERROR = 1,
    DOUBL_OBJ_PATH,
    INVALID_OBJ_PATH,
    INVALID_ROOT,
    INVALID_OBJECT,
    INVALID_PARENT,
    OBJ_NOT_LOADED,
    NO_DATA_LOADER,
    INVALID_OBJ_ADDR,
    DIR_NOT_EMPTY,
    NO_MORE_LEVELS,
    NO_ACCESS,
    LAST
  };
};
 
STATUSCODE_ENUM_DECL( IDataProviderSvc::Status )
 
inline StatusCode IDataProviderSvc::linkObject( DataObject* fromObj, std::string_view objPath, DataObject* toObj ) {
  if ( fromObj ) {
    IRegistry* from_entry = fromObj->registry();
    if ( from_entry ) return linkObject( from_entry, objPath, toObj );
  }
  return Status::INVALID_PARENT;
}