DataHandle.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2026 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/DataHandleProperty.h>
#include <GaudiKernel/DataObjID.h>
#include <GaudiKernel/System.h>
 
#include <span>
#include <sstream>
#include <tuple>
#include <vector>
 
//---------------------------------------------------------------------------

 
//---------------------------------------------------------------------------
 
class IDataHandleHolder;
 
namespace Gaudi {
 
  class DataHandle {
  public:
    enum Mode { Reader = 1 << 2, Writer = 1 << 4 };
 
    DataHandle( DataObjID k, Mode a = Reader, IDataHandleHolder* owner = nullptr )
        : m_key( std::move( k ) ), m_owner( owner ), m_mode( a ) {}
 
    DataHandle( DataObjID k, bool isCond, Mode a = Reader, IDataHandleHolder* owner = nullptr )
        : m_key( std::move( k ) ), m_owner( owner ), m_mode( a ), m_isCond( isCond ) {}
 
    using PropertyType = DataHandleProperty;
 
    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( DataObjID key ) { m_key = std::move( key ); }
    virtual void updateKey( std::string key ) { m_key.updateKey( std::move( 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; }
 
    friend std::ostream& operator<<( std::ostream& str, const DataHandle& d );
 
  protected:
    DataObjID          m_key   = { "NONE" };
    IDataHandleHolder* m_owner = nullptr;
 
    static const std::string default_type;
 
  private:
    Mode m_mode   = Reader;
    bool m_isCond = false;
  };

  class DataHandleVectorBase {
  public:
    using PropertyType = DataHandleVectorProperty;
 
    virtual ~DataHandleVectorBase() = default;

    virtual void setKeys( std::span<const DataObjID> keys ) = 0;
    virtual const std::vector<DataObjID>& keys() const = 0;
    virtual DataHandle::Mode mode() const = 0;
    virtual std::string type() const = 0;

    std::string pythonPropertyClassName() const { return "DataHandleVector"; }
    std::string semantics() const;
    std::string pythonRepr() const;
  };

  template <template <typename> class Handle, typename T>
  class DataHandleVector : public DataHandleVectorBase {
  public:
    template <typename Owner>
    DataHandleVector( Owner* parent, std::string name, const std::vector<std::string>& keys, std::string doc = "" )
        : m_owner{ parent } {
      std::vector<DataObjID> ids;
      ids.reserve( keys.size() );
      for ( const auto& key : keys ) ids.emplace_back( key );
      setKeys( ids );
      auto p = parent->declareProperty( std::move( name ), *this, std::move( doc ) );
      p->template setOwnerType<Owner>();
    }

    template <typename Owner>
    DataHandleVector( Owner* parent, const std::pair<std::string, std::vector<std::string>>& keys )
        : DataHandleVector{ parent, keys.first, keys.second } {}

    template <typename Owner, typename Keys>
    DataHandleVector( std::tuple<Owner, Keys>&& keys ) : DataHandleVector{ std::get<0>( keys ), std::get<1>( keys ) } {}

    template <typename Owner, typename Name, typename Keys>
    DataHandleVector( std::tuple<Owner, Name, Keys>&& keys )
        : DataHandleVector{ std::get<0>( keys ), std::get<1>( keys ), std::get<2>( keys ) } {}

    void setKeys( std::span<const DataObjID> keys ) override {
      m_keys.assign( keys.begin(), keys.end() );
      m_handles.clear();
      m_handles.reserve( m_keys.size() );
      for ( const auto& key : m_keys ) m_handles.emplace_back( key, m_owner );
    }

    void clear() { setKeys( std::span<const DataObjID>{} ); }

    const std::vector<DataObjID>& keys() const override { return m_keys; }
    const std::vector<Handle<T>>& handles() const { return m_handles; }
    const DataObjID& at( std::size_t i ) const { return m_keys.at( i ); }
    auto size() const { return m_handles.size(); }

    DataHandle::Mode mode() const override { return Handle<T>::mode_v; }
    std::string type() const override { return System::typeinfoName( typeid( T ) ); }
 
  protected:
    IDataHandleHolder*     m_owner = nullptr;
    std::vector<DataObjID> m_keys;
    std::vector<Handle<T>> m_handles;
  };
 
  namespace Parsers {
    StatusCode parse( DataHandle&, std::string_view );
  }
  namespace Utils {
    GAUDI_API std::ostream& toStream( const DataHandle& v, std::ostream& o );
  }
} // namespace Gaudi