Collaboration diagram for columnar::TestUtils::LinkColumnVector:

Public Types
using	CM = ColumnarModeArray

Public Member Functions
	~LinkColumnVector () noexcept
std::vector< std::string >	connect (const ColumnInfo &columnInfo, const std::unordered_map< std::string, const std::vector< ColumnarOffsetType > * > &offsetColumns, const std::unordered_map< std::string, ColumnInfo > &requestedColumns)
void	clear ()
void	checkOffsets (unsigned eventIndex)
template<typename T>
void	addLink (const ElementLink< T > &element, unsigned eventIndex)
void	addEmptyLink ()
void	addSplitLink (std::size_t linkIndex, SG::sgkey_t linkKey, unsigned eventIndex)
std::size_t	size () const noexcept
const CM::LinkIndexType *	data () const noexcept
auto	begin () const noexcept
auto	end () const noexcept
const std::vector< typename CM::LinkKeyType > &	keysColumn (std::size_t index) const

Private Member Functions
void	addTarget (const std::string &name, const std::unordered_map< std::string, const std::vector< ColumnarOffsetType > * > &offsetColumns)

Private Attributes
std::vector< typename CM::LinkIndexType >	m_columnData
std::string	m_columnName
std::vector< std::string >	m_targetNames
std::vector< SG::sgkey_t >	m_targetKeys
std::vector< const std::vector< ColumnarOffsetType > * >	m_targetOffsetColumns
std::vector< std::vector< typename CM::LinkKeyType > >	m_keysColumns
std::unordered_map< SG::sgkey_t, std::unordered_set< std::size_t > >	m_unknownKeysAllowedTargets

Detailed Description

Definition at line 299 of file ColumnarPhysliteTest.cxx.

Member Typedef Documentation

◆ CM

using columnar::TestUtils::LinkColumnVector::CM = ColumnarModeArray

Public Members

Definition at line 305 of file ColumnarPhysliteTest.cxx.

Constructor & Destructor Documentation

◆ ~LinkColumnVector()

columnar::TestUtils::LinkColumnVector::~LinkColumnVector ( )

inlinenoexcept

Definition at line 307 of file ColumnarPhysliteTest.cxx.

      {
        if (!m_unknownKeysAllowedTargets.empty())
        {
          std::cout << "found unknown keys for " << m_columnName << ":";
          for (auto& [key, allowedSet] : m_unknownKeysAllowedTargets)
          {
            std::cout << "  " << std::hex << key << std::dec << " (allowed targets:";
            for (auto index : allowedSet)
              std::cout << " " << m_targetNames.at(index);
            std::cout << ")";
          }
        }
      }

Member Function Documentation

◆ addEmptyLink()

void columnar::TestUtils::LinkColumnVector::addEmptyLink ( )

inline

Definition at line 374 of file ColumnarPhysliteTest.cxx.

      {
        m_columnData.push_back (invalidObjectIndex);
      }

◆ addLink()

template<typename T>

void columnar::TestUtils::LinkColumnVector::addLink	(	const ElementLink< T > &	element,
		unsigned	eventIndex )

inline

Definition at line 363 of file ColumnarPhysliteTest.cxx.

      {
        if (element.isDefault())
        {
          addEmptyLink();
          return;
        }
 
        addSplitLink (element.index(), element.key(), eventIndex);
      }

◆ addSplitLink()

void columnar::TestUtils::LinkColumnVector::addSplitLink	(	std::size_t	linkIndex,
		SG::sgkey_t	linkKey,
		unsigned	eventIndex )

inline

