columnar::ColumnarToolWrapperData Class Reference

a class that holds the columnar data for a single call to ColumnarToolWrapper More...

#include <ColumnarToolWrapper.h>

Collaboration diagram for columnar::ColumnarToolWrapperData:

Public Member Functions
	ColumnarToolWrapperData (const ColumnarToolWrapper *val_wrapper) noexcept
	constructor: wrap the given tool More...
template<typename CT >
void	setColumn (const std::string &name, std::size_t size, CT *dataPtr)
	set the data for the given column picking up the type via a template More...
void	setColumnVoid (const std::string &name, std::size_t size, const void *dataPtr, const std::type_info &type, bool isConst)
	set the data for the given column with the user passing in the type More...
void	setColumnNumpy (const std::string &name, std::size_t size, const void *dataPtr, int type, unsigned bits, bool isConst)
	set the data for the given column with the user passing in the type information from numpy More...
void	call ()
	call the tool More...
void	checkColumnsValid ()
	check that all columns are valid More...
template<typename CT >
std::pair< std::size_t, CT * >	getColumn (const std::string &name)
	get the data for the given column picking up the type via a template More...
std::pair< std::size_t, const void * >	getColumnVoid (const std::string &name, const std::type_info *type, bool isConst)
	get the data for the given column in a type-erased manner More...
void **	data () noexcept
	the data vector we have assembled More...

Private Member Functions
void	checkColumn (const std::pair< const std::string, ColumnarToolWrapper::MyColumnInfo > &column)

Private Attributes
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

Detailed Description

a class that holds the columnar data for a single call to ColumnarToolWrapper

The idea is that this is a fairly lightweight class that can be instantiated once per call and contain all thread-local information (i.e. the pointers to the user data). For every use of this tool the caller should create a new instance of this class.

The basic usage is something like this:

ColumnarToolWrapper wrapper {...};
ColumnarToolWrapperData data {&wrapper};
std::span<const float> input1 = ...;
data.setColumn ("input1", input1.size(), input1.data());
std::span<float> output1 = ...;
data.setColumn ("output1", output1.size(), output1.data());
data.call ();

Definition at line 135 of file ColumnarToolWrapper.h.

Constructor & Destructor Documentation

ColumnarToolWrapperData()

columnar::ColumnarToolWrapperData::ColumnarToolWrapperData ( const ColumnarToolWrapper *  val_wrapper )

explicitnoexcept

constructor: wrap the given tool

Public Members

Definition at line 111 of file ColumnarToolWrapper.cxx.

    : m_wrapper (val_wrapper),
      m_data (m_wrapper->m_numColumns, nullptr),
      m_dataSize (m_wrapper->m_numColumns, 0u),
      m_columnIsChecked (m_wrapper->m_numColumns, false),
      m_columnIsFilled (m_wrapper->m_numColumns, false)
  {}

Member Function Documentation

call()

void columnar::ColumnarToolWrapperData::call

(

)

call the tool

Definition at line 197 of file ColumnarToolWrapper.cxx.

  {
    checkColumnsValid ();
    m_wrapper->m_tool->callVoid (m_data.data());
  }

checkColumn()

void columnar::ColumnarToolWrapperData::checkColumn ( const std::pair< const std::string, ColumnarToolWrapper::MyColumnInfo > &  column )

private

Definition at line 206 of file ColumnarToolWrapper.cxx.

  {
    if (m_columnIsChecked.at(column.second.index))
      return;
    if (!m_columnIsFilled.at(column.second.index))
    {
      if (!column.second.isOptional)
        throw std::runtime_error ("column not filled: " + column.first);
      m_columnIsChecked[column.second.index] = true;
      return;
    }
 
    ColumnarOffsetType expectedSize = 1u;
    if (column.second.offsets)
    {
      checkColumn (*column.second.offsets);
      if (m_data[column.second.offsets->second.index] == nullptr)
        throw std::runtime_error ("offset column not filled: " + column.second.offsets->first);
      const auto offsetIndex = column.second.offsets->second.index;
      auto *offsetsPtr = static_cast<const ColumnarOffsetType*>(m_data[offsetIndex]);
      expectedSize = offsetsPtr[m_dataSize[offsetIndex]-1];
    }
    expectedSize *= column.second.fixedDimensions;
 
    if (column.second.isOffset)
      expectedSize += 1u;
 
    if (m_dataSize[column.second.index] != expectedSize)
      throw std::runtime_error ("column size doesn't match expected size: " + column.first + ", found " + std::to_string (m_dataSize[column.second.index]) + " vs " + std::to_string (expectedSize));
 
    if (column.second.isOffset)
    {
      auto *dataPtr = static_cast<const ColumnarOffsetType*>(m_data[column.second.index]);
      if (dataPtr[0] != 0)
        throw std::runtime_error ("offset column doesn't start with 0: " + column.first);
    }
 
    m_columnIsChecked[column.second.index] = true;
  }

checkColumnsValid()

