VariadicTable< Ts > Class Template Reference

A class for "pretty printing" a table of data. More...

#include <VariadicTable.h>

Public Types
typedef std::tuple< Ts... >	DataTuple
	The type stored for each row.

Public Member Functions
	VariadicTable (std::vector< std::string > headers, unsigned int static_column_size=0, unsigned int cell_padding=1)
	Construct the table with headers.
void	addRow (Ts... entries)
	Add a row of data.
template<typename StreamType >
void	print (StreamType &stream)
	Pretty print the table of data.
void	setColumnFormat (const std::vector< VariadicTableColumnFormat > &column_format)
	Set how to format numbers for each column.
void	setColumnPrecision (const std::vector< int > &precision)
	Set how many digits of precision to show for floating point numbers.

Protected Member Functions
template<std::size_t I, typename TupleType , typename StreamType >
void	print_each (TupleType &&t, StreamType &stream, std::integral_constant< size_t, I >)
	These three functions print out each item in a Tuple into the table.
template<typename TupleType , typename StreamType >
void	print_each (TupleType &&t, StreamType &stream)
	This is what gets called first.
template<class T >
size_t	sizeOfData (const T &data, decltype(((T *) nullptr) ->size()) *=nullptr)
	Try to find the size the column will take up.
template<class T >
size_t	sizeOfData (const T &data, typename std::enable_if< std::is_integral< T >::value >::type *=nullptr)
	Try to find the size the column will take up.
size_t	sizeOfData (...)
	If it doesn't... let's just use a statically set size.
template<typename TupleType >
void	size_each (TupleType &&, std::vector< unsigned int > &, std::integral_constant< size_t, std::tuple_size< typename std::remove_reference< TupleType >::type >::value >)
	These three functions iterate over the Tuple, find the printed size of each element and set it in a vector.
template<std::size_t I, typename TupleType , typename = typename std::enable_if< I != std::tuple_size<typename std::remove_reference<TupleType>::type>::value>::type>
void	size_each (TupleType &&t, std::vector< unsigned int > &sizes, std::integral_constant< size_t, I >)
	Recursively called for each element.
template<typename TupleType >
void	size_each (TupleType &&t, std::vector< unsigned int > &sizes)
	The function that is actually called that starts the recursion.
void	size_columns ()
	Finds the size each column should be and set it in _column_sizes.

Static Protected Member Functions
template<typename T >
static auto	justify (int)

Protected Attributes
std::vector< std::string >	_headers
	The column headers.
unsigned int	_num_columns
	Number of columns in the table.
unsigned int	_static_column_size
	Size of columns that we can't get the size of.
unsigned int	_cell_padding
	Size of the cell padding.
std::vector< DataTuple >	_data
	The actual data.
std::vector< unsigned int >	_column_sizes
	Holds the printable width of each column.
std::vector< VariadicTableColumnFormat >	_column_format
	Column Format.
std::vector< int >	_precision
	Precision For each column.

Detailed Description

template<class... Ts>
class VariadicTable< Ts >

A class for "pretty printing" a table of data.

Requries C++11 (and nothing more)

It's templated on the types that will be in each column (all values in a column must have the same type)

For instance, to use it with data that looks like: "Fred", 193.4, 35, "Sam" with header names: "Name", "Weight", "Age", "Brother"

You would invoke the table like so: VariadicTable<std::string, double, int, std::string> vt("Name", "Weight", "Age", "Brother");

Then add the data to the table: vt.addRow("Fred", 193.4, 35, "Sam");

And finally print it: vt.print();

Definition at line 61 of file VariadicTable.h.

Member Typedef Documentation

DataTuple

template<class... Ts>

typedef std::tuple<Ts...> VariadicTable< Ts >::DataTuple

The type stored for each row.

Definition at line 65 of file VariadicTable.h.

Constructor & Destructor Documentation

VariadicTable()

template<class... Ts>

VariadicTable< Ts >::VariadicTable ( std::vector< std::string >  headers, unsigned int  static_column_size = 0, unsigned int  cell_padding = 1  )

inline

Construct the table with headers.

Parameters

headers	The names of the columns
static_column_size	The size of columns that can't be found automatically

