columnar::ColumnVectorData Class Reference

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

#include <ColumnVectorWrapper.h>

Collaboration diagram for columnar::ColumnVectorData:

Public Member Functions
	ColumnVectorData (const ColumnVectorHeader *val_header)
	standard constructor
template<typename CT>
void	setColumn (std::size_t columnIndex, std::size_t size, CT *dataPtr)
	set the data for the given column
void	setColumnVoid (std::size_t columnIndex, std::size_t size, const void *dataPtr, const std::type_info &type, bool isConst)
template<typename CT>
std::pair< std::size_t, CT * >	getColumn (std::size_t columnIndex)
	get the data for the given column
std::pair< std::size_t, const void * >	getColumnVoid (std::size_t columnIndex, const std::type_info *type, bool isConst)
void	checkData () const
	do a basic check of the data vector
void	callNoCheck (const IColumnarTool &tool)
	call the tool with the assembled data, without performing any checks on the data

Private Attributes
const ColumnVectorHeader *	m_header = nullptr
std::vector< void * >	m_data
std::vector< std::size_t >	m_dataSize

Detailed Description

a class that holds the columnar data for a single call

This manages the data pointer and makes sure the data is set and retrieved in a consistent manner to the header information.

Definition at line 157 of file ColumnVectorWrapper.h.

Constructor & Destructor Documentation

ColumnVectorData()

columnar::ColumnVectorData::ColumnVectorData ( const ColumnVectorHeader * val_header )

explicit

standard constructor

Public Members

Definition at line 196 of file ColumnVectorWrapper.cxx.

    : m_header (val_header),
      m_data (val_header->numColumns(), nullptr),
      m_dataSize (val_header->numColumns(), 0u)
  {
    setColumn (ColumnVectorHeader::sizeIndex, m_dataSize.size(), m_dataSize.data());
  }

Member Function Documentation

callNoCheck()

void columnar::ColumnVectorData::callNoCheck

(

const IColumnarTool &

tool

)

call the tool with the assembled data, without performing any checks on the data

Definition at line 260 of file ColumnVectorWrapper.cxx.

  {
    tool.callVoid (m_data.data());
  }

checkData()

void columnar::ColumnVectorData::checkData ( ) const

inline

do a basic check of the data vector

Definition at line 192 of file ColumnVectorWrapper.h.

                            {
      m_header->checkData (m_data);
    }

getColumn()

template<typename CT>

std::pair< std::size_t, CT * > columnar::ColumnVectorData::getColumn ( std::size_t columnIndex )

inlinenodiscard

get the data for the given column

Definition at line 179 of file ColumnVectorWrapper.h.

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

getColumnVoid()

std::pair< std::size_t, const void * > columnar::ColumnVectorData::getColumnVoid ( std::size_t columnIndex, const std::type_info * type, bool isConst )

nodiscard

Definition at line 241 of file ColumnVectorWrapper.cxx.

  {
    if (columnIndex >= m_header->numColumns())
      throw std::runtime_error ("invalid column index: " + std::to_string(columnIndex) + " (max is " + std::to_string(m_header->numColumns()-1) + ")");
 
    auto& header = m_header->getColumn (columnIndex);
    if (*type != *header.type)
      throw std::runtime_error ("invalid type for column: " + header.debugName);
    if (!isConst && header.readOnly)
      throw std::runtime_error ("retrieving non-const vector from a read-only column: " + header.debugName);
    if (m_data[columnIndex] != nullptr)
      return std::make_pair (m_dataSize[columnIndex], m_data[columnIndex]);
    else
      return std::make_pair (0u, nullptr);
  }

setColumn()

template<typename CT>

void columnar::ColumnVectorData::setColumn ( std::size_t columnIndex, std::size_t size, CT * dataPtr )

inline

set the data for the given column

Definition at line 169 of file ColumnVectorWrapper.h.

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

setColumnVoid()

void columnar::ColumnVectorData::setColumnVoid	(	std::size_t	columnIndex,
		std::size_t	size,
		const void *	dataPtr,
		const std::type_info &	type,
		bool	isConst )

Definition at line 207 of file ColumnVectorWrapper.cxx.

  {
    if (columnIndex == ColumnVectorHeader::nullIndex)
      throw std::logic_error ("cannot set the null column");
    if (columnIndex >= m_header->numColumns())
      throw std::logic_error ("invalid column index: " + std::to_string(columnIndex) + " (max is " + std::to_string(m_header->numColumns()-1) + ")");
    auto& header = m_header->getColumn (columnIndex);
 
    // If dataPtr is null, we use a dummy value to avoid issues in which
    // we check whether a column exists by checking for a null pointer,
    // which would return false for columns that were set with a
    // nullptr.
    if (dataPtr == nullptr)
    {
      if (size != 0) [[unlikely]]
        throw std::logic_error ("dataPtr is null but size is not zero for column: " + header.debugName);
      static const unsigned dummyValue = 0;
      dataPtr = &dummyValue;
    }
 
    if (type != *header.type)
      throw std::runtime_error ("invalid type for column: " + header.debugName);
    if (isConst && !header.readOnly)
      throw std::runtime_error ("assigning const vector to a column that is not read-only: " + header.debugName);
    if (m_data[columnIndex] != nullptr)
      throw std::runtime_error ("column filled multiple times: " + header.debugName);
    auto *castDataPtr ATLAS_THREAD_SAFE = const_cast<void*>(dataPtr);
    m_data[columnIndex] = castDataPtr;
    m_dataSize[columnIndex] = size;
  }

Member Data Documentation

m_data

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

private

Definition at line 206 of file ColumnVectorWrapper.h.

m_dataSize

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

private

Definition at line 207 of file ColumnVectorWrapper.h.

m_header

const ColumnVectorHeader* columnar::ColumnVectorData::m_header = nullptr

private

Private Members

Definition at line 205 of file ColumnVectorWrapper.h.

---

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

• ColumnVectorWrapper.h
• ColumnVectorWrapper.cxx