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 Alignment {
        LEFT,                                           
        RIGHT,                                          
        CENTER                                          
    };

    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);
    };

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, const CellProperties &prop) {
        insert(rowIdx, columnIdx, boost::lexical_cast<std::string>(value), 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;

};

} // namespace

std::ostream& operator<<(std::ostream &out, const Rose::FormattedTable &table);

#endif