TableLayout.hpp

Go to the documentation of this file.

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2016-2024 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2024 TotalEnergies
 * Copyright (c) 2018-2024 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2023-2024 Chevron
 * Copyright (c) 2019-     GEOS/GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */
 
#ifndef GEOS_COMMON_FORMAT_TABLE_TABLELAYOUT_HPP
#define GEOS_COMMON_FORMAT_TABLE_TABLELAYOUT_HPP
 
#include "common/DataTypes.hpp"
#include "TableTypes.hpp"
#include <variant>
#include "common/logger/Logger.hpp"
 
 
namespace geos
{
 
class TableLayout
{
 
public:
 
  enum Alignment { right, left, center };
 
  enum MarginValue : integer
  {
    tiny = 0,
    small = 1,
    medium = 2,
    large = 3
  };
 
  enum Section { header, values };
 
  struct ColumnAlignement
  {
    Alignment headerAlignment = Alignment::center;
    Alignment valueAlignment = Alignment::right;
  };
 
  struct CellLayout
  {
    std::vector< string > m_lines;
    CellType m_cellType;
    Alignment m_alignment;
    size_t m_cellWidth;
 
    CellLayout();
 
    CellLayout( CellType cellType, string const & value, TableLayout::Alignment alignment );
  };
 
  class Column
  {
public:
    CellLayout m_header;
    std::vector< Column > m_subColumn;
    ColumnAlignement m_alignment;
 
    Column();
 
    Column( TableLayout::CellLayout cellLayout );
 
    Column * getParent()
    { return m_parent; }
 
    void setParent( Column * parent )
    { m_parent = parent; }
 
    Column * getNextCell()
    { return m_next; }
 
    void setNextCell( Column * nextCell )
    {  m_next = nextCell; }
 
    Column & setName( string_view name );
 
    Column & setVisibility( CellType celltype );
 
    TableLayout::Column & addSubColumns( std::initializer_list< TableLayout::Column > subCol );
 
    TableLayout::Column & addSubColumns( std::initializer_list< string > subColName );
 
    TableLayout::Column & addSubColumns( string const & subColName );
 
    TableLayout::Column & setHeaderAlignment( Alignment headerAlignment );
 
    TableLayout::Column & setValuesAlignment( Alignment valueAlignment );
 
    size_t getNumberCellMerge()
    { return m_headerMergeCount; }
 
    void incrementMergeHeaderCount( size_t value )
    { m_headerMergeCount+= value;}
 
    void decrementMergeHeaderCount()
    { m_headerMergeCount--; }
 
    bool hasChild() const
    { return !this->m_subColumn.empty(); }
 
    bool hasParent() const
    { return this->m_parent != nullptr; }
 
private:
    Column * m_parent;
    Column * m_next;
    size_t m_headerMergeCount  = 0;
  };
 
  class DeepFirstIterator
  {
public:
    using ColumnType = Column;
 
    DeepFirstIterator( ColumnType * columnPtr, size_t idxLayer ):
      m_currentColumn( columnPtr ), m_currentLayer( idxLayer )
    {}
 
    DeepFirstIterator & operator=( Column * columnPtr )
    {
      this->m_currentColumn= columnPtr;
      return *this;
    }
 
    DeepFirstIterator & operator++();
 
    DeepFirstIterator operator++( int );
 
    ColumnType & operator*()
    { return *m_currentColumn; }
 
    ColumnType * operator->()
    { return m_currentColumn; }
 
    friend bool operator== ( DeepFirstIterator const & a, DeepFirstIterator const & b )
    { return a.m_currentColumn == b.m_currentColumn; };
    friend bool operator!= ( DeepFirstIterator const & a, DeepFirstIterator const & b )
    { return a.m_currentColumn != b.m_currentColumn; };
 
    size_t getCurrentLayer() const
    { return m_currentLayer; }
 
    bool isLastColumn();
 
private:
    ColumnType * m_currentColumn;
    size_t m_currentLayer;
  };
 
  DeepFirstIterator beginDeepFirst();
 
  DeepFirstIterator endDeepFirst()
  {
    return DeepFirstIterator( nullptr, 0 );
  }
 
  using TableLayoutArgs = std::initializer_list< std::variant< string_view, TableLayout::Column > >;
 
  TableLayout() = default;
 
  TableLayout( string_view title,
               std::vector< TableLayout::Column > const & columns )
  {
    setMargin( MarginValue::medium );
    setTitle( title );
    for( auto const & column :columns )
    {
      addToColumns( column );
    }
  }
 
  TableLayout( string_view title,
               TableLayoutArgs args )
  {
    setMargin( MarginValue::medium );
    setTitle( title );
    processArguments( args );
  }
 
  TableLayout( TableLayoutArgs args )
  {
    setMargin( MarginValue::medium );
    processArguments( args );
  }
 
  TableLayout( string_view title,
               std::vector< string > const & args )
  {
    setMargin( MarginValue::medium );
    setTitle( title );
    addToColumns( args );
  }
 
  size_t getMaxDepth() const;
 
  std::vector< Column > & getColumns()
  { return m_tableColumnsData; }
 
  std::vector< Column > const & getColumns() const
  { return m_tableColumnsData; }
 
  string_view getTitle() const
  { return m_tableTitle; }
 
  TableLayout & setTitle( string_view title );
 
  TableLayout & enableLineBreak( bool value );
 
  TableLayout & setMargin( MarginValue marginValue );
 
  bool isLineBreakEnabled() const;
 
 
  integer const & getBorderMargin() const
  { return m_borderMargin; }
 
  integer const & getColumnMargin() const
  { return m_columnMargin; }
 
  integer const & getMarginValue() const
  { return m_marginValue; }
 
  integer const & getMarginTitle() const
  { return m_titleMargin; }
 
  std::vector< size_t > & getSublineInHeaderCounts()
  { return m_sublineHeaderCounts; }
 
  std::vector< size_t > & getNbSubDataLines()
  { return m_sublineDataCounts; }
 
  void addToColumns( string_view m_header );
 
private:
 
  void processArguments( TableLayoutArgs args )
  {
    for( auto const & arg : args )
    {
      std::visit( [this]( auto const & value ) {
        addToColumns( value );
      }, arg );
    }
  }
 
  template< typename ... Ts >
  void processArguments( Ts &... args )
  {
    addToColumns( args ... );
  }
 
  void addToColumns( std::vector< string > const & columnNames );
 
  void addToColumns( TableLayout::Column const & column );
 
  std::vector< Column > m_tableColumnsData;
  std::vector< size_t > m_sublineHeaderCounts;
  std::vector< size_t > m_sublineDataCounts;
  bool m_wrapLine = true;
 
  string m_tableTitle;
 
  integer m_borderMargin;
  integer m_columnMargin;
  integer m_marginValue;
  integer m_titleMargin = 2;
 
};
}
 
#endif /* GEOS_COMMON_FORMAT_TABLE_TABLELAYOUT_HPP */