columnar::ColumnarToolWrapper Class Reference

a class that wraps an IColumnarTool for use in Python More...

#include <ColumnarToolWrapper.h>

Collaboration diagram for columnar::ColumnarToolWrapper:

Classes
struct	MyColumnInfo
	my cached information for the various columns needed More...

Public Member Functions
	ColumnarToolWrapper (IColumnarTool *val_tool)
	constructor: wrap the given tool (non-owning) More...
	ColumnarToolWrapper (std::shared_ptr< IColumnarTool > val_tool)
	constructor: wrap the given tool (owning) More...
	ColumnarToolWrapper (const ColumnarToolWrapper &)=delete
ColumnarToolWrapper &	operator= (const ColumnarToolWrapper &)=delete
std::vector< std::string >	getColumnNames () const
	get information on all defined columns More...
std::vector< ColumnInfo >	getColumnInfo () const

Private Attributes
const IColumnarTool *	m_tool = nullptr
	the wrapped tool More...
std::shared_ptr< const IColumnarTool >	m_toolOwn
	the owning pointer to the tool More...
std::unordered_map< std::string, MyColumnInfo >	m_columns
unsigned	m_numColumns = 0u
	the number of columns that the tool expects (equal to the greatest column index + 1) More...

Friends
class	ColumnarToolWrapperData

Detailed Description

a class that wraps an IColumnarTool for use in Python

This is not necessarily specific to python, but that is the primary use case. Essentially all it does is provide a way to preload columns by name, check that the columns are are consistent with what the tool expects, and can then call the tool on those columns.

This class only does the meta-data handling, whereas the actual handling of columnar data is done by ColumnarToolWrapperData. Please check its documentation for details.

Definition at line 35 of file ColumnarToolWrapper.h.

Constructor & Destructor Documentation

ColumnarToolWrapper() [1/3]

columnar::ColumnarToolWrapper::ColumnarToolWrapper ( IColumnarTool *  val_tool )

explicit

constructor: wrap the given tool (non-owning)

Public Members

Definition at line 28 of file ColumnarToolWrapper.cxx.

    : m_tool (val_tool)
  {
    constexpr unsigned numpySigned = 0;
    constexpr unsigned numpyUnsigned = 1;
    constexpr unsigned numpyFloat = 2;
    std::unordered_map<std::type_index, std::pair<int,unsigned>> numpyTypes;
    numpyTypes[typeid (float)] = { numpyFloat, sizeof (float) * 8 };
    numpyTypes[typeid (char)] = { std::is_signed_v<char> ? numpySigned : numpyUnsigned, sizeof (char) * 8 };
    numpyTypes[typeid (int)] = { numpySigned, sizeof (int) * 8 };
    numpyTypes[typeid (std::uint8_t)] = { numpyUnsigned, sizeof (std::uint8_t) * 8 };
    numpyTypes[typeid (std::uint16_t)] = { numpyUnsigned, sizeof (std::uint16_t) * 8 };
    numpyTypes[typeid (std::uint32_t)] = { numpyUnsigned, sizeof (std::uint32_t) * 8 };
    numpyTypes[typeid (std::uint64_t)] = { numpyUnsigned, sizeof (std::uint64_t) * 8 };
 
 
    auto toolColumns = m_tool->getColumnInfo();
    unsigned nextIndex = 1u;
    for (auto& column : toolColumns)
    {
      MyColumnInfo myinfo;
      myinfo.index = nextIndex++;
      val_tool->setColumnIndex (column.name, myinfo.index);
      myinfo.type = column.type;
      switch (column.accessMode)
      {
      case ColumnAccessMode::input:
        myinfo.isConst = true;
        break;
      case ColumnAccessMode::output:
        myinfo.isConst = false;
        break;
      case ColumnAccessMode::update:
        myinfo.isConst = false;
        break;
      }
      for (unsigned dim : column.fixedDimensions)
        myinfo.fixedDimensions *= dim;
      myinfo.isOffset = column.isOffset;
      myinfo.isOptional = column.isOptional;
 
      if (auto iter = numpyTypes.find (*column.type); iter != numpyTypes.end())
      {
        myinfo.numpyType = iter->second.first;
        myinfo.numpyBits = iter->second.second;
      }
      const auto infoIdx = myinfo.index;
      auto [iter, success] = m_columns.emplace (column.name, std::move (myinfo));
      if (!success)
        throw std::runtime_error ("column name already registered: " + column.name);
 
      if (m_numColumns <= infoIdx)
        m_numColumns = infoIdx + 1;
   }
 
    for (auto& column : toolColumns)
    {
      if (!column.offsetName.empty())
      {
        auto offsetIter = m_columns.find (column.offsetName);
        if (offsetIter == m_columns.end())
          throw std::runtime_error ("offset column name not found: " + column.offsetName);
        if (*offsetIter->second.type != typeid (ColumnarOffsetType))
          throw std::runtime_error ("offset column has wrong type: " + column.offsetName);
        if (!offsetIter->second.isOffset)
          throw std::runtime_error ("offset column is not registered as offset: " + column.offsetName);
        m_columns.at (column.name).offsets = &*offsetIter;
      }
    }
  }

