columnar::ToolColumnVectorMap Class Reference

a class that interfaces an IColumnarTool to a ColumnVectorHeader More...

#include <ToolColumnVectorMap.h>

Collaboration diagram for columnar::ToolColumnVectorMap:

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

Public Member Functions
	ToolColumnVectorMap (ColumnVectorHeader &val_columnHeader, IColumnarTool &val_tool)
	standard constructor
const IColumnarTool &	getTool () const
	get the wrapped tool
const ColumnVectorHeader &	getColumnHeader () const
	get the header information for the various columns needed
std::vector< std::string >	getColumnNames () const
	get the list of all defined columns
std::size_t	getColumnIndex (const std::string &name) const
	get the index for the column with the given name
template<typename CT>
void	setColumn (ColumnVectorData &columnData, const std::string &name, std::size_t size, CT *dataPtr) const
	set the data for the given column picking up the type via a template
void	setColumnVoid (ColumnVectorData &columnData, const std::string &name, std::size_t size, const void *dataPtr, const std::type_info &type, bool isConst) const
	set the data for the given column with the user passing in the type
template<typename CT>
std::pair< std::size_t, CT * >	getColumn (ColumnVectorData &columnData, const std::string &name) const
	get the data for the given column picking up the type via a template
std::pair< std::size_t, const void * >	getColumnVoid (ColumnVectorData &columnData, const std::string &name, const std::type_info *type, bool isConst) const
	get the data for the given column in a type-erased manner

Private Attributes
const IColumnarTool *	m_tool = nullptr
	the wrapped tool
ColumnVectorHeader *	m_columnHeader = nullptr
	the header information for the various columns needed
std::unordered_map< std::string, MyColumnInfo >	m_columns

Detailed Description

a class that interfaces an IColumnarTool to a ColumnVectorHeader

This takes care of registering all the columns needed by the tool, storing the name-index map, and setting the column indices in the tool.

This class does not try to take care of any tool management, or working with the ColumnVectorData. It does provide some helpers implemented using its own public interface, but this is just for convenience.

Definition at line 29 of file ToolColumnVectorMap.h.

Constructor & Destructor Documentation

ToolColumnVectorMap()

columnar::ToolColumnVectorMap::ToolColumnVectorMap ( ColumnVectorHeader & val_columnHeader, IColumnarTool & val_tool )

explicit

standard constructor

Public Members

This will extract the column information from the tool, configure all the columns for it, and set the proper column indices in the tool.

Definition at line 25 of file ToolColumnVectorMap.cxx.

    : m_tool (&val_tool), m_columnHeader (&val_columnHeader)
  {
    auto toolColumns = m_tool->getColumnInfo();
    for (auto& column : toolColumns)
    {
      const std::size_t columnIndex = m_columnHeader->addColumn (column);
 
      MyColumnInfo myinfo;
      myinfo.index = columnIndex;
      val_tool.setColumnIndex (column.name, 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);
    }
 
    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);
        m_columnHeader->setOffsetColumn (m_columns.at (column.name).index, offsetIter->second.index);
      }
    }
 
    // final consistency check
    m_columnHeader->checkSelf ();
  }

Member Function Documentation

getColumn()

template<typename CT>

std::pair< std::size_t, CT * > columnar::ToolColumnVectorMap::getColumn ( ColumnVectorData & columnData, const std::string & name ) const

inlinenodiscard

get the data for the given column picking up the type via a template

Definition at line 94 of file ToolColumnVectorMap.h.

                                                                          {
      return columnData.getColumn<CT> (getColumnIndex(name));
    }

getColumnHeader()

const ColumnVectorHeader & columnar::ToolColumnVectorMap::getColumnHeader ( ) const

inlinenodiscard

get the header information for the various columns needed

Definition at line 49 of file ToolColumnVectorMap.h.

                                                                     {
      return *m_columnHeader; }

getColumnIndex()

std::size_t columnar::ToolColumnVectorMap::getColumnIndex ( const std::string & name ) const

nodiscard

get the index for the column with the given name

This is mostly to share the lookup code, as well as the proper error handling.

Definition at line 72 of file ToolColumnVectorMap.cxx.

  {
    auto column = m_columns.find (name);
    if (column == m_columns.end())
      throw std::runtime_error ("trying to access unknown column " + name + " on tool");
    return column->second.index;
  }

getColumnNames()

std::vector< std::string > columnar::ToolColumnVectorMap::getColumnNames ( ) const

nodiscard

get the list of all defined columns

This is mostly to make it easy for the caller to know which columns are defined. For more complete information ask the tool directly for the vector of ColumnInfo.

Definition at line 60 of file ToolColumnVectorMap.cxx.

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

getColumnVoid()

std::pair< std::size_t, const void * > columnar::ToolColumnVectorMap::getColumnVoid ( ColumnVectorData & columnData, const std::string & name, const std::type_info * type, bool isConst ) const

inlinenodiscard

get the data for the given column in a type-erased manner

Definition at line 100 of file ToolColumnVectorMap.h.

                                                                                                                      {
      return columnData.getColumnVoid (getColumnIndex(name), type, isConst);
    }

getTool()

const IColumnarTool & columnar::ToolColumnVectorMap::getTool ( ) const

inlinenodiscard

get the wrapped tool

Definition at line 45 of file ToolColumnVectorMap.h.

                                                        {
      return *m_tool; }

setColumn()

template<typename CT>

void columnar::ToolColumnVectorMap::setColumn ( ColumnVectorData & columnData, const std::string & name, std::size_t size, CT * dataPtr ) const

inline

set the data for the given column picking up the type via a template

Forwarding MemberFunctions

These function are just forwarding to ColumnVectorHeader and ColumnVectorData. These are just here to make use easier and insulate the user from changes (Law of Demeter).

Definition at line 79 of file ToolColumnVectorMap.h.

                                                                                                            {
      columnData.setColumn (getColumnIndex(name), size, dataPtr);
    }

setColumnVoid()

void columnar::ToolColumnVectorMap::setColumnVoid ( ColumnVectorData & columnData, const std::string & name, std::size_t size, const void * dataPtr, const std::type_info & type, bool isConst ) const

inline

set the data for the given column with the user passing in the type

Definition at line 85 of file ToolColumnVectorMap.h.

                                                                                                                                                                {
      columnData.setColumnVoid (getColumnIndex(name), size, dataPtr, type, isConst);
    }

Member Data Documentation

m_columnHeader

ColumnVectorHeader* columnar::ToolColumnVectorMap::m_columnHeader = nullptr

private

the header information for the various columns needed

Definition at line 115 of file ToolColumnVectorMap.h.

m_columns

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

private

Definition at line 122 of file ToolColumnVectorMap.h.

m_tool

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

private

the wrapped tool

Private Members

Definition at line 112 of file ToolColumnVectorMap.h.

---

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

• ToolColumnVectorMap.h
• ToolColumnVectorMap.cxx