Definition at line 73 of file VariadicTable.h.

    : _headers(headers),
      _num_columns(std::tuple_size<DataTuple>::value),
      _static_column_size(static_column_size),
      _cell_padding(cell_padding)
  {
    assert(headers.size() == _num_columns);
  }

Member Function Documentation

addRow()

template<class... Ts>

void VariadicTable< Ts >::addRow ( Ts...  entries )

inline

Add a row of data.

Easiest to use like: table.addRow({data1, data2, data3});

Parameters

data	A Tuple of data to add

Definition at line 92 of file VariadicTable.h.

{ _data.emplace_back(std::make_tuple(entries...)); }

Referenced by ReporterData::restoreState().

justify()

template<class... Ts>

template<typename T >

static auto VariadicTable< Ts >::justify ( int  )

inlinestaticprotected

Definition at line 172 of file VariadicTable.h.

  {
    if constexpr (std::is_arithmetic<typename std::remove_reference<T>::type>::value)
      // If it's a floating point value
      return std::right;
    else
      // Otherwise
      return std::left;
  }

print()

template<class... Ts>

template<typename StreamType >

void VariadicTable< Ts >::print ( StreamType &  stream )

inline

Pretty print the table of data.

Definition at line 98 of file VariadicTable.h.

  {
    size_columns();
 
    // Start computing the total width
    // First - we will have _num_columns + 1 "|" characters
    unsigned int total_width = _num_columns + 1;
 
    // Now add in the size of each colum
    for (auto & col_size : _column_sizes)
      total_width += col_size + (2 * _cell_padding);
 
    // Print out the top line
    stream << std::string(total_width, '-') << "\n";
 
    // Print out the headers
    stream << "|";
    for (unsigned int i = 0; i < _num_columns; i++)
    {
      // Must find the center of the column
      auto half = _column_sizes[i] / 2;
      half -= _headers[i].size() / 2;
 
      stream << std::string(_cell_padding, ' ') << std::setw(_column_sizes[i]) << std::left
             << std::string(half, ' ') + _headers[i] << std::string(_cell_padding, ' ') << "|";
    }
 
    stream << "\n";
 
    // Print out the line below the header
    stream << std::string(total_width, '-') << "\n";
 
    // Now print the rows of the table
    for (auto & row : _data)
    {
      stream << "|";
      print_each(row, stream);
      stream << "\n";
    }
 
    // Print out the line below the header
    stream << std::string(total_width, '-') << std::endl;
  }

Referenced by SolutionInvalidity::print(), PerfGraph::print(), PerfGraph::printHeaviestBranch(), and SolutionInvalidity::printHistory().

print_each() [1/2]

template<class... Ts>

template<typename TupleType , typename StreamType >

void VariadicTable< Ts >::print_each ( TupleType &&  t, StreamType &  stream  )

inlineprotected

This is what gets called first.

Definition at line 248 of file VariadicTable.h.

  {
    print_each(std::forward<TupleType>(t), stream, std::integral_constant<size_t, 0>());
  }

print_each() [2/2]

template<class... Ts>

template<std::size_t I, typename TupleType , typename StreamType >

void VariadicTable< Ts >::print_each ( TupleType &&  t, StreamType &  stream, std::integral_constant< size_t, I >    )

inlineprotected

These three functions print out each item in a Tuple into the table.

Original Idea From From https://stackoverflow.com/a/26908596

BTW: This would all be a lot easier with generic lambdas there would only need to be one of this sequence and then you could pass in a generic lambda. Unfortunately, that's C++14 This gets called on each item

