columnar::TestUtils::ManualColumnData Class Reference

a class that holds manually specified column data More...

#include <ManualColumnData.h>

Collaboration diagram for columnar::TestUtils::ManualColumnData:

Public Member Functions
	ManualColumnData (std::vector< std::any > &&data)
	standard constructor
void	configureType (const std::string &columnName, const std::type_info &type)
	configure for the given type
const std::type_info *	type () const noexcept
	get the type we are configured for
template<typename T>
std::span< const T >	getSpan (const std::string &name) const
	get the configured column as an std::span
std::size_t	columnSize () const noexcept
	get the size of the column
void *	columnVoidData () noexcept
	get the data pointer for the column

Private Attributes
std::vector< std::any >	m_data
	a vector of untyped data provided by the user
const std::type_info *	m_type = nullptr
	the actual type for the column
std::shared_ptr< void >	m_column
	the column created from m_data

Detailed Description

a class that holds manually specified column data

This is for use in unit test code to allow users specifying a column as a simple list of values, e.g.

columnMap.addColumn ({1.0f, 2, 3u});

Internally this represents the user data as a vector of std::any, and then converts it to the appropriate type when asked. This is not particularly efficient, but it is only meant for use in unit tests, where ease of use is more important than efficiency.

Definition at line 38 of file ManualColumnData.h.

Constructor & Destructor Documentation

ManualColumnData()

columnar::TestUtils::ManualColumnData::ManualColumnData

(

std::vector< std::any > &&

data

)

standard constructor

Public Members

Definition at line 63 of file ManualColumnData.cxx.

      : m_data (std::move (data))
    {
    }

Member Function Documentation

columnSize()

std::size_t columnar::TestUtils::ManualColumnData::columnSize ( ) const

inlinenodiscardnoexcept

get the size of the column

Definition at line 67 of file ManualColumnData.h.

                                                           {
        return m_data.size(); }

columnVoidData()

void * columnar::TestUtils::ManualColumnData::columnVoidData ( )

inlinenodiscardnoexcept

get the data pointer for the column

Definition at line 71 of file ManualColumnData.h.

                                                    {
        return m_column.get(); }

configureType()

void columnar::TestUtils::ManualColumnData::configureType	(	const std::string &	columnName,
		const std::type_info &	type )

configure for the given type

Definition at line 71 of file ManualColumnData.cxx.

    {
      // I could check whether the type matches an already configured
      // type, but by not doing so I allow the user to reset the column
      // data if it got overwritten by the tool.
 
      if (type == typeid(float))
      {
        m_column = castGetAnyColumn<float> (columnName, m_data);
      } else if (type == typeid(char))
      {
        m_column = castGetAnyColumn<char> (columnName, m_data);
      } else if (type == typeid(int))
      {
        m_column = castGetAnyColumn<int> (columnName, m_data);
      } else if (type == typeid(std::uint8_t))
      {
        m_column = castGetAnyColumn<std::uint8_t> (columnName, m_data);
      } else if (type == typeid(std::uint16_t))
      {
        m_column = castGetAnyColumn<std::uint16_t> (columnName, m_data);
      } else if (type == typeid(std::uint32_t))
      {
        m_column = castGetAnyColumn<std::uint32_t> (columnName, m_data);
      } else if (type == typeid(std::uint64_t))
      {
        m_column = castGetAnyColumn<std::uint64_t> (columnName, m_data);
      } else
        throw std::runtime_error (
          columnName + ": column has unsupported type " +
          boost::core::demangle(type.name()) +
          ", extend test handler to support it");
      m_type = &type;
    }

getSpan()

template<typename T>

std::span< const T > columnar::TestUtils::ManualColumnData::getSpan ( const std::string & name ) const

inlinenodiscard

get the configured column as an std::span

Definition at line 57 of file ManualColumnData.h.

      {
        if (m_type == nullptr)
          throw std::runtime_error ("column " + name + " not configured");
        if (*m_type != typeid(T))
          throw std::runtime_error ("column " + name + " has wrong type: " + boost::core::demangle(m_type->name()) + " != " + boost::core::demangle(typeid(T).name()));
        return std::span<const T> (static_cast<const T*> (m_column.get()), m_data.size());
      }

type()

const std::type_info * columnar::TestUtils::ManualColumnData::type ( ) const

inlinenodiscardnoexcept

get the type we are configured for

Definition at line 52 of file ManualColumnData.h.

                                                              {
        return m_type; }

Member Data Documentation

m_column

std::shared_ptr<void> columnar::TestUtils::ManualColumnData::m_column

private

the column created from m_data

Definition at line 87 of file ManualColumnData.h.

m_data

std::vector<std::any> columnar::TestUtils::ManualColumnData::m_data

private

a vector of untyped data provided by the user

Private Members

Definition at line 81 of file ManualColumnData.h.

m_type

const std::type_info* columnar::TestUtils::ManualColumnData::m_type = nullptr

private

the actual type for the column

Definition at line 84 of file ManualColumnData.h.

---

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

• ManualColumnData.h
• ManualColumnData.cxx