columnar::TestUtils::ColumnarTestToolHandle Class Reference

a handle to a columnar tool for running tests More...

#include <ColumnarMemoryTest.h>

Collaboration diagram for columnar::TestUtils::ColumnarTestToolHandle:

Public Member Functions
	ColumnarTestToolHandle (asg::AsgTool &val_tool)
void	renameContainers (const std::vector< std::pair< std::string, std::string > > &renames)
	rename the columns the tool uses
void	initialize ()
	initialize the tool
void	applySystematicVariation (const std::string &sysName)
	set the tool to apply the given systematic variation
std::vector< ColumnInfo >	getColumnInfo () const
	get the expected column info
std::vector< std::string >	getColumnNames () const
	get the expected column names
std::vector< std::string >	getRecommendedSystematics () const
	get the recommended systematics
ToolColumnVectorMap &	getToolWrapper ()
	get the tool wrapper
const ToolColumnVectorMap &	getToolWrapper () const
const ColumnVectorHeader &	getColumnHeader () const
	get the column header
IColumnarTool *	getTool ()
	get the contained tool

Private Attributes
IColumnarTool *	m_tool = nullptr
CP::ISystematicsTool *	m_systTool = nullptr
std::shared_ptr< ColumnVectorHeader >	m_columnHeader
std::shared_ptr< ToolColumnVectorMap >	m_toolWrapper

Detailed Description

a handle to a columnar tool for running tests

This used to be shared with the python bindings, but there are sufficient differences between testing and python bindings to split the two.

Definition at line 54 of file ColumnarMemoryTest.h.

Constructor & Destructor Documentation

ColumnarTestToolHandle()

columnar::TestUtils::ColumnarTestToolHandle::ColumnarTestToolHandle ( asg::AsgTool & val_tool )

explicit

Public Members

Definition at line 51 of file ColumnarMemoryTest.cxx.

    {
      m_tool = dynamic_cast<IColumnarTool*> (&val_tool);
      if (m_tool == nullptr)
        throw std::runtime_error ("tool does not implement IColumnarTool");
      m_systTool = dynamic_cast<CP::ISystematicsTool*> (m_tool);
    }

Member Function Documentation

applySystematicVariation()

void columnar::TestUtils::ColumnarTestToolHandle::applySystematicVariation

(

const std::string &

sysName

)

set the tool to apply the given systematic variation

Definition at line 84 of file ColumnarMemoryTest.cxx.

    {
      // by convention setting a systematic on a non-systematics tool
      // will do nothing
      if (m_systTool == nullptr)
        return;
      if (!m_systTool->applySystematicVariation (CP::SystematicSet (sysName)).isSuccess())
        throw std::runtime_error ("failed to apply systematic variation");
    }

getColumnHeader()

const ColumnVectorHeader & columnar::TestUtils::ColumnarTestToolHandle::getColumnHeader ( ) const

inlinenodiscard

get the column header

Definition at line 86 of file ColumnarMemoryTest.h.

                                                                       {
        return *m_columnHeader;}

getColumnInfo()

std::vector< ColumnInfo > columnar::TestUtils::ColumnarTestToolHandle::getColumnInfo ( ) const

nodiscard

get the expected column info

Definition at line 97 of file ColumnarMemoryTest.cxx.

    {
      if (!m_toolWrapper)
        throw std::runtime_error ("tool not initialized");
      return m_tool->getColumnInfo ();
    }

getColumnNames()

std::vector< std::string > columnar::TestUtils::ColumnarTestToolHandle::getColumnNames

(

)

const

get the expected column names

Definition at line 107 of file ColumnarMemoryTest.cxx.

    {
      if (!m_toolWrapper)
        throw std::runtime_error ("tool not initialized");
      return m_toolWrapper->getColumnNames ();
    }

getRecommendedSystematics()

std::vector< std::string > columnar::TestUtils::ColumnarTestToolHandle::getRecommendedSystematics

(

)

const

get the recommended systematics

Definition at line 117 of file ColumnarMemoryTest.cxx.

    {
      if (!m_systTool)
        return {""};
      std::vector<std::string> result;
      for (auto& sys : CP::make_systematics_vector (m_systTool->recommendedSystematics()))
        result.push_back (sys.name());
      return result;
    }

getTool()

IColumnarTool * columnar::TestUtils::ColumnarTestToolHandle::getTool ( )

nodiscard

get the contained tool

Definition at line 150 of file ColumnarMemoryTest.cxx.

    {
      return m_tool;
    }

getToolWrapper() [1/2]

ToolColumnVectorMap & columnar::TestUtils::ColumnarTestToolHandle::getToolWrapper ( )

nodiscard

get the tool wrapper

Definition at line 130 of file ColumnarMemoryTest.cxx.

    {
      if (!m_toolWrapper)
        throw std::runtime_error ("tool not initialized");
      return *m_toolWrapper;
    }

getToolWrapper() [2/2]

const ToolColumnVectorMap & columnar::TestUtils::ColumnarTestToolHandle::getToolWrapper ( ) const

nodiscard

Definition at line 140 of file ColumnarMemoryTest.cxx.

    {
      if (!m_toolWrapper)
        throw std::runtime_error ("tool not initialized");
      return *m_toolWrapper;
    }

initialize()

void columnar::TestUtils::ColumnarTestToolHandle::initialize

(

)

initialize the tool

Definition at line 75 of file ColumnarMemoryTest.cxx.

    {
      m_columnHeader = std::make_shared<ColumnVectorHeader> ();
      m_toolWrapper = std::make_shared<ToolColumnVectorMap> (*m_columnHeader, *m_tool);
    }

renameContainers()

void columnar::TestUtils::ColumnarTestToolHandle::renameContainers

(

const std::vector< std::pair< std::string, std::string > > &

renames

)

rename the columns the tool uses

Definition at line 62 of file ColumnarMemoryTest.cxx.

    {
      columnar::renameContainers (*m_tool, renames);
      if (m_toolWrapper)
      {
        m_columnHeader = std::make_shared<ColumnVectorHeader> ();
        m_toolWrapper = std::make_shared<ToolColumnVectorMap> (*m_columnHeader, *m_tool);
      }
    }

Member Data Documentation

m_columnHeader

std::shared_ptr<ColumnVectorHeader> columnar::TestUtils::ColumnarTestToolHandle::m_columnHeader

private

Definition at line 102 of file ColumnarMemoryTest.h.

m_systTool

CP::ISystematicsTool* columnar::TestUtils::ColumnarTestToolHandle::m_systTool = nullptr

private

Definition at line 100 of file ColumnarMemoryTest.h.

m_tool

IColumnarTool* columnar::TestUtils::ColumnarTestToolHandle::m_tool = nullptr

private

Private Members

Definition at line 99 of file ColumnarMemoryTest.h.

m_toolWrapper

std::shared_ptr<ToolColumnVectorMap> columnar::TestUtils::ColumnarTestToolHandle::m_toolWrapper

private

Definition at line 103 of file ColumnarMemoryTest.h.

---

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

• ColumnarMemoryTest.h
• ColumnarMemoryTest.cxx