Definition at line 196 of file VariadicTable.h.

  {
    auto & val = std::get<I>(t);
 
    auto original_precision = stream.precision();
    auto original_flags = stream.flags();
 
    // Set the precision
    if (!_precision.empty())
    {
      assert(_precision.size() ==
             std::tuple_size<typename std::remove_reference<TupleType>::type>::value);
 
      stream << std::setprecision(_precision[I]);
    }
 
    // Set the format
    if (!_column_format.empty())
    {
      assert(_column_format.size() ==
             std::tuple_size<typename std::remove_reference<TupleType>::type>::value);
 
      if (_column_format[I] == VariadicTableColumnFormat::SCIENTIFIC)
        stream << std::scientific;
 
      if (_column_format[I] == VariadicTableColumnFormat::FIXED)
        stream << std::fixed;
 
      if (_column_format[I] == VariadicTableColumnFormat::PERCENT)
        stream << std::fixed << std::setprecision(2);
    }
 
    stream << std::string(_cell_padding, ' ') << std::setw(_column_sizes[I])
           << justify<decltype(val)>(0) << val << std::string(_cell_padding, ' ') << "|";
 
    // Restore the format
    if (!_column_format.empty())
      stream.flags(original_flags);
 
    // Restore the precision
    if (!_precision.empty())
      stream.precision(original_precision);
 
    // Recursive call to print the next item (if there are any left)
    if constexpr (I + 1 != std::tuple_size<typename std::remove_reference<TupleType>::type>::value)
      print_each(std::forward<TupleType>(t), stream, std::integral_constant<size_t, I + 1>());
  }

Referenced by VariadicTable< Ts >::print(), VariadicTable< Ts >::print_each(), and VariadicTable< Ts >::print_each().

setColumnFormat()

template<class... Ts>

void VariadicTable< Ts >::setColumnFormat ( const std::vector< VariadicTableColumnFormat > &  column_format )

inline

Set how to format numbers for each column.

Note: this is ignored for std::string columns

@column_format The format for each column: MUST be the same length as the number of columns.

Definition at line 149 of file VariadicTable.h.

  {
    assert(column_format.size() == std::tuple_size<DataTuple>::value);
 
    _column_format = column_format;
  }

Referenced by PerfGraph::printHeaviestSections(), SolutionInvalidity::summaryTable(), SolutionInvalidity::transientTable(), and PerfGraph::treeTable().

setColumnPrecision()

template<class... Ts>

void VariadicTable< Ts >::setColumnPrecision ( const std::vector< int > &  precision )

inline

Set how many digits of precision to show for floating point numbers.

Note: this is ignored for std::string columns

@column_format The precision for each column: MUST be the same length as the number of columns.

Definition at line 163 of file VariadicTable.h.

  {
    assert(precision.size() == std::tuple_size<DataTuple>::value);
    _precision = precision;
  }

size_columns()

template<class... Ts>

void VariadicTable< Ts >::size_columns ( )

inlineprotected

Finds the size each column should be and set it in _column_sizes.

Definition at line 334 of file VariadicTable.h.

  {
    _column_sizes.resize(_num_columns);
 
    // Temporary for querying each row
    std::vector<unsigned int> column_sizes(_num_columns);
 
    // Start with the size of the headers
    for (unsigned int i = 0; i < _num_columns; i++)
      _column_sizes[i] = _headers[i].size();
 
    // Grab the size of each entry of each row and see if it's bigger
    for (auto & row : _data)
    {
      size_each(row, column_sizes);
 
      for (unsigned int i = 0; i < _num_columns; i++)
        _column_sizes[i] = std::max(_column_sizes[i], column_sizes[i]);
    }
  }

Referenced by VariadicTable< Ts >::print().

size_each() [1/3]

template<class... Ts>

template<typename TupleType >

void VariadicTable< Ts >::size_each ( TupleType &&  , std::vector< unsigned int > &  , std::integral_constant< size_t, std::tuple_size< typename std::remove_reference< TupleType >::type >::value >    )

inlineprotected

These three functions iterate over the Tuple, find the printed size of each element and set it in a vector.

End the recursion

Definition at line 293 of file VariadicTable.h.

  {
  }

Referenced by VariadicTable< Ts >::size_columns(), VariadicTable< Ts >::size_each(), and VariadicTable< Ts >::size_each().

size_each() [2/3]

template<class... Ts>

template<typename TupleType >

void VariadicTable< Ts >::size_each ( TupleType &&  t, std::vector< unsigned int > &  sizes  )

inlineprotected

The function that is actually called that starts the recursion.

Definition at line 326 of file VariadicTable.h.

  {
    size_each(std::forward<TupleType>(t), sizes, std::integral_constant<size_t, 0>());
  }

size_each() [3/3]

template<class... Ts>

template<std::size_t I, typename TupleType , typename = typename std::enable_if< I != std::tuple_size<typename std::remove_reference<TupleType>::type>::value>::type>

void VariadicTable< Ts >::size_each ( TupleType &&  t, std::vector< unsigned int > &  sizes, std::integral_constant< size_t, I >    )

