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:
 
  static constexpr size_t noColumnMaxWidth = std::numeric_limits< size_t >::max();
 
  enum Alignment { right, left, center };
 
  static constexpr Alignment defaultHeaderAlignment = Alignment::center;
 
  static constexpr Alignment defaultValueAlignment = Alignment::right;
 
  enum MarginValue : integer
  {
    tiny = 0,
    small = 1,
    medium = 2,
    large = 3
  };
 
  enum Section { header, values };
 
  struct ColumnAlignement
  {
    Alignment headerAlignment = defaultHeaderAlignment;
    Alignment valueAlignment = defaultValueAlignment;
  };
 
  class CellLayout
  {
public:
    CellType m_cellType;
    Alignment m_alignment;
 
    CellLayout();
 
    CellLayout( CellType cellType );
 
    CellLayout( CellType cellType, TableLayout::Alignment alignment );
 
    size_t getWidth() const
    { return m_cellWidth; }
 
    void setWidth( size_t cellWidth )
    { m_cellWidth = cellWidth; }
 
    stdVector< string_view > const & getLines() const
    { return m_lines; }
 
    std::vector< string_view > & getLines()
    { return m_lines; }
 
    size_t getHeight() const
    { return m_lines.size(); }
 
    size_t isEmpty() const
    { return m_lines.empty() || m_lines[0].empty(); }
 
    void prepareLayout( string_view value, size_t maxLineWidth );
 
private:
    size_t m_cellWidth;
    stdVector< string_view > m_lines;
  };
 
  class Cell
  {
public:
    CellLayout m_layout;
 
    Cell();
 
    Cell( CellType cellType, TableLayout::Alignment alignment );
 
    Cell( CellType cellType, TableLayout::Alignment alignment, string_view value );
 
    Cell( Cell const & other );
 
    Cell( Cell && other );
 
    Cell & operator=( Cell const & other );
 
    Cell & operator=( Cell && other );
 
    string_view getText() const
    { return m_text; }
 
    void setText( string_view text );
 
    void prepareLayout( size_t maxLineWidth );
 
private:
    string m_text;
  };
 
  class Column
  {
public:
    using ColumnsList = stdVector< Column >;
 
    Cell m_header;
    ColumnsList m_subColumns;
    ColumnAlignement m_alignment;
 
    Column();
 
    explicit Column( string_view name ):
      Column( name, ColumnAlignement() )
    {}
 
    Column( string_view name, ColumnAlignement alignment );
 
    Column * getParent()
    { return m_parent; }
 
    Column const * getParent() const
    { return m_parent; }
 
    void setParent( Column * parent )
    { m_parent = parent; }
 
    Column * getNext()
    { return m_next; }
 
    Column const * getNext() const
    { return m_next; }
 
    void setNext( Column * nextCell )
    {  m_next = nextCell; }
 
    Column & setName( string_view name );
 
    string_view getName() const;
 
    Column & setVisibility( bool visible );
 
    Column & addSubColumns( std::initializer_list< Column > subCol );
 
    Column & addSubColumns( std::initializer_list< string > subColNames );
 
    Column & addSubColumns( stdVector< string > const & subColNames );
 
    Column & addSubColumn( string_view subColName );
 
    Column & addSubColumn( Column const & subCol );
 
    Column & setHeaderAlignment( Alignment headerAlignment );
 
    Column & setValuesAlignment( Alignment valueAlignment );
 
    bool hasChild() const
    { return !this->m_subColumns.empty(); }
 
    bool hasParent() const
    { return this->m_parent != nullptr; }
 
    bool hasNext() const
    { return this->m_next != nullptr; }
 
    bool isVisible() const
    { return m_header.m_layout.m_cellType!=CellType::Hidden; }
 
private:
    Column * m_parent = nullptr;
    Column * m_next = nullptr;
  };
 
  class DeepFirstIterator
  {
public:
    using ColumnType = Column const;
 
    DeepFirstIterator( ColumnType * columnPtr, size_t idxLayer ):
      m_currentColumn( columnPtr ), m_currentLayer( idxLayer )
    {}
 
    DeepFirstIterator & operator=( ColumnType * columnPtr )
    {
      this->m_currentColumn = columnPtr;
      return *this;
    }
 
    DeepFirstIterator & operator++();
 
    DeepFirstIterator operator++( int );
 
    ColumnType & operator*() const
    { return *m_currentColumn; }
 
    ColumnType * getPtr() const
    { return m_currentColumn; }
 
    ColumnType * operator->() const
    { 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; }
 
private:
    ColumnType * m_currentColumn;
    size_t m_currentLayer;
  };
 
  DeepFirstIterator beginDeepFirst() const;
 
  DeepFirstIterator endDeepFirst() const
  { return DeepFirstIterator( nullptr, 0 ); }
 
  using TableLayoutArgs = std::initializer_list< std::variant< string_view, TableLayout::Column > >;
 
  using ColumnsList = Column::ColumnsList;
 
 
  TableLayout()
  {
    setMargin( MarginValue::medium );
  }
 
  TableLayout( string_view title,
               stdVector< TableLayout::Column > const & columns )
  {
    setMargin( MarginValue::medium );
    setTitle( title );
    addColumns( columns );
  }
 
  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,
               stdVector< string > const & args )
  {
    setMargin( MarginValue::medium );
    setTitle( title );
    addColumns( args );
  }
 
  ColumnsList const & getColumns() const
  { return m_tableColumns; }
 
  ColumnsList & getColumns()
  { return m_tableColumns; }
 
  CellLayout const & getTitleLayout() const
  { return m_tableTitleLayout; }
 
  CellLayout & getTitleLayout()
  { return m_tableTitleLayout; }
 
  string_view getTitleStr() const
  { return m_tableTitleStr; }
 
  TableLayout & setTitle( string_view title );
 
  TableLayout & enableLineBreak( bool value );
 
  TableLayout & setMargin( MarginValue marginValue );
 
  TableLayout & setMaxColumnWidth( size_t width );
 
  bool isMaxColumnWidthSet()
  { return m_maxColumnWidth != noColumnMaxWidth; }
 
  bool isLineBreakEnabled() const;
 
  integer const & getBorderMargin() const
  { return m_borderMargin; }
 
  integer const & getColumnMargin() const
  { return m_columnMargin; }
 
  integer const & getMarginValue() const
  { return m_marginValue; }
 
  size_t const & getMaxColumnWidth() const
  { return m_maxColumnWidth; }
 
  void addColumns( stdVector< TableLayout::Column > const & columnNames );
 
  void addColumns( stdVector< string > const & columns );
 
  void addColumn( string_view columnName );
 
  void addColumn( TableLayout::Column const & column );
 
