feat: Table subs division

src/coreComponents/common/format/table/TableData.cpp

@@ -87,7 +87,6 @@ TableData2D::TableDataHolder TableData2D::buildTableData( string_view targetUnit
                                                           string_view columnFmt ) const
 {
   TableData2D::TableDataHolder tableData1D;
-  std::vector< size_t > rowsLength;
 
   tableData1D.headerNames.push_back( string( targetUnit ) );
 
@@ -114,8 +113,7 @@ TableData2D::TableDataHolder TableData2D::buildTableData( string_view targetUnit
       currentRowValues.push_back( GEOS_FMT( "{}", cellValue ) );
     }
 
-    tableData1D.tableData.addRow( std::move( currentRowValues ) );
-    rowsLength.push_back( currentRowValues.size() );
+    tableData1D.tableData.addRow( currentRowValues );
   }
 
   return tableData1D;

src/coreComponents/common/format/table/TableFormatter.hpp

@@ -41,7 +41,7 @@ class TableFormatter
 
   /**
    * @brief Construct a new Table Formatter from a tableLayout
-   * @param tableLayout Contain all column names and optionnaly the table title
+   * @param tableLayout Contain all tableColumnData names and optionnaly the table title
    */
   TableFormatter( TableLayout const & tableLayout );
 
@@ -67,7 +67,7 @@ class TableCSVFormatter : public TableFormatter
 
   /**
    * @brief Construct a new Table Formatter from a tableLayout
-   * @param tableLayout Contain all column names and optionnaly the table title
+   * @param tableLayout Contain all tableColumnData names and optionnaly the table title
    */
   TableCSVFormatter( TableLayout const & tableLayout );
 
@@ -77,7 +77,7 @@ class TableCSVFormatter : public TableFormatter
   virtual ~TableCSVFormatter() = default;
 
   /**
-   * @return The string with all column names.
+   * @return The string with all tableColumnData names.
    */
   string headerToString() const;
 
