DataHandle.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_DATAHANDLE
#define GAUDIKERNEL_DATAHANDLE 1

#include "GaudiKernel/DataHandleConfigurable.h"
#include "GaudiKernel/DataObjID.h"
#include "GaudiKernel/Property.h"
#include <string>
#include <type_traits>

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

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

class IDataHandleHolder;

namespace Gaudi
{

  inline namespace v1
  {
    class DataHandle
    {
    public:
      enum Mode { Reader = 1 << 2, Writer = 1 << 4, Updater = Reader | Writer };

      DataHandle( const DataObjID& k, Mode a = Reader, IDataHandleHolder* owner = nullptr )
          : m_key( k ), m_owner( owner ), m_mode( a ){};

      DataHandle( const DataObjID& k, const bool& isCond, Mode a = Reader, IDataHandleHolder* owner = nullptr )
          : m_key( k ), m_owner( owner ), m_mode( a ), m_isCond( isCond ){};

      virtual ~DataHandle() = default;

      virtual void setOwner( IDataHandleHolder* o ) { m_owner = o; }
      virtual IDataHandleHolder*                owner() const { return m_owner; }

      virtual Mode mode() const { return m_mode; }

      virtual void setKey( const DataObjID& key ) const { m_key = key; }
      virtual void updateKey( const std::string& key ) const { m_key.updateKey( key ); }

      virtual const std::string& objKey() const { return m_key.key(); }
      virtual const DataObjID&   fullKey() const { return m_key; }

      virtual void reset( bool ){};

      virtual std::string pythonRepr() const;
      virtual bool        init() { return true; }

      // is this a ConditionHandle?
      virtual bool isCondition() const { return m_isCond; }

    protected:
      mutable DataObjID  m_key   = {"NONE"};
      IDataHandleHolder* m_owner = nullptr;

    private:
      Mode m_mode   = Reader;
      bool m_isCond = false;
    };
  }

  namespace v2
  {
    class DataHandle
    {
    public:
      // DataHandles are used for the purpose of accounting component data
      // dependencies, and should thus never be copied.
      DataHandle( const DataHandle& ) = delete;
      DataHandle& operator=( const DataHandle& ) = delete;

      // DataHandles pass a pointer to themselves to the host Algorithm during
      // registration, which happens at construction time. They should thus
      // not be moved, as that would invalidate said pointer.
      //
      // The only reason why we don't delete the DataHandle move constructor
      // as well is that it would also forbid some safe and useful forms of
      // in-place construction.
      //
      // We will be able to plug this memory safety hole, and set this to
      // "= delete" the way it should be, once Gaudi switches to C++17-only and
      // guaranteed copy elision can be taken for granted.
      //
      DataHandle( DataHandle&& ) = default;
      DataHandle& operator=( DataHandle&& ) = delete;

      // Manner in which this DataHandle will be accessing its whiteboard
      using AccessMode = IDataHandleMetadata::AccessMode;
      AccessMode access() const { return m_property.metadata().access(); }

      const DataObjID& targetKey() const { return m_property.targetKey(); }

      void setTargetKey( const DataObjID& id ) { m_property.setTargetKey( id ); }

      virtual void initialize( const IDataHandleHolder& owner ) = 0;

      bool ownerSetupDone() const { return m_ownerSetupDone; }

      template <typename Owner, std::enable_if_t<std::is_base_of<IDataHandleHolder, Owner>::value>* = nullptr>
      void setOwner( Owner& owner )
      {
        if ( m_ownerSetupDone ) {
          throw std::runtime_error( "Attempted to set DataHandle owner twice" );
        }
        m_property.setOwner( &owner );
        m_ownerSetupDone = true;
      }

    protected:
      template <typename Owner, typename T                                          = DataObjID,
                std::enable_if_t<std::is_base_of<IDataHandleHolder, Owner>::value>* = nullptr>
      DataHandle( Owner& owner, const std::string& propertyName, T&& defaultID, const std::string& docString,
                  const IDataHandleMetadata& metadata )
          : m_property{&owner, propertyName, {metadata, std::forward<T>( defaultID )}, docString}
          , m_ownerSetupDone{true}
      {
      }

      template <typename T = DataObjID>
      explicit DataHandle( const std::string& propertyName, T&& defaultID, const std::string& docString,
                           const IDataHandleMetadata& metadata )
          : m_property{propertyName, {metadata, std::forward<T>( defaultID )}, docString}, m_ownerSetupDone{false}
      {
      }

    private:
      Gaudi::Property<DataHandleConfigurable> m_property;

      bool m_ownerSetupDone;
    };
  }
}

#endif