ulvis.paste.net - pastebin

Paste Search Dynamic
Recent pastes
table.ruler
  1. #pragma once
  2. #include <iostream>
  3. #include <map>
  4. #include <iomanip>
  5. #include <vector>
  6. #include <string>
  7.  
  8. namespace texttable {
  9.         class TextTable {
  10.  
  11.         public:
  12.                 enum Alignment { LEFT, RIGHT };
  13.                 typedef std::vector< std::string > Row;
  14.                 TextTable(char horizontal = '-', char vertical = '|', char corner = '+') :
  15.                         _horizontal(horizontal),
  16.                         _vertical(vertical),
  17.                         _corner(corner)
  18.                 {}
  19.  
  20.                 void setAlignment(unsigned i, Alignment alignment)
  21.                 {
  22.                         _alignment[i] = alignment;
  23.                 }
  24.  
  25.                 Alignment alignment(unsigned i) const
  26.                 {
  27.                         return _alignment[i];
  28.                 }
  29.  
  30.                 char vertical() const
  31.                 {
  32.                         return _vertical;
  33.                 }
  34.  
  35.                 char horizontal() const
  36.                 {
  37.                         return _horizontal;
  38.                 }
  39.  
  40.                 void add(std::string const & content)
  41.                 {
  42.                         _current.push_back(content);
  43.                 }
  44.  
  45.                 void endOfRow()
  46.                 {
  47.                         _rows.push_back(_current);
  48.                         _current.assign(0, "");
  49.                 }
  50.  
  51.                 template <typename Iterator>
  52.                 void addRow(Iterator begin, Iterator end)
  53.                 {
  54.                         for (auto i = begin; i != end; ++i) {
  55.                                 add(*i);
  56.                         }
  57.                         endOfRow();
  58.                 }
  59.  
  60.                 template <typename Container>
  61.                 void addRow(Container const & container)
  62.                 {
  63.                         addRow(container.begin(), container.end());
  64.                 }
  65.  
  66.                 std::vector< Row > const & rows() const
  67.                 {
  68.                         return _rows;
  69.                 }
  70.  
  71.                 void setup() const
  72.                 {
  73.                         determineWidths();
  74.                         setupAlignment();
  75.                 }
  76.  
  77.                 std::string ruler() const
  78.                 {
  79.                         std::string result;
  80.                         result += _corner;
  81.                         for (auto width = _width.begin(); width != _width.end(); ++width) {
  82.                                 result += repeat(*width, _horizontal);
  83.                                 result += _corner;
  84.                         }
  85.  
  86.                         return result;
  87.                 }
  88.  
  89.                 int width(unsigned i) const
  90.                 {
  91.                         return _width[i];
  92.                 }
  93.  
  94.         private:
  95.                 char _horizontal;
  96.                 char _vertical;
  97.                 char _corner;
  98.                 Row _current;
  99.                 std::vector< Row > _rows;
  100.                 std::vector< unsigned > mutable _width;
  101.                 std::map< unsigned, Alignment > mutable _alignment;
  102.  
  103.                 static std::string repeat(unsigned times, char c)
  104.                 {
  105.                         std::string result;
  106.                         for (; times > 0; --times)
  107.                                 result += c;
  108.  
  109.                         return result;
  110.                 }
  111.  
  112.                 unsigned columns() const
  113.                 {
  114.                         return _rows[0].size();
  115.                 }
  116.  
  117.                 void determineWidths() const
  118.                 {
  119.                         _width.assign(columns(), 0);
  120.                         for (auto rowIterator = _rows.begin(); rowIterator != _rows.end(); ++rowIterator) {
  121.                                 Row const & row = *rowIterator;
  122.                                 for (unsigned i = 0; i < row.size(); ++i) {
  123.                                         _width[i] = _width[i] > row[i].size() ? _width[i] : row[i].size();
  124.                                 }
  125.                         }
  126.                 }
  127.  
  128.                 void setupAlignment() const
  129.                 {
  130.                         for (unsigned i = 0; i < columns(); ++i) {
  131.                                 if (_alignment.find(i) == _alignment.end()) {
  132.                                         _alignment[i] = Alignment::LEFT;
  133.                                 }
  134.                         }
  135.                 }
  136.         };
  137.  
  138.         static std::ostream & operator<<(std::ostream & stream, TextTable const & table)
  139.         {
  140.                 table.setup();
  141.                 stream << table.ruler() << "\n";
  142.                 for (auto rowIterator = table.rows().begin(); rowIterator != table.rows().end(); ++rowIterator) {
  143.                         TextTable::Row const & row = *rowIterator;
  144.                         stream << table.vertical();
  145.                         for (unsigned i = 0; i < row.size(); ++i) {
  146.                                 auto alignment = table.alignment(i) == TextTable::Alignment::LEFT ? std::left : std::right;
  147.                                 stream << std::setw(table.width(i)) << alignment << row[i];
  148.                                 stream << table.vertical();
  149.                         }
  150.                         stream << "\n";
  151.                         stream << table.ruler() << "\n";
  152.                 }
  153.  
  154.                 return stream;
  155.         }
  156. }
Parsed in 0.024 seconds