@@ -115,7 +115,6 @@ class TableTextFormatter : public TableFormatter
 {
 public:
 
-
   /**
    * @brief Construct a new TableFormatter
    */
@@ -125,7 +124,7 @@ class TableTextFormatter : public TableFormatter
 
   /**
    * @brief Construct a new TableFormatter from a tableLayout
-   * @param tableLayout Contain all column names and optionnaly the table title
+   * @param tableLayout Contain all tableColumnData names and optionnaly the table title
    */
   TableTextFormatter( TableLayout const & tableLayout );
 
@@ -136,9 +135,10 @@ class TableTextFormatter : public TableFormatter
   virtual ~TableTextFormatter() = default;
 
   /**
-   * @return A TableLayout converted into a formatted representation.
+   * @return A TableLayout string representation,
+   * The TableTextFormatter receives hasn't receive any data, so only the header part is returned.
    */
-  string layoutToString() const;
+  string toString() const;
 
   /**
    * @brief Convert a data source to a table string.
@@ -156,95 +156,113 @@ class TableTextFormatter : public TableFormatter
   static constexpr char m_horizontalLine = '-';
 
   /**
-   * @brief Fill the vector (m_column) in tableData with values from rows stored in tableData.
-   * @param columns Vector of columns to be filled.
+   * @brief Prepare all the tableColumnsData  with the appropriate values and formatting separator
+   * @param tableColumnsData  The vector containg all tableColumnsData . Each tableColumnData contains its own
+   *        parameters (such as name, alignment, etc.).
    * @param tableData Vector containing all rows filled with values
+   * @param sectionSeparatingLine Separator string used between sections of the table
+   * @param topSeparator The table top separator
    */
-  void fillTableColumnsFromRows( std::vector< TableLayout::Column > & columns,
-                                 std::vector< std::vector< string > > & tableData ) const;
+  void prepareAndBuildTable( std::vector< TableLayout::ColumnStructure > & tableColumnsData,
+                             TableData const & tableData,
+                             string & sectionSeparatingLine,
+                             string & topSeparator ) const;
+/**
+ * @brief Displays the complete table
+ * @param tableOutput The output stream
+ * @param tableColumnsData  Vector containg all tableColumnsData
+ * @param sectionSeparatingLine Separator string used between sections of the table
+ * @param topSeparator The table top separator
+ */
+  void outputTable( std::ostringstream & tableOutput,
+                    std::vector< TableLayout::ColumnStructure > & tableColumnsData,
+                    string_view sectionSeparatingLine,
+                    string_view topSeparator ) const;
 
   /**
-   * @brief Converts a TableLayout into a formatted representation.
-   * @param tableOutput The output stream
-   * @param columns The vector containing all table columns
-   * @param msgTableError A vector containg all error related to the table
-   * @param sectionSeparatingLine An empty string for building the section separator
+   * @brief Populate all the tableColumnData values with values extracted from TableData.
+   * @param tableColumnsData  Vector of tableColumnsData  to populate.
+   * @param tableData Vector containing all rows filled with values
+   * @param isSubColumn Boolean indicating if the current tableColumnData is a subcolumn
    */
-  void outputLayout( std::ostringstream & tableOutput,
-                     std::vector< TableLayout::Column > & columns,
-                     std::vector< string > const & msgTableError,
-                     string & sectionSeparatingLine ) const;
+  void populateColumnsFromTableData( std::vector< TableLayout::ColumnStructure > & tableColumnsData,
+                                     std::vector< std::vector< string > > const & tableData ) const;
 
   /**
    * @brief Split all header names by detecting the newline \\n character. and
-   * set the same vector size for each split header and merge it into columns
-   * @param columns The vector containg all columns
-   * @param largestHeaderVectorSize The largest split header vector size
-   * @param splitHeaders A empty vector who will contain all split header names
+   * set the same vector size for each divided header and merge it into tableColumnsData
+   * @param tableColumnsData  The vector containg all tableColumnsData
+   * @param allDividedHeaderParts Vector to store the split header names for each tableColumnData
    */
-  void splitAndSetColumnNames( std::vector< TableLayout::Column > & columns,
-                               size_t & largestHeaderVectorSize,
-                               std::vector< std::vector< string > > & splitHeaders ) const;
+  void splitAndMergeColumnHeaders( std::vector< TableLayout::ColumnStructure > & tableColumnsData,
+                                   std::vector< std::vector< string > > & allDividedHeaderParts ) const;
 
   /**
-   * @brief For each column find and set the column's longest string
-   * @param columns The vector containg all columns
+   * @brief For each tableColumnData find and set the column's longest string
+   * @param tableColumnData The tableColumnData to process.
+   * @param maxStringSize Store the longest string(s) for each tableColumnData.
+   * @param idxColumn The current index of the tableColumnData
+   *
+   * @note Compares the longest string from the header with the longest string from the column values.
+   * If the column contains subcolumns, it recursively applies the same logic to them
    */
-  void findAndSetMaxStringSize( std::vector< TableLayout::Column > & columns ) const;
+  void findAndSetLongestColumnString( TableLayout::ColumnStructure & tableColumnData ) const;
 
   /**
-   * @brief recalculate the largest string size for each columns
-   * @param columns Vector containing all table columns
-   * @param extraCharacters Extra characters to be added to \p m_maxStringSize of each columns
+   * @brief Compute the max table line length, taking into account the length of : title, tableColumnsData  header/values
+   * Increase the size of the tableColumnsData if necessary, then builds the table's separating lines
+   * @param tableColumnsData Vector of tableColumnData containing containing the largest string for each tableColumnData
+   * @param sectionSeparatingLine Separator string used between sections of the table
+   * @param topSeparator The table top separator
    */
-  void increaseColumnsSize( std::vector< TableLayout::Column > & columns,
-                            integer const extraCharacters ) const;
+  void computeAndBuildTableSeparator( std::vector< TableLayout::ColumnStructure > & tableColumnsData,
+                                      string & sectionSeparatingLine,
+                                      string & topSeparator ) const;
 
   /**
-   * @brief Compute the max table line length, taking into account the length of : title, error, columns header and content
-   * Increase the size of the columns if necessary
-   * @param columns Vector of column containing containing the largest string for each column
-   * @param msgTableError Vector containing all error messages
+   * @brief Increase each tableColumnData size if the title is larger than all the tableColumnsData
+   * @param tableColumnsData Vector containing all table tableColumnsData
+   * @param extraCharacters ExtraCharacters to be distributed between each tableColumnsData
    */
-  void computeTableWidth( std::vector< TableLayout::Column > & columns,
-                          std::vector< string > const & msgTableError ) const;
+  void increaseColumnsSize( std::vector< TableLayout::ColumnStructure > & tableColumnsData,
+                            size_t const extraCharacters ) const;
 
   /**
-   * @brief Build all separators needed from content length contained in the columns vector
-   * @param columns Vector containing all table columns
-   * @param topSeparator Top separator to be built
-   * @param sectionSeparatingLine Line section separator to be built
+   * @brief Output the title row in the table
+   * @param topSeparator The top separator string
    */
-  void buildTableSeparators( std::vector< TableLayout::Column > const & columns,
-                             string & topSeparator,
-                             string & sectionSeparatingLine ) const;
+  void outputTitleRow( std::ostringstream & tableOutput,
+                       string_view topSeparator ) const;
 
   /**
-   * @brief Add a row on top of the table
+   * @brief Output the header rows in the table
+   * @param tableColumnsData  Vector containing all table tableColumnsData
    * @param tableOutput The output stream
-   * @param msg Vector of string(s) to display
-   * @param topSeparator The top table separator
-   * @param alignment The aligment for a row
+   * @param sectionSeparatingLine Separator string used between sections of the table
    */
-  void outputTopRows( std::ostringstream & tableOutput,
-                      std::vector< string > const & msg,
-                      string_view topSeparator,
-                      TableLayout::Alignment alignment ) const;
+  void outputHeaderSectionRows( std::vector< TableLayout::ColumnStructure > const & tableColumnsData,
+                                std::ostringstream & tableOutput,
+                                string_view sectionSeparatingLine ) const;
 
   /**
-   * @brief Output a section by specifying it's type ( header or section )
-   * @param columns Vector containing all table columns
-   * @param sectionSeparatingLine Line separator between sections
-   * @param rows A section row
-   * @param nbRows Indicates the number of lines in a section
-   * @param section The section to be built
-   * @note Add the ending line if there are one or more rows
+   * @brief Outputs subcolumns for the given row in the table.
+   * @param tableColumnsData  Vector containing the subcolumn values
+   * @param tableOutput The output stream
+   * @param idxRow Index of the current row in the table
+   */
+  void outputSubSection( std::vector< TableLayout::ColumnStructure > const & tableColumnsData,
+                         std::ostringstream & tableOutput,
+                         integer idxRow ) const;
+
+  /**
+   * @brief Output the values rows in the table
+   * @param tableColumnsData  Vector containing all table tableColumnsData
+   * @param tableOutput The output stream
+   * @param sectionSeparatingLine Separator string used between sections of the table
    */
-  void outputSectionRows( std::vector< TableLayout::Column > const & columns,
-                          string_view sectionSeparatingLine,
-                          std::ostringstream & rows,
-                          integer const nbRows,
-                          TableLayout::Section const section ) const;
+  void outputValuesSectionRows( std::vector< TableLayout::ColumnStructure > const & tableColumnsData,
+                                std::ostringstream & tableOutput,
+                                string_view sectionSeparatingLine ) const;
 };
 
 /**

src/coreComponents/common/format/table/TableLayout.cpp

@@ -16,51 +16,100 @@
 /**
  * @file TableData.hpp
  */