Definition at line 379 of file ColumnarPhysliteTest.cxx.

      {
        if (linkIndex == 0 && linkKey == 0)
        {
          addEmptyLink();
          return;
        }
 
        unsigned targetIndex = 0u;
        while (targetIndex < m_targetKeys.size() && m_targetKeys.at(targetIndex) != linkKey)
          ++ targetIndex;
 
        // We didn't find the key, so we try to figure out which of the
        // targets it could be. The idea is that you wouldn't rely on
        // this for real tests, but that you then go and fill in those
        // keys in the central lookup table. It will always record and
        // report, that means if there is a variant link with extra
        // targets you didn't declare you will get a diagnostic. This
        // may be overly cautious, but it gives an extra diagnostic if
        // maybe you missed a target.
        if (targetIndex == m_targetKeys.size())
        {
          if (!m_unknownKeysAllowedTargets.contains (linkKey))
          {
            auto& allowedSet = m_unknownKeysAllowedTargets[linkKey];
            for (std::size_t i = 0; i < m_targetKeys.size(); ++ i)
            {
              if (m_targetKeys.at(i) == 0)
                allowedSet.insert(i);
            }
          }
          auto& allowedSet = m_unknownKeysAllowedTargets[linkKey];
          for (auto iter = allowedSet.begin(); iter != allowedSet.end();)
          {
            auto index = *iter;
            auto& targetOffsetColumn = *m_targetOffsetColumns.at(index);
            if (eventIndex + 1 >= targetOffsetColumn.size())
              throw std::runtime_error ("target offset column not yet filled for: " + m_targetNames.at(index));
            if (targetOffsetColumn.at(eventIndex) + linkIndex >= targetOffsetColumn.at(eventIndex + 1))
              iter = allowedSet.erase(iter);
            else
              ++ iter;
          }
          // Not quite sure whether it is safer to use or not use one of
          // the targets from the allowed set in this case. In general
          // tools are expected to handle invalid links gracefully,
          // worst case they throw an exception when trying to access
          // it. So what I came up with is that for variant links we
          // assume it invalid, but for non-variant links the tool
          // expects exactly one target and we either found it or throw
          // an exception.
          if (m_keysColumns.empty())
          {
            if (allowedSet.size() == 1 && m_targetKeys.at(*allowedSet.begin()) == 0 && m_unknownKeysAllowedTargets.size() == 1)
              targetIndex = *allowedSet.begin();
            else
            {
              std::ostringstream error;
              error << "target key mismatch: read sgkey " << std::hex << linkKey << std::dec;
              error << " for column " << m_columnName << " with element index " << linkIndex << " targeting " << m_targetNames.at(0);
              if (m_targetKeys.at(0) != 0u)
              {
                error << ", expected sgkey " << std::hex << m_targetKeys.at(0) << std::dec;
              } else if (m_unknownKeysAllowedTargets.size() > 1)
              {
                error << ", alternate key found for non-variant link:";
                for (auto& [key, allowedSet] : m_unknownKeysAllowedTargets)
                {
                  if (key != linkKey)
                    error << " " << std::hex << key << std::dec;
                }
              } else
              {
                error << ", no expected sgkey configured but the maximum allowed index for the target is " << m_targetOffsetColumns.at(0)->at(eventIndex + 1) - m_targetOffsetColumns.at(0)->at(eventIndex) - 1;
              }
              throw std::runtime_error (std::move (error).str());
            }
          }
        }
 
        if (targetIndex == m_targetKeys.size())
        {
          // this creates a link with an unknown key, which the user
          // will ignore
          m_columnData.push_back (CM::mergeLinkKeyIndex (0xff, linkIndex));
          return;
        }
 
        auto& targetOffsetColumn = *m_targetOffsetColumns.at(targetIndex);
        if (eventIndex + 1 >= targetOffsetColumn.size())
          throw std::runtime_error ("target offset column not yet filled for: " + m_targetNames.at(targetIndex));
        auto myLinkIndex = linkIndex + targetOffsetColumn.at(eventIndex);
        if (myLinkIndex >= targetOffsetColumn.at(eventIndex + 1))
          throw std::runtime_error ("index out of range for link: " + m_columnName + " with element index " + std::to_string(linkIndex) + " targeting " + m_targetNames.at(targetIndex) + " with offset " + std::to_string(targetOffsetColumn.at(eventIndex)) + " and next offset " + std::to_string(targetOffsetColumn.at(eventIndex + 1)));
 
        m_columnData.push_back (CM::mergeLinkKeyIndex (targetIndex, myLinkIndex));
      }

◆ addTarget()

void columnar::TestUtils::LinkColumnVector::addTarget	(	const std::string &	name,
		const std::unordered_map< std::string, const std::vector< ColumnarOffsetType > * > &	offsetColumns )

inlineprivate

Definition at line 517 of file ColumnarPhysliteTest.cxx.

      {
        unsigned targetIndex = 0;
        while (targetIndex < m_targetNames.size() && m_targetNames.at(targetIndex) != name)
          ++ targetIndex;
        if (targetIndex == m_targetNames.size())
        {
          m_targetNames.push_back(name);
          if (auto offsetIter = offsetColumns.find (name); offsetIter != offsetColumns.end())
            m_targetOffsetColumns.push_back (offsetIter->second);
          else
            throw std::runtime_error ("missing offset column: " + name);
          if (auto keyIter = knownKeys.find (name); keyIter != knownKeys.end())
            m_targetKeys.push_back (keyIter->second);
          else
            m_targetKeys.push_back (0);
        }
        if (!m_keysColumns.empty())
          m_keysColumns.back().push_back (targetIndex);
      }

◆ begin()

auto columnar::TestUtils::LinkColumnVector::begin ( ) const

inlinenodiscardnoexcept

Definition at line 487 of file ColumnarPhysliteTest.cxx.

487{ return m_columnData.begin(); }

◆ checkOffsets()

void columnar::TestUtils::LinkColumnVector::checkOffsets ( unsigned eventIndex )

inline

Definition at line 352 of file ColumnarPhysliteTest.cxx.

      {
        for (std::size_t i = 0; i < m_targetNames.size(); ++ i)
        {
          auto& targetOffsetColumn = *m_targetOffsetColumns.at(i);
          if (eventIndex + 1 >= targetOffsetColumn.size())
            throw std::runtime_error ("target offset column not yet filled for: " + m_targetNames.at(i) + " when checking link column " + m_columnName);
        }
      }

