EventDataHandle.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_EVENTDATAHANDLE
#define GAUDIKERNEL_EVENTDATAHANDLE 1

#include "GaudiKernel/DataHandle.h"
#include "GaudiKernel/DataObjID.h"
#include "GaudiKernel/EventContext.h"
#include "GaudiKernel/HandleDetail.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include <memory>
#include <stdexcept>
#include <string>

//---------------------------------------------------------------------------

//---------------------------------------------------------------------------

class IDataHandleHolder;

namespace Gaudi
{
  class EventDataHandle : public Gaudi::v2::DataHandle
  {
  public:
    void initialize( const IDataHandleHolder& owner ) final override;

  protected:
    using AccessMode = DataHandle::AccessMode;

    class Metadata : public IDataHandleMetadata
    {
    public:
      // Initialize by specifying which access mode should be used
      Metadata( AccessMode access ) : m_access{access} {}

      // Identifier for the whiteboard implementation that we use
      std::string whiteBoard() const final override { return "IDataProviderSvc"; }

      // Tell what is the access mode
      AccessMode access() const final override { return m_access; }

    private:
      AccessMode m_access;
    };

    // Metadata singletons shared by all read and write handles
    static const Metadata s_readHandleMetadata;
    static const Metadata s_writeHandleMetadata;

    template <typename Owner>
    EventDataHandle( Owner& owner, const std::string& propertyName, DataObjID&& defaultID, const std::string& docString,
                     const Metadata& metadata )
        : DataHandle{owner, propertyName, std::move( defaultID ), docString, metadata}
    {
      registerToOwner( owner );
    }

    IDataProviderSvc* m_whiteBoard = nullptr;

  private:
    void registerToOwner( IDataHandleHolder& owner );
  };

  template <typename T>
  class EventReadHandle : public EventDataHandle
  {
  protected:
    using AccessMode = DataHandle::AccessMode;

  public:
    template <typename Owner>
    EventReadHandle( Owner* owner, const std::string& propertyName, DataObjID defaultID,
                     const std::string& docString = "" )
        : EventDataHandle{*owner, propertyName, std::move( defaultID ), docString, s_readHandleMetadata}
    {
    }

    decltype( auto ) get( const EventContext& /* ctx */ ) const
    {
      // TODO: Introduce and use an EventContext-aware whiteboard interface
      DataObject* ptr = nullptr;
      auto        sc  = m_whiteBoard->retrieveObject( targetKey().key(), ptr );
      if ( sc.isFailure() ) {
        throw std::runtime_error( "Failed to read input from whiteboard" );
      }
      return HandleDetail::unwrapDataObject<T>( *ptr );
    }
  };

  template <typename T>
  class EventWriteHandle : public EventDataHandle
  {
  protected:
    using AccessMode = DataHandle::AccessMode;

  public:
    template <typename Owner>
    EventWriteHandle( Owner* owner, const std::string& propertyName, DataObjID defaultID,
                      const std::string& docString = "" )
        : EventDataHandle{*owner, propertyName, std::move( defaultID ), docString, s_writeHandleMetadata}
    {
    }

    const T& put( const EventContext& ctx, T data ) const
    {
      auto ptrAndRef = HandleDetail::wrapDataObject<T>( std::move( data ) );
      putImpl( ctx, std::move( ptrAndRef.first ) );
      return ptrAndRef.second;
    }

    const T& put( const EventContext& ctx, std::unique_ptr<DataObject> ptr ) const
    {
      auto ptrAndRef = HandleDetail::wrapDataObject<T>( std::move( ptr ) );
      putImpl( ctx, std::move( ptrAndRef.first ) );
      return ptrAndRef.second;
    }

  private:
    void putImpl( const EventContext& /* ctx */, std::unique_ptr<DataObject>&& ptr ) const
    {
      // TODO: Introduce and use an EventContext-aware whiteboard interface
      auto sc = m_whiteBoard->registerObject( targetKey().key(), ptr.release() );
      if ( sc.isFailure() ) {
        throw std::runtime_error( "Failed to write output into whiteboard" );
      }
    }
  };
}

#endif