ColumnVectorWrapper.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/

 
 
#ifndef COLUMNAR_TOOL_WRAPPER_COLUMN_VECTOR_WRAPPER_H
#define COLUMNAR_TOOL_WRAPPER_COLUMN_VECTOR_WRAPPER_H
 
#include <ColumnarInterfaces/ColumnInfo.h>
 
#include <span>
#include <string>
#include <typeinfo>
#include <unordered_map>
#include <vector>
 
namespace columnar
{
  class IColumnarTool;
 

 
  struct ColumnVectorElementHeader final
  {
    std::string debugName;
 

    const std::type_info *type = nullptr;
 

    bool isOptional = true;
 

    bool readOnly = true;
 

    bool isOffset = false;
 

    unsigned arraySize = 1u;
 

    std::size_t offsetIndex = 0u;
 

    ColumnAccessMode accessMode = ColumnAccessMode::input;

    std::string offsetName;

    std::vector<std::string> linkTargetNames;

    std::string variantLinkKeyColumn;

    std::vector<unsigned> fixedDimensions;
  };
 
 

 
  class ColumnVectorHeader final
  {
  public:

    static constexpr std::size_t nullIndex = 0u;

    static constexpr std::size_t sizeIndex = 1u;

    static constexpr std::size_t unsetIndex = static_cast<std::size_t>(-1);

    static constexpr std::size_t numFixedColumns = 2u;

    ColumnVectorHeader ();
 

    [[nodiscard]] std::size_t addColumn (const ColumnInfo& columnInfo);

    void setOffsetColumn (std::size_t columnIndex, std::size_t offsetIndex);
 

    [[nodiscard]] std::size_t numColumns () const noexcept {
      return m_elements.size(); }

    [[nodiscard]] const ColumnVectorElementHeader&
    getColumn (std::size_t index) const {
      return m_elements.at (index); }

    [[nodiscard]] std::size_t
    getColumnIndex (const std::string& name) const noexcept {
      auto iter = m_nameToIndex.find(name);
      return (iter != m_nameToIndex.end()) ? iter->second : nullIndex; }

    [[nodiscard]] std::unordered_map<std::string, ColumnInfo> getAllColumnInfo() const;
 

    void checkSelf () const;

    void checkData (std::span<const void*const> data) const;
 

  private:

    std::vector<ColumnVectorElementHeader> m_elements;

    std::unordered_map<std::string, std::size_t> m_nameToIndex;
  };
 
 

 
  class ColumnVectorData final
  {
  public:

    explicit ColumnVectorData (const ColumnVectorHeader *val_header);
 

    template<typename CT>
    void setColumn (std::size_t columnIndex, std::size_t size, CT* dataPtr) {
      auto voidPtr = reinterpret_cast<const void*>(const_cast<const CT*>(dataPtr));
      setColumnVoid (columnIndex, size, voidPtr, typeid (std::decay_t<CT>), std::is_const_v<CT>);
    }
    void setColumnVoid (std::size_t columnIndex, std::size_t size, const void *dataPtr, const std::type_info& type, bool isConst);
 

    template<typename CT>
    [[nodiscard]] std::pair<std::size_t,CT*>
    getColumn (std::size_t columnIndex)
    {
      auto [size, ptr] = getColumnVoid (columnIndex, &typeid (std::decay_t<CT>), std::is_const_v<CT>);
      if constexpr (std::is_const_v<CT>)
        return std::make_pair (size, static_cast<CT*>(ptr));
      else
        return std::make_pair (size, static_cast<CT*>(const_cast<void*>(ptr)));
    }
    [[nodiscard]] std::pair<std::size_t,const void*>
    getColumnVoid (std::size_t columnIndex, const std::type_info *type, bool isConst);
 

    void checkData () const {
      m_header->checkData (m_data);
    }

    void callNoCheck (const IColumnarTool& tool);
 

  private:
 
    const ColumnVectorHeader *m_header = nullptr;
    std::vector<void*> m_data;
    std::vector<std::size_t> m_dataSize;
  };
}
 
#endif