inlineprotected

Recursively called for each element.

Definition at line 309 of file VariadicTable.h.

  {
    sizes[I] = sizeOfData(std::get<I>(t));
 
    // Override for Percent
    if (!_column_format.empty())
      if (_column_format[I] == VariadicTableColumnFormat::PERCENT)
        sizes[I] = 6; // 100.00
 
    // Continue the recursion
    size_each(std::forward<TupleType>(t), sizes, std::integral_constant<size_t, I + 1>());
  }

sizeOfData() [1/3]

template<class... Ts>

size_t VariadicTable< Ts >::sizeOfData (   ... )

inlineprotected

If it doesn't... let's just use a statically set size.

Definition at line 282 of file VariadicTable.h.

{ return _static_column_size; }

sizeOfData() [2/3]

template<class... Ts>

template<class T >

size_t VariadicTable< Ts >::sizeOfData ( const T &  data, decltype(((T *) nullptr) ->size()) *  = nullptr  )

inlineprotected

Try to find the size the column will take up.

If the datatype has a size() member... let's call it

Definition at line 259 of file VariadicTable.h.

  {
    return data.size();
  }

Referenced by VariadicTable< Ts >::size_each().

sizeOfData() [3/3]

template<class... Ts>

template<class T >

size_t VariadicTable< Ts >::sizeOfData ( const T &  data, typename std::enable_if< std::is_integral< T >::value >::type *  = nullptr  )

inlineprotected

Try to find the size the column will take up.

If the datatype is an integer - let's get it's length

Definition at line 270 of file VariadicTable.h.

  {
    if (data == 0)
      return 1;
 
    return std::log10(data) + 1;
  }

Member Data Documentation

_cell_padding

template<class... Ts>

unsigned int VariadicTable< Ts >::_cell_padding

protected

Size of the cell padding.

Definition at line 365 of file VariadicTable.h.

Referenced by VariadicTable< Ts >::print(), and VariadicTable< Ts >::print_each().

_column_format

template<class... Ts>

std::vector<VariadicTableColumnFormat> VariadicTable< Ts >::_column_format

protected

Column Format.

Definition at line 374 of file VariadicTable.h.

Referenced by VariadicTable< Ts >::print_each(), VariadicTable< Ts >::setColumnFormat(), and VariadicTable< Ts >::size_each().

_column_sizes

template<class... Ts>

std::vector<unsigned int> VariadicTable< Ts >::_column_sizes

protected

Holds the printable width of each column.

Definition at line 371 of file VariadicTable.h.

Referenced by VariadicTable< Ts >::print(), VariadicTable< Ts >::print_each(), and VariadicTable< Ts >::size_columns().

_data

template<class... Ts>

std::vector<DataTuple> VariadicTable< Ts >::_data

protected

The actual data.

Definition at line 368 of file VariadicTable.h.

Referenced by VariadicTable< Ts >::addRow(), VariadicTable< Ts >::print(), and VariadicTable< Ts >::size_columns().

_headers

template<class... Ts>

std::vector<std::string> VariadicTable< Ts >::_headers

protected

The column headers.

Definition at line 356 of file VariadicTable.h.

Referenced by VariadicTable< Ts >::print(), and VariadicTable< Ts >::size_columns().

_num_columns

template<class... Ts>

unsigned int VariadicTable< Ts >::_num_columns

protected

Number of columns in the table.

Definition at line 359 of file VariadicTable.h.

Referenced by VariadicTable< Ts >::print(), VariadicTable< Ts >::size_columns(), and VariadicTable< Ts >::VariadicTable().

_precision

template<class... Ts>

std::vector<int> VariadicTable< Ts >::_precision

protected

Precision For each column.

Definition at line 377 of file VariadicTable.h.

Referenced by VariadicTable< Ts >::print_each(), and VariadicTable< Ts >::setColumnPrecision().

_static_column_size

template<class... Ts>

unsigned int VariadicTable< Ts >::_static_column_size

protected

Size of columns that we can't get the size of.

Definition at line 362 of file VariadicTable.h.

Referenced by VariadicTable< Ts >::sizeOfData().

---

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

• include/utils/PerfGraph.h
• include/utils/VariadicTable.h