◆ clear()

void columnar::TestUtils::LinkColumnVector::clear ( )

inline

Definition at line 347 of file ColumnarPhysliteTest.cxx.

      {
        m_columnData.clear();
      }

◆ connect()

std::vector< std::string > columnar::TestUtils::LinkColumnVector::connect	(	const ColumnInfo &	columnInfo,
		const std::unordered_map< std::string, const std::vector< ColumnarOffsetType > * > &	offsetColumns,
		const std::unordered_map< std::string, ColumnInfo > &	requestedColumns )

inlinenodiscard

Definition at line 322 of file ColumnarPhysliteTest.cxx.

      {
        m_columnName = columnInfo.name;
        std::vector<std::string> keyColumnNames;
        if (!columnInfo.soleLinkTargetName.empty())
        {
          addTarget (columnInfo.soleLinkTargetName, offsetColumns);
        } else
        {
          for (auto& [requestedName, requestedInfo] : requestedColumns)
          {
            if (requestedInfo.keyColumnForVariantLink == m_columnName)
            {
              keyColumnNames.push_back (requestedName);
              m_keysColumns.emplace_back();
              for (const auto& targetName : requestedInfo.variantLinkTargetNames)
                addTarget (targetName, offsetColumns);
            }
          }
          if (m_keysColumns.empty())
            throw std::runtime_error ("no key column found for variant link: " + m_columnName);
        }
        return keyColumnNames;
      }

◆ data()

const CM::LinkIndexType * columnar::TestUtils::LinkColumnVector::data ( ) const

inlinenodiscardnoexcept

Definition at line 482 of file ColumnarPhysliteTest.cxx.

      {
        return m_columnData.data();
      }

◆ end()

auto columnar::TestUtils::LinkColumnVector::end ( ) const

inlinenodiscardnoexcept

Definition at line 488 of file ColumnarPhysliteTest.cxx.

488{ return m_columnData.end(); }

◆ keysColumn()

const std::vector< typename CM::LinkKeyType > & columnar::TestUtils::LinkColumnVector::keysColumn ( std::size_t index ) const

inlinenodiscard

Definition at line 490 of file ColumnarPhysliteTest.cxx.

      {
        return m_keysColumns.at(index);
      }

◆ size()

std::size_t columnar::TestUtils::LinkColumnVector::size ( ) const

inlinenodiscardnoexcept

Definition at line 477 of file ColumnarPhysliteTest.cxx.

      {
        return m_columnData.size();
      }

Member Data Documentation

◆ m_columnData

std::vector<typename CM::LinkIndexType> columnar::TestUtils::LinkColumnVector::m_columnData

private

Private Members

Definition at line 501 of file ColumnarPhysliteTest.cxx.

◆ m_columnName

std::string columnar::TestUtils::LinkColumnVector::m_columnName

private

Definition at line 503 of file ColumnarPhysliteTest.cxx.

◆ m_keysColumns

std::vector<std::vector<typename CM::LinkKeyType> > columnar::TestUtils::LinkColumnVector::m_keysColumns

private

Definition at line 511 of file ColumnarPhysliteTest.cxx.

◆ m_targetKeys

std::vector<SG::sgkey_t> columnar::TestUtils::LinkColumnVector::m_targetKeys

private

Definition at line 506 of file ColumnarPhysliteTest.cxx.

◆ m_targetNames

std::vector<std::string> columnar::TestUtils::LinkColumnVector::m_targetNames

private

Definition at line 505 of file ColumnarPhysliteTest.cxx.

◆ m_targetOffsetColumns

std::vector<const std::vector<ColumnarOffsetType>*> columnar::TestUtils::LinkColumnVector::m_targetOffsetColumns

private

Definition at line 507 of file ColumnarPhysliteTest.cxx.

◆ m_unknownKeysAllowedTargets

std::unordered_map<SG::sgkey_t,std::unordered_set<std::size_t> > columnar::TestUtils::LinkColumnVector::m_unknownKeysAllowedTargets

private

Definition at line 513 of file ColumnarPhysliteTest.cxx.

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

ColumnarPhysliteTest.cxx

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ CM

Public Members

Constructor & Destructor Documentation

◆ ~LinkColumnVector()

Member Function Documentation

◆ addEmptyLink()

◆ addLink()

◆ addSplitLink()

◆ addTarget()

◆ begin()

◆ checkOffsets()

◆ clear()

◆ connect()

◆ data()

◆ end()

◆ keysColumn()

◆ size()

Member Data Documentation

◆ m_columnData

Private Members

◆ m_columnName

◆ m_keysColumns

◆ m_targetKeys

◆ m_targetNames

◆ m_targetOffsetColumns

◆ m_unknownKeysAllowedTargets