ColumnarToolWrapper() [2/3]

columnar::ColumnarToolWrapper::ColumnarToolWrapper ( std::shared_ptr< IColumnarTool >  val_tool )

explicit

constructor: wrap the given tool (owning)

Definition at line 102 of file ColumnarToolWrapper.cxx.

    : ColumnarToolWrapper (val_tool.get())
  {
    m_toolOwn = std::move (val_tool);
  }

ColumnarToolWrapper() [3/3]

columnar::ColumnarToolWrapper::ColumnarToolWrapper ( const ColumnarToolWrapper &  )

delete

Member Function Documentation

getColumnInfo()

std::vector< ColumnInfo > columnar::ColumnarToolWrapper::getColumnInfo

(

)

const

Definition at line 261 of file ColumnarToolWrapper.cxx.

  {
    return m_tool->getColumnInfo();
  }

getColumnNames()

std::vector< std::string > columnar::ColumnarToolWrapper::getColumnNames

(

)

const

get information on all defined columns

This is mostly to make it easy for the caller to know which columns are defined and connect them to the dataframe automatically. You can ask either for the list of column names or the full ColumnInfo, depending on what you need.

Definition at line 249 of file ColumnarToolWrapper.cxx.

  {
    std::vector<std::string> result;
    for (auto& column : m_columns)
      result.push_back (column.first);
    std::sort (result.begin(), result.end());
    return result;
  }

operator=()

ColumnarToolWrapper& columnar::ColumnarToolWrapper::operator= ( const ColumnarToolWrapper &  )

delete

Friends And Related Function Documentation

ColumnarToolWrapperData

friend class ColumnarToolWrapperData

friend

Private Members

Definition at line 74 of file ColumnarToolWrapper.h.

Member Data Documentation

m_columns

std::unordered_map<std::string,MyColumnInfo> columnar::ColumnarToolWrapper::m_columns

private

Definition at line 105 of file ColumnarToolWrapper.h.

m_numColumns

unsigned columnar::ColumnarToolWrapper::m_numColumns = 0u

private

the number of columns that the tool expects (equal to the greatest column index + 1)

Definition at line 110 of file ColumnarToolWrapper.h.

m_tool

const IColumnarTool* columnar::ColumnarToolWrapper::m_tool = nullptr

private

the wrapped tool

Definition at line 78 of file ColumnarToolWrapper.h.

m_toolOwn

std::shared_ptr<const IColumnarTool> columnar::ColumnarToolWrapper::m_toolOwn

private

the owning pointer to the tool

Definition at line 81 of file ColumnarToolWrapper.h.

---

The documentation for this class was generated from the following files:

• ColumnarToolWrapper.h
• ColumnarToolWrapper.cxx