ColumnarToolWrapper.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
 
 
#ifndef COLUMNAR_PYTHON_WRAPPER_PYTHON_TOOL_WRAPPER_H
#define COLUMNAR_PYTHON_WRAPPER_PYTHON_TOOL_WRAPPER_H
 
#include <memory>
#include <string>
#include <typeinfo>
#include <unordered_map>
#include <vector>
 
namespace columnar
{
  struct ColumnInfo;
  class IColumnarTool;
 
 
 
  class ColumnarToolWrapper final
  {
 
  public:
 
    explicit ColumnarToolWrapper (IColumnarTool *val_tool);
 
    explicit ColumnarToolWrapper (std::shared_ptr<IColumnarTool> val_tool);
 
 
    // copying would need special handling, so disabling it until needed
    ColumnarToolWrapper (const ColumnarToolWrapper&) = delete;
    ColumnarToolWrapper& operator= (const ColumnarToolWrapper&) = delete;
 
 
      [[nodiscard]] std::vector<std::string> getColumnNames () const;
      [[nodiscard]] std::vector<ColumnInfo> getColumnInfo () const;
  
 
 
 
  private:
 
    // These two classes work closely together, but for new users it
    // seemed clearer to make it a friend instead of a nested class.
    friend class ColumnarToolWrapperData;
 
 
    const IColumnarTool *m_tool = nullptr;
 
    std::shared_ptr<const IColumnarTool> m_toolOwn;
 
 
    struct MyColumnInfo
    {
      const std::type_info *type = nullptr;
 
      bool isConst = false;
 
      unsigned index = 0u;
 
      unsigned fixedDimensions = 1u;
 
      bool isOffset = false;
 
      bool isOptional = false;
 
      int numpyType = -1;
 
      unsigned numpyBits = 0u;
 
      const std::pair<const std::string,MyColumnInfo> *offsets = nullptr;
    };
    std::unordered_map<std::string,MyColumnInfo> m_columns;
 
 
    unsigned m_numColumns = 0u;
  };
 
 
 
 
  class ColumnarToolWrapperData
  {
 
  public:
 
    explicit ColumnarToolWrapperData (const ColumnarToolWrapper *val_wrapper) noexcept;
 
 
    template<typename CT>
    void setColumn (const std::string& name, std::size_t size, CT* dataPtr) {
      auto voidPtr = reinterpret_cast<const void*>(const_cast<const CT*>(dataPtr));
      setColumnVoid (name, size, voidPtr, typeid (std::decay_t<CT>), std::is_const_v<CT>);
    }
 
 
    void setColumnVoid (const std::string& name, std::size_t size, const void *dataPtr, const std::type_info& type, bool isConst);
 
 
    void setColumnNumpy (const std::string& name, std::size_t size, const void *dataPtr, int type, unsigned bits, bool isConst);
 
 
    void call ();
 
 
 
 
  public:
 
 
    void checkColumnsValid ();
 
 
    template<typename CT>
    [[nodiscard]] std::pair<std::size_t,CT*>
    getColumn (const std::string& name)
    {
      auto [size, ptr] = getColumnVoid (name, &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 (const std::string& name, const std::type_info *type, bool isConst);
 
    [[nodiscard]] void** data () noexcept {
      return m_data.data();}
 
 
 
 
  private:
 
    const ColumnarToolWrapper *m_wrapper = nullptr;
 
    std::vector<void*> m_data;
    std::vector<std::size_t> m_dataSize;
    std::vector<bool> m_columnIsChecked;
    std::vector<bool> m_columnIsFilled;
 
    void checkColumn (const std::pair<const std::string,ColumnarToolWrapper::MyColumnInfo>& column);
  };
}
 
#endif