FormattedTable.h

#ifndef ROSE_FormattedTable_H
#define ROSE_FormattedTable_H
 
#include <Rose/Color.h>
#include <boost/lexical_cast.hpp>
#include <string>
#include <vector>
 
namespace Rose {
 
class FormattedTable {
public:
    // Public types
 
    enum class Format {
        PLAIN,                                          
        HTML,                                           
        CSV,                                            
        SHELL                                           
    };
    enum class Format {…};
 
    enum class Alignment {
        LEFT,                                           
        RIGHT,                                          
        CENTER                                          
    };
    enum class Alignment {…};
 
    class CellProperties {
        Sawyer::Optional<Color::HSV> foreground_;
        Sawyer::Optional<Color::HSV> background_;
        Sawyer::Optional<Alignment> alignment_;
 
    public:
        CellProperties();
 
        CellProperties(const Sawyer::Optional<Color::HSV> &foreground,
                       const Sawyer::Optional<Color::HSV> &background,
                       const Sawyer::Optional<Alignment> &alignment);
 
        const Sawyer::Optional<Color::HSV>& foreground() const;
        CellProperties& foreground(const Sawyer::Optional<Color::HSV>&);
        const Sawyer::Optional<Color::HSV>& background() const;
        CellProperties& background(const Sawyer::Optional<Color::HSV>&);
        const Sawyer::Optional<Alignment>& alignment() const;
        CellProperties& alignment(const Sawyer::Optional<Alignment>&);
        static CellProperties merge(const CellProperties &a, const CellProperties &b);
    };
    class CellProperties {…};
 
private:
    std::vector<std::vector<std::string>> cells_;         // data
    std::vector<std::vector<CellProperties>> props_;      // data properties
    std::vector<std::vector<std::string>> columnHeaders_; // titles for columns
    std::vector<std::vector<CellProperties>> columnHeaderProps_;
    std::string indentation_;                             // to be printed before each line of output
    Format format_ = Format::PLAIN;
 
public:
    // Constructors, etc.
 
    FormattedTable();
 
    FormattedTable(size_t nRows, size_t nColumns);
 
    // Table-wide properties
 
    Format format() const;
    void format(Format);
    const std::string& indentation() const;
    void indentation(const std::string&);
    // FormattedTable data
 
    void resize(size_t nRows, size_t nColumns);
    void resize(size_t nRows);
    size_t nRows() const;
    size_t nColumns() const;
    void insert(size_t rowIdx, size_t columnIdx, const std::string &repr);
    void insert(size_t rowIdx, size_t columnIdx, const std::string &repr, const CellProperties&);
    template<typename T> void insert(size_t rowIdx, size_t columnIdx, const T &value) {
        insert(rowIdx, columnIdx, boost::lexical_cast<std::string>(value));
    }
    template<typename T> void insert(size_t rowIdx, size_t columnIdx, const T &value) {…}
    template<typename T> void insert(size_t rowIdx, size_t columnIdx, const T &value, const CellProperties &prop) {
        insert(rowIdx, columnIdx, boost::lexical_cast<std::string>(value), prop);
    }
    template<typename T> void insert(size_t rowIdx, size_t columnIdx, const T &value, const CellProperties &prop) {…}
    const std::string& get(size_t rowIdx, size_t colIdx) const;
 
    const CellProperties& cellProperties(size_t rowIdx, size_t columnIdx) const;
    void cellProperties(size_t rowIdx, size_t columnIdx, const CellProperties&);
    // FormattedTable columns
 
    size_t nColumnHeaderRows() const;
    void nColumnHeaderRows(size_t);
    const std::string& columnHeader(size_t rowIdx, size_t columnIdx) const;
    void columnHeader(size_t rowIdx, size_t columnIdx, const std::string &title);
    const CellProperties& columnHeaderProperties(size_t rowIdx, size_t columnIdx) const;
    void columnHeaderProperties(size_t rowIdx, size_t columnIdx, const CellProperties&);
    // Printing
 
    void print(std::ostream&) const;
 
private:
    std::string cellPropertiesBegin(const CellProperties&) const;
    std::string cellPropertiesEnd(const CellProperties&) const;
    void printHorizontalRule(std::ostream&, const std::vector<size_t> &widths) const;
    void printRow(std::ostream&, const std::vector<size_t> &widths, const std::vector<CellProperties> &props,
                  const std::vector<std::string> &row) const;
    std::vector<size_t> computeColumnWidths() const;
 
};
class FormattedTable {…};
 
} // namespace
 
std::ostream& operator<<(std::ostream &out, const Rose::FormattedTable &table);
 
#endif