protected:
 
  void processArguments( TableLayoutArgs args )
  {
    for( auto const & arg : args )
    {
      std::visit( [this]( auto const & value ) {
        addColumn( value );
      }, arg );
    }
  }
 
  template< typename ... Ts >
  void processArguments( Ts &... args )
  {
    addColumns( args ... );
  }
 
  ColumnsList m_tableColumns;
 
  bool m_lineBreakAtBegin = true;
 
  string m_tableTitleStr;
 
  CellLayout m_tableTitleLayout = CellLayout( CellType::Header, Alignment::center );
 
  size_t m_maxColumnWidth = noColumnMaxWidth;
 
 
  integer m_borderMargin;
 
  integer m_columnMargin;
 
  integer m_marginValue;
 
};
 
class PreparedTableLayout : public TableLayout
{
public:
 
  PreparedTableLayout();
 
  PreparedTableLayout( TableLayout const & other );
 
  PreparedTableLayout( PreparedTableLayout const & ) = delete;
 
  PreparedTableLayout( PreparedTableLayout && ) = delete;
 
  size_t getColumnLayersCount() const
  { return m_columnLayersCount; }
 
  size_t getVisibleLowermostColumnCount() const
  { return m_visibleLowermostColumnCount; }
 
  size_t getTotalLowermostColumnCount() const
  { return m_totalLowermostColumnCount; }
 
private:
 
  // Number of column layers that a table layout has, default is 1;
  size_t m_columnLayersCount;
  // Numbers of lower most column
  size_t m_totalLowermostColumnCount;
// Numbers of lower most column that are visible
  size_t m_visibleLowermostColumnCount;
 
  void prepareLayoutRecusive( stdVector< TableLayout::Column > & columns, size_t level );
 
};
}
 
#endif /* GEOS_COMMON_FORMAT_TABLE_TABLELAYOUT_HPP */