IDataProviderSvc.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_IDATAPROVIDERSVC_H
#define GAUDIKERNEL_IDATAPROVIDERSVC_H

// Framework include files
#include "GaudiKernel/IInterface.h"

// C/C++ include files
#include "boost/utility/string_ref.hpp"
#include <string>

// Forward declarations
class IOpaqueAddress;
class IRegistry;
#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/DataStoreItem.h"

class GAUDI_API IDataProviderSvc : virtual public IInterface
{

  //  /// i.e. int -> "/" + int
  static inline std::string itemToPath( int item ) { return '/' + std::to_string( item ); }
public:
  DeclareInterfaceID( IDataProviderSvc, 4, 0 );

  enum { SEPARATOR = '/' };

  StatusCode registerObject( boost::string_ref fullPath, DataObject* pObject )
  {
    return registerObject( nullptr, fullPath, pObject );
  }

  virtual StatusCode registerObject( boost::string_ref parentPath, boost::string_ref objectPath,
                                     DataObject* pObject ) = 0;

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

  virtual StatusCode registerObject( DataObject* parentObj, boost::string_ref objectPath, DataObject* pObject ) = 0;

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

  virtual StatusCode unregisterObject( boost::string_ref fullPath ) = 0;

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

  StatusCode unregisterObject( boost::string_ref parentPath, int item )
  {
    return unregisterObject( parentPath, itemToPath( item ) );
  }

  virtual StatusCode unregisterObject( DataObject* pObject ) = 0;

  virtual StatusCode unregisterObject( DataObject* pParent, boost::string_ref objPath ) = 0;

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

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

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

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

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

  StatusCode retrieveObject( DataObject* parentObj, boost::string_ref 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, boost::string_ref path, DataObject*& pObject ) = 0;

  virtual StatusCode findObject( boost::string_ref fullPath, DataObject*& pObject ) = 0;

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

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

  StatusCode findObject( DataObject* parentObj, boost::string_ref 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( boost::string_ref 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( boost::string_ref parentPath, boost::string_ref updatePath )
  {
    DataObject* pParent = nullptr;
    StatusCode  status  = findObject( parentPath, pParent );
    return status.isSuccess() ? updateObject( pParent, updatePath ) : status;
  }

  StatusCode updateObject( DataObject* pParent, boost::string_ref 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, boost::string_ref objPath, DataObject* toObj ) = 0;

  StatusCode linkObject( boost::string_ref fromPath, boost::string_ref 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, boost::string_ref objPath, DataObject* toObj );

  virtual StatusCode linkObject( boost::string_ref fullPath, DataObject* toObj ) = 0;

  virtual StatusCode unlinkObject( IRegistry* from, boost::string_ref objPath ) = 0;

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

  virtual StatusCode unlinkObject( DataObject* fromObj, boost::string_ref objPath ) = 0;

  virtual StatusCode unlinkObject( boost::string_ref 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, boost::string_ref objPath, DataObject* toObj )
{
  if ( fromObj ) {
    IRegistry* from_entry = fromObj->registry();
    if ( from_entry ) return linkObject( from_entry, objPath, toObj );
  }
  return Status::INVALID_PARENT;
}

#endif // GAUDIKERNEL_IDATAPROVIDERSVC_H