TextTable.h

#pragma once

#include <iostream>
#include <map>
#include <iomanip>
#include <vector>
#include <string>

class TextTable {

public:
    enum class Alignment { LEFT, RIGHT };
    typedef std::vector< std::string > Row;
    TextTable(char horizontal = '-', char vertical = '|', char corner = '+') :
        _horizontal(horizontal),
        _vertical(vertical),
        _corner(corner)
    {}

    void setAlignment(unsigned i, Alignment alignment)
    {
        _alignment[i] = alignment;
    }

    Alignment alignment(unsigned i) const
    {
        return _alignment[i];
    }

    char vertical() const
    {
        return _vertical;
    }

    char horizontal() const
    {
        return _horizontal;
    }

    void add(std::string const& content)
    {
        _current.push_back(content);
    }

    void endOfRow()
    {
        _rows.push_back(_current);
        _current.assign(0, "");
    }

    template <typename Iterator>
    void addRow(Iterator begin, Iterator end)
    {
        for (auto i = begin; i != end; ++i) {
            add(*i);
        }
        endOfRow();
    }

    template <typename Container>
    void addRow(Container const& container)
    {
        addRow(container.begin(), container.end());
    }

    std::vector< Row > const& rows() const
    {
        return _rows;
    }

    void setup() const
    {
        determineWidths();
        setupAlignment();
    }

    std::string ruler() const
    {
        std::string result;
        result += _corner;
        for (auto width = _width.begin(); width != _width.end(); ++width) {
            result += repeat(*width, _horizontal);
            result += _corner;
        }

        return result;
    }

    int width(unsigned i) const
    {
        return _width[i];
    }

private:
    char _horizontal;
    char _vertical;
    char _corner;
    Row _current;
    std::vector< Row > _rows;
    std::vector< unsigned > mutable _width;
    std::map< unsigned, Alignment > mutable _alignment;

    static std::string repeat(unsigned times, char c)
    {
        std::string result;
        for (; times > 0; --times)
            result += c;

        return result;
    }

    unsigned columns() const
    {
        return _rows[0].size();
    }

    void determineWidths() const
    {
        _width.assign(columns(), 0);
        for (auto rowIterator = _rows.begin(); rowIterator != _rows.end(); ++rowIterator) {
            Row const& row = *rowIterator;
            for (unsigned i = 0; i < row.size(); ++i) {
                _width[i] = _width[i] > row[i].size() ? _width[i] : row[i].size();
            }
        }
    }

    void setupAlignment() const
    {
        for (unsigned i = 0; i < columns(); ++i) {
            if (_alignment.find(i) == _alignment.end()) {
                _alignment[i] = Alignment::LEFT;
            }
        }
    }
};

inline std::ostream& operator<<(std::ostream& stream, TextTable const& table)
{
    table.setup();
    stream << table.ruler() << "\n";
    for (auto rowIterator = table.rows().begin(); rowIterator != table.rows().end(); ++rowIterator) {
        TextTable::Row const& row = *rowIterator;
        stream << table.vertical();
        for (unsigned i = 0; i < row.size(); ++i) {
            auto alignment = table.alignment(i) == TextTable::Alignment::LEFT ? std::left : std::right;
            stream << std::setw(table.width(i)) << alignment << row[i];
            stream << table.vertical();
        }
        stream << "\n";
        stream << table.ruler() << "\n";
    }

    return stream;
}