void columnar::ColumnarToolWrapperData::checkColumnsValid

(

)

check that all columns are valid

Testing/Validation Members

These members shouldn't be needed for regular users, but it can help in debugging issues with the tool or the wrapper.

Definition at line 188 of file ColumnarToolWrapper.cxx.

  {
    for (auto& column : m_wrapper->m_columns)
      checkColumn (column);
  }

data()

void** columnar::ColumnarToolWrapperData::data ( )

inlinenoexcept

the data vector we have assembled

Definition at line 201 of file ColumnarToolWrapper.h.

                                          {
      return m_data.data();}

getColumn()

template<typename CT >

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

inline

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

Definition at line 187 of file ColumnarToolWrapper.h.

    {
      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)));
    }

getColumnVoid()

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

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

Definition at line 168 of file ColumnarToolWrapper.cxx.

  {
    auto column = m_wrapper->m_columns.find (name);
    if (column == m_wrapper->m_columns.end())
      throw std::runtime_error ("unknown column name: " + name);
 
    if (*type != *column->second.type)
      throw std::runtime_error ("invalid type for column: " + name);
    if (!isConst && column->second.isConst)
      throw std::runtime_error ("retrieving non-const vector from a const column: " + name);
    if (m_data[column->second.index] != nullptr)
      return std::make_pair (m_dataSize[column->second.index],
                              m_data[column->second.index]);
    else
      return std::make_pair (0u, nullptr);
  }

setColumn()

template<typename CT >

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

inline

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

Definition at line 149 of file ColumnarToolWrapper.h.

                                                                        {
      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>);
    }

setColumnNumpy()

void columnar::ColumnarToolWrapperData::setColumnNumpy	(	const std::string &	name,
		std::size_t	size,
		const void *	dataPtr,
		int	type,
		unsigned	bits,
		bool	isConst
	)

set the data for the given column with the user passing in the type information from numpy

Definition at line 145 of file ColumnarToolWrapper.cxx.

  {
    auto column = m_wrapper->m_columns.find (name);
    if (column == m_wrapper->m_columns.end())
      throw std::runtime_error ("unknown column name: " + name);
 
    if (type != column->second.numpyType || bits != column->second.numpyBits)
      throw std::runtime_error ("invalid type for column: " + name + " (expected " + std::to_string (column->second.numpyType) + "/" + std::to_string (column->second.numpyBits) + " but got " + std::to_string (type) + "/" + std::to_string (bits) + ")");
    if (isConst && !column->second.isConst)
      throw std::runtime_error ("assigning const vector to a non-const column: " + name);
    if (column->second.index == 0)
      throw std::runtime_error ("column has no index assigned: " + name);
    if (m_columnIsFilled[column->second.index])
      throw std::runtime_error ("column filled multiple times: " + name);
    m_columnIsFilled[column->second.index] = true;
    auto *castDataPtr ATLAS_THREAD_SAFE = const_cast<void*>(dataPtr);
    m_data[column->second.index] = castDataPtr;
    m_dataSize[column->second.index] = size;
  }

setColumnVoid()

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

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

Definition at line 122 of file ColumnarToolWrapper.cxx.

  {
    auto column = m_wrapper->m_columns.find (name);
    if (column == m_wrapper->m_columns.end())
      throw std::runtime_error ("unknown column name: " + name);
 
    if (type != *column->second.type)
      throw std::runtime_error ("invalid type for column: " + name);
    if (isConst && !column->second.isConst)
      throw std::runtime_error ("assigning const vector to a non-const column: " + name);
    if (column->second.index == 0)
      throw std::runtime_error ("column has no index assigned: " + name);
    if (m_columnIsFilled[column->second.index])
      throw std::runtime_error ("column filled multiple times: " + name);
    m_columnIsFilled[column->second.index] = true;
    auto *castDataPtr ATLAS_THREAD_SAFE = const_cast<void*>(dataPtr);
    m_data[column->second.index] = castDataPtr;
    m_dataSize[column->second.index] = size;
  }

Member Data Documentation

m_columnIsChecked

std::vector<bool> columnar::ColumnarToolWrapperData::m_columnIsChecked

private

Definition at line 215 of file ColumnarToolWrapper.h.

m_columnIsFilled

std::vector<bool> columnar::ColumnarToolWrapperData::m_columnIsFilled

private

Definition at line 216 of file ColumnarToolWrapper.h.

m_data

std::vector<void*> columnar::ColumnarToolWrapperData::m_data

private

Definition at line 213 of file ColumnarToolWrapper.h.

m_dataSize

std::vector<std::size_t> columnar::ColumnarToolWrapperData::m_dataSize

private

Definition at line 214 of file ColumnarToolWrapper.h.

m_wrapper

const ColumnarToolWrapper* columnar::ColumnarToolWrapperData::m_wrapper = nullptr

private

Private Members

Definition at line 211 of file ColumnarToolWrapper.h.

---

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

• ColumnarToolWrapper.h
• ColumnarToolWrapper.cxx