-
 #include "TableLayout.hpp"
 
 namespace geos
 {
 
-TableLayout::TableLayout( std::vector< string > const & columnNames, string const & title ):
-  m_tableTitle( title )
+void TableLayout::addToColumns( const std::vector< string > & columnNames )
 {
-  setMargin( MarginValue::medium );
-  m_columns.reserve( columnNames.size() );
-  for( auto const & name : columnNames )
+  for( const auto & columnName : columnNames )
   {
-    m_columns.push_back( {TableLayout::ColumnParam{{name}, Alignment::right, true}, {}, ""} );
+    addToColumns( columnName );
   }
 }
 
-TableLayout::TableLayout( std::vector< ColumnParam > const & columnParameters, string const & title ):
-  m_tableTitle( title )
+void TableLayout::addToColumns( string_view columnName )
+{
+  m_tableColumnsData.push_back( TableLayout::Column{ columnName } );
+}
+
+void TableLayout::addToColumns( Column const & column )
 {
-  setMargin( MarginValue::medium );
-  m_columns.reserve( columnParameters.size() );
-  for( auto const & param : columnParameters )
+  if( !column.subColumnNames.empty())
   {
-    m_columns.push_back( { param, {}, ""} );
+    std::vector< TableLayout::ColumnStructure > subColumns;
+    for( const auto & subColumnsName : column.subColumnNames )
+    {
+      subColumns.push_back(
+        TableLayout::ColumnStructure {
+          TableLayout::Column{ subColumnsName, column.alignmentSettings.headerAlignment }
+        } );
+    }
+    m_tableColumnsData.push_back( TableLayout::ColumnStructure { column, subColumns } );
+  }
+  else
+  {
+    m_tableColumnsData.push_back( TableLayout::ColumnStructure { column } );
   }
 }
 
-void TableLayout::setMargin( MarginValue marginValue )
+TableLayout & TableLayout::setTitle( string_view title )
 {
-  m_borderMargin = marginValue;
+  m_tableTitle = title;
+  return *this;
+}
+
+TableLayout & TableLayout::disableLineBreak()
+{
+  m_wrapLine = false;
+  return *this;
+}
+
+TableLayout & TableLayout::setMargin( MarginValue marginValue )
+{
+  m_marginValue = marginValue;
+  m_borderMargin = marginValue + 1; // margin + border character
   m_columnMargin = integer( marginValue ) * 2 + 1;
+
+  return *this;
+}
+
+TableLayout & TableLayout::setValuesAlignment( TableLayout::Alignment alignment )
+{
+  for( auto & tableColumnData : m_tableColumnsData )
+  {
+    tableColumnData.column.alignmentSettings.valueAlignment = alignment;
+  }
+  return *this;
+}
+
+bool TableLayout::isLineBreakEnabled() const
+{
+  return m_wrapLine;
 }
 
-std::vector< TableLayout::Column > const & TableLayout::getColumns() const
+void TableLayout::removeSubColumn()
 {
-  return m_columns;
+  for( auto & column : m_tableColumnsData )
+  {
+    if( !column.subColumn.empty() )
+    {
+      column.subColumn.clear();
+    }
+  }
+}
+
+std::vector< TableLayout::ColumnStructure > const & TableLayout::getColumns() const
+{
+  return m_tableColumnsData;
 }
 
 string_view TableLayout::getTitle() const
 {
   return m_tableTitle;
 }
 
-
 integer const & TableLayout::getBorderMargin() const
 {
   return m_borderMargin;
@@ -71,6 +120,11 @@
   return m_columnMargin;
 }
 
+integer const & TableLayout::getMarginValue() const
+{
+  return m_marginValue;
+}
+
 integer const & TableLayout::getMarginTitle() const
 {
   return m_titleMargin;