report_table.h

// -*-c++-*-
#ifndef STORMM_REPORT_TABLE_H
#define STORMM_REPORT_TABLE_H
 
#include <string>
#include <vector>
#include "copyright.h"
#include "DataTypes/common_types.h"
#include "DataTypes/stormm_vector_types.h"
#include "FileManagement/file_enumerators.h"
#include "Parsing/parsing_enumerators.h"
#include "reporting_enumerators.h"
#include "summary_file.h"
 
namespace stormm {
namespace review {
 
using diskutil::PrintSituation;
using parse::JustifyText;
  
class ReportTable {
public:

  ReportTable(const std::vector<std::string> &data_in,
              const std::vector<std::string> &column_headings,
              const std::string &variable_name_in = std::string(""),
              int format_width_in = default_output_file_width,
              const std::vector<JustifyText> &alignments = {}, bool enforce_format_width = false);
 
  ReportTable(const std::vector<double> &data_in, const std::vector<std::string> &column_headings,
              double precision = 1.0e-6, const std::string &variable_name_in = std::string(""),
              int format_width_in = default_output_file_width,
              const std::vector<JustifyText> &alignments = {});
 
  ReportTable(const std::vector<double> &data_in, const std::vector<std::string> &column_headings,
              const std::vector<double> &precision,
              const std::string &variable_name_in = std::string(""),
              int format_width_in = default_output_file_width,
              const std::vector<JustifyText> &alignments = {});
 
  ReportTable(const std::vector<double> &data_in, const std::vector<std::string> &column_headings,
              const std::vector<int> &decimal_places,
              const std::string &variable_name_in = std::string(""),
              int format_width_in = default_output_file_width,
              const std::vector<JustifyText> &alignments = {});
 
  ReportTable(const std::vector<int> &data_in, const std::vector<std::string> &column_headings,
              const std::string &variable_name_in = std::string(""),
              int format_width_in = default_output_file_width,
              const std::vector<JustifyText> &alignments = {});
 
  ReportTable(const std::vector<llint> &data_in, const std::vector<std::string> &column_headings,
              const std::string &variable_name_in = std::string(""),
              int format_width_in = default_output_file_width,
              const std::vector<JustifyText> &alignments = {});
  
  ReportTable(const std::vector<char4> &data_in, const std::vector<std::string> &column_headings,
              const std::string &variable_name_in = std::string(""),
              int format_width_in = default_output_file_width,
              const std::vector<JustifyText> &alignments = {});

  ReportTable(const ReportTable &original) = default;
  ReportTable(ReportTable &&original) = default;
  ReportTable& operator=(const ReportTable &original) = default;
  ReportTable& operator=(ReportTable &&original) = default;

  int getColumnCount() const;

  int getHeaderRowCount() const;

  int getDataRowCount() const;

  int getColumnWidth(int column_index) const;

  int getTableWidth() const;

  TableContentKind getContentKind() const;
  
  const std::string& getValue(size_t row_index, size_t column_index) const;

  std::string printTable(OutputSyntax style, int width = -1, int data_row_start = 0,
                         int data_row_end = -1) const;
 
  void printTable(std::ofstream *foutp, OutputSyntax style, int width = -1, int data_row_start = 0,
                  int data_row_end = -1) const;
 
  void printTable(const std::string &file_name, PrintSituation expectation, OutputSyntax style,
                  int width = -1, int data_row_start = 0, int data_row_end = -1) const;

  void setVariableName(const std::string &variable_name_in);

  void unprotectContent();
  
private:
  int column_count;                          
  int data_row_count;                        
  int header_row_count;                      
  int format_width;                          
  TableContentKind data_kind;                
  std::vector<std::string> rendered_data;    
  std::vector<std::string> column_headings;  
  std::vector<int> column_widths;            
  std::string variable_name;                 
  
  void formatColumnHeadings(const std::vector<std::string> &column_headings_in,
                            const std::vector<size_t> &data_widths);

  void findColumnWidths(const std::vector<size_t> &data_widths,
                        const std::vector<JustifyText> &alignments = {});
  
  std::vector<std::string> dataAsStrings(const std::vector<double> &data_in, int ncol,
                                         double precision);
 
  std::vector<std::string> dataAsStrings(const std::vector<double> &data_in,
                                         const std::vector<double> &precision);
 
  std::vector<std::string> dataAsStrings(const std::vector<double> &data_in,
                                         const std::vector<int> &decimal_places);
 
  std::vector<std::string> dataAsStrings(const std::vector<int> &data_in, int ncol);
  
  std::vector<std::string> dataAsStrings(const std::vector<llint> &data_in, int ncol);
 
  std::vector<std::string> dataAsStrings(const std::vector<char4> &data_in, int ncol);

  std::string formatVariableName(OutputSyntax style, int set_start, int set_end,
                                 int data_row_start, int actual_row_end) const;

  
  std::string formatClosure(OutputSyntax style, const std::string &comment_block,
                            const std::string &carriage_return, std::string *hstack_line,
                            std::string *hstack_declaration, int set_start, int set_end) const;
};
 
} // namespace review
} // namespace stormm
  
#endif