Table Maker for Modern C++

Overview

ci status standard license version

Source for the above image can be found here

Table of Contents

Quick Start

tabulate is a header-only library. Just add include/ to your include_directories and you should be good to go. A single header file version is also available in single_include/.

NOTE Tabulate supports >=C++11. The rest of this README, however, assumes C++17 support.

Create a Table object and call Table.add_rows to add rows to your table.

#include <tabulate/table.hpp>
using namespace tabulate;

int main() {

  Table universal_constants;

  universal_constants.add_row({"Quantity", "Value"});
  universal_constants.add_row({"Characteristic impedance of vacuum", "376.730 313 461... Ω"});
  universal_constants.add_row({"Electric constant (permittivity of free space)", "8.854 187 817... × 10⁻¹²F·m⁻¹"});
  universal_constants.add_row({"Magnetic constant (permeability of free space)", "4π × 10⁻⁷ N·A⁻² = 1.2566 370 614... × 10⁻⁶ N·A⁻²"});
  universal_constants.add_row({"Gravitational constant (Newtonian constant of gravitation)", "6.6742(10) × 10⁻¹¹m³·kg⁻¹·s⁻²"});
  universal_constants.add_row({"Planck's constant", "6.626 0693(11) × 10⁻³⁴ J·s"});
  universal_constants.add_row({"Dirac's constant", "1.054 571 68(18) × 10⁻³⁴ J·s"});
  universal_constants.add_row({"Speed of light in vacuum", "299 792 458 m·s⁻¹"});

You can format this table using Table.format() which returns a Format object. Using a fluent interface, format properties of the table, e.g., borders, font styles, colors etc.

  universal_constants.format()
    .font_style({FontStyle::bold})
    .border_top(" ")
    .border_bottom(" ")
    .border_left(" ")
    .border_right(" ")
    .corner(" ");

You can access rows in the table using Table[row_index]. This will return a Row object on which you can similarly call Row.format() to format properties of all the cells in that row.

Now, let's format the header of the table. The following code changes the font background of the header row to red, aligns the cell contents to center and applies a padding to the top and bottom of the row.

  universal_constants[0].format()
    .padding_top(1)
    .padding_bottom(1)
    .font_align(FontAlign::center)
    .font_style({FontStyle::underline})
    .font_background_color(Color::red);

Calling Table.column(index) will return a Column object. Similar to rows, you can use Column.format() to format all the cells in that column.

Now, let's change the font color of the second column to yellow:

  universal_constants.column(1).format()
    .font_color(Color::yellow);

You can access cells by indexing twice from a table: From a row using Table[row_index][col_index] or from a column using Table.column(col_index)[cell_index]. Just like rows, columns, and tables, you can use Cell.format() to format individual cells

  universal_constants[0][1].format()
    .font_background_color(Color::blue)
    .font_color(Color::white);
}

Print the table using the stream operator<< like so:

  std::cout << universal_constants << std::endl;

You could also use Table.print(stream) to print the table, e.g., universal_constants.print(std::cout).

Formatting Options

Style Inheritance Model

Formatting in tabulate follows a simple style-inheritance model. When rendering each cell:

  1. Apply cell formatting if specified
  2. If no cell formatting is specified, apply its parent row formatting
  3. If no row formatting is specified, apply its parent table formatting
  4. If no table formatting is specified, apply the default table formatting

This enables overriding the formatting for a particular cell even though row or table formatting is specified, e.g., when an entire row is colored yellow but you want a specific cell to be colored red.

Word Wrapping

tabulate supports automatic word-wrapping when printing cells.

Although word-wrapping is automatic, there is a simple override. Automatic word-wrapping is used only if the cell contents do not have any embedded newline \n characters. So, you can embed newline characters in the cell contents and enforce the word-wrapping manually.

#include <tabulate/table.hpp>
using namespace tabulate;

int main() {
  Table table;

  table.add_row({"This paragraph contains a veryveryveryveryveryverylong word. The long word will "
                 "break and word wrap to the next line.",
                 "This paragraph \nhas embedded '\\n' \ncharacters and\n will break\n exactly "
                 "where\n you want it\n to\n break."});

  table[0][0].format().width(20);
  table[0][1].format().width(50);

  std::cout << table << std::endl;
}
  • The above table has 1 row and 2 columns.
  • The first cell has automatic word-wrapping.
  • The second cell uses the embedded newline characters in the cell contents - even though the second column has plenty of space (50 characters width), it uses user-provided newline characters to break into new lines and enforce the cell style.
  • NOTE: Whether word-wrapping is automatic or not, tabulate performs a trim operation on each line of each cell to remove whitespace characters from either side of line.

NOTE: Both columns in the above table are left-aligned by default. This, however, can be easily changed.

Font Alignment

tabulate supports three font alignment settings: left, center, and right. By default, all table content is left-aligned. To align cells, use .format().font_align(alignment).

#include <tabulate/table.hpp>
using namespace tabulate;

int main() {
  Table movies;
  movies.add_row({"S/N", "Movie Name", "Director", "Estimated Budget", "Release Date"});
  movies.add_row({"tt1979376", "Toy Story 4", "Josh Cooley", "$200,000,000", "21 June 2019"});
  movies.add_row({"tt3263904", "Sully", "Clint Eastwood", "$60,000,000", "9 September 2016"});
  movies.add_row({"tt1535109", "Captain Phillips", "Paul Greengrass", "$55,000,000", " 11 October 2013"});

  // center align 'Director' column
  movies.column(2).format()
    .font_align(FontAlign::center);

  // right align 'Estimated Budget' column
  movies.column(3).format()
    .font_align(FontAlign::right);

  // right align 'Release Date' column
  movies.column(4).format()
    .font_align(FontAlign::right);

  // center-align and color header cells
  for (size_t i = 0; i < 5; ++i) {
    movies[0][i].format()
      .font_color(Color::yellow)
      .font_align(FontAlign::center)
      .font_style({FontStyle::bold});
  }

  std::cout << movies << std::endl;
}

Font Styles

tabulate supports 8 font styles: bold, dark, italic, underline, blink, reverse, concealed, crossed. Depending on the terminal (or terminal settings), some of these might not work.

To apply a font style, simply call .format().font_style({...}). The font_style method takes a vector of font styles. This allows to apply multiple font styles to a cell, e.g., bold and italic.

#include <tabulate/table.hpp>
using namespace tabulate;

int main() {
  Table styled_table;
  styled_table.add_row({"Bold", "Italic", "Bold & Italic", "Blinking"});
  styled_table.add_row({"Underline", "Crossed", "Dark", "Bold, Italic & Underlined"});

  styled_table[0][0].format()
    .font_style({FontStyle::bold});

  styled_table[0][1].format()
    .font_style({FontStyle::italic});

  styled_table[0][2].format()
    .font_style({FontStyle::bold, FontStyle::italic});

  styled_table[0][3].format()
    .font_style({FontStyle::blink});

  styled_table[1][0].format()
    .font_style({FontStyle::underline});

  styled_table[1][1].format()
    .font_style({FontStyle::crossed});

  styled_table[1][2].format()
    .font_style({FontStyle::dark});


  styled_table[1][3].format()
    .font_style({FontStyle::bold, FontStyle::italic, FontStyle::underline});

  std::cout << styled_table << std::endl;

}

NOTE: Font styles are applied to the entire cell. Unlike HTML, you cannot currently apply styles to specific words in a cell.

Cell Colors

There are a number of methods in the Format object to color cells - foreground and background - for font, borders, corners, and column separators. Thanks to termcolor, tabulate supports 8 colors: grey, red, green, yellow, blue, magenta, cyan, and white. The look of these colors vary depending on your terminal.

For font, border, and corners, you can call .format().<element>_color(value) to set the foreground color and .format().<element>_background_color(value) to set the background color. Here's an example:

#include <tabulate/table.hpp>
using namespace tabulate;

int main() {
  Table colors;

  colors.add_row({"Font Color is Red", "Font Color is Blue", "Font Color is Green"});
  colors.add_row({"Everything is Red", "Everything is Blue", "Everything is Green"});
  colors.add_row({"Font Background is Red", "Font Background is Blue", "Font Background is Green"});

  colors[0][0].format()
    .font_color(Color::red)
    .font_style({FontStyle::bold});
  colors[0][1].format()
    .font_color(Color::blue)
    .font_style({FontStyle::bold});
  colors[0][2].format()
    .font_color(Color::green)
    .font_style({FontStyle::bold});

  colors[1][0].format()
    .border_left_color(Color::red)
    .border_left_background_color(Color::red)
    .font_background_color(Color::red)
    .font_color(Color::red);

  colors[1][1].format()
    .border_left_color(Color::blue)
    .border_left_background_color(Color::blue)
    .font_background_color(Color::blue)
    .font_color(Color::blue);

  colors[1][2].format()
    .border_left_color(Color::green)
    .border_left_background_color(Color::green)
    .font_background_color(Color::green)
    .font_color(Color::green)
    .border_right_color(Color::green)
    .border_right_background_color(Color::green);

  colors[2][0].format()
    .font_background_color(Color::red)
    .font_style({FontStyle::bold});
  colors[2][1].format()
    .font_background_color(Color::blue)
    .font_style({FontStyle::bold});
  colors[2][2].format()
    .font_background_color(Color::green)
    .font_style({FontStyle::bold});

  std::cout << colors << std::endl;
}

Borders and Corners

tabulate allows for fine control over borders and corners. For each border and corner, you can set the text, color, and background color.

NOTE: You can use .corner(..), .corner_color(..), and .corner_background_color(..) to set a common style for all corners. Similarly, you can use .border(..), .border_color(..) and .border_background_color(..) to set a common style for all borders.

NOTE: Note the use of .format().multi_byte_characters(true). Use this when you know your table has multi-byte characters. This is an opt-in because the calculation of column width when dealing with multi-byte characters is more involved and you don't want to pay the performance penalty unless you need it. Just like any other format setting, you can set this at the table-level, row-level, or on a per-cell basis.

Here's an example where each border and corner is individually styled:

#include <tabulate/table.hpp>
using namespace tabulate;

int main() {
  Table table;

  table.add_row({"ᛏᚺᛁᛊ ᛁᛊ ᚨ ᛊᛏᛟᚱy ᛟᚠᚨ ᛒᛖᚨᚱ ᚨᚾᛞ\n"
                 "ᚨ ᚹᛟᛚᚠ, ᚹᚺᛟ ᚹᚨᚾᛞᛖᚱᛖᛞ ᛏᚺᛖ\n"
                 "ᚱᛖᚨᛚᛗᛊ ᚾᛁᚾᛖ ᛏᛟ ᚠᚢᛚᚠᛁᛚᛚ ᚨ ᛈᚱᛟᛗᛁᛊᛖ\n"
                 "ᛏᛟ ᛟᚾᛖ ᛒᛖᚠᛟᚱᛖ; ᛏᚺᛖy ᚹᚨᛚᚲ ᛏᚺᛖ\n"
                 "ᛏᚹᛁᛚᛁᚷᚺᛏ ᛈᚨᛏᚺ, ᛞᛖᛊᛏᛁᚾᛖᛞ ᛏᛟ\n"
                 "ᛞᛁᛊcᛟᚹᛖᚱ ᛏᚺᛖ ᛏᚱᚢᛏᚺ\nᛏᚺᚨᛏ ᛁᛊ ᛏᛟ cᛟᛗᛖ."});

  table.format()
      .multi_byte_characters(true)
      // Font styling
      .font_style({FontStyle::bold, FontStyle::dark})
      .font_align(FontAlign::center)
      .font_color(Color::red)
      .font_background_color(Color::yellow)
      // Corners
      .corner_top_left("")
      .corner_top_right("")
      .corner_bottom_left("")
      .corner_bottom_right("")
      .corner_top_left_color(Color::cyan)
      .corner_top_right_color(Color::yellow)
      .corner_bottom_left_color(Color::green)
      .corner_bottom_right_color(Color::red)
      // Borders
      .border_top("")
      .border_bottom("")
      .border_left("")
      .border_right("")
      .border_left_color(Color::yellow)
      .border_right_color(Color::green)
      .border_top_color(Color::cyan)
      .border_bottom_color(Color::red);

  std::cout << table << std::endl;
}

Range-based Iteration

Hand-picking and formatting cells using operator[] gets tedious very quickly. To ease this, tabulate supports range-based iteration on tables, rows, and columns. Quickly iterate over rows and columns to format cells.

#include <tabulate/table.hpp>
using namespace tabulate;

int main() {
  Table table;

  table.add_row({"Company", "Contact", "Country"});
  table.add_row({"Alfreds Futterkiste", "Maria Anders", "Germany"});
  table.add_row({"Centro comercial Moctezuma", "Francisco Chang", "Mexico"});
  table.add_row({"Ernst Handel", "Roland Mendel", "Austria"});
  table.add_row({"Island Trading", "Helen Bennett", "UK"});
  table.add_row({"Laughing Bacchus Winecellars", "Yoshi Tannamuri", "Canada"});
  table.add_row({"Magazzini Alimentari Riuniti", "Giovanni Rovelli", "Italy"});

  // Set width of cells in each column
  table.column(0).format().width(40);
  table.column(1).format().width(30);
  table.column(2).format().width(30);

  // Iterate over cells in the first row
  for (auto& cell : table[0]) {
    cell.format()
      .font_style({FontStyle::underline})
      .font_align(FontAlign::center);
  }

  // Iterator over cells in the first column
  for (auto& cell : table.column(0)) {
    if (cell.get_text() != "Company") {
      cell.format()
        .font_align(FontAlign::right);
    }
  }

  // Iterate over rows in the table
  size_t index = 0;
  for (auto& row : table) {
    row.format()
      .font_style({FontStyle::bold});

    // Set blue background color for alternate rows
    if (index > 0 && index % 2 == 0) {
      for (auto& cell : row) {
        cell.format()
          .font_background_color(Color::blue);
      }      
    }
    index += 1;
  }

  std::cout << table << std::endl;
}

Nested Tables

Table.add_row(...) takes either a std::string or a tabulate::Table. This can be used to nest tables within tables. Here's an example program that prints a UML class diagram using tabulate. Note the use of font alignment, style, and width settings to generate a diagram that looks centered and great.

#include <tabulate/table.hpp>
using namespace tabulate;

int main() {
  Table class_diagram;

  // Global styling
  class_diagram.format().font_style({FontStyle::bold}).font_align(FontAlign::center).width(60);

  // Animal class
  Table animal;
  animal.add_row({"Animal"});
  animal[0].format().font_align(FontAlign::center);

  // Animal properties nested table
  Table animal_properties;
  animal_properties.format().width(20);
  animal_properties.add_row({"+age: Int"});
  animal_properties.add_row({"+gender: String"});
  animal_properties[1].format().hide_border_top();

  // Animal methods nested table
  Table animal_methods;
  animal_methods.format().width(20);
  animal_methods.add_row({"+isMammal()"});
  animal_methods.add_row({"+mate()"});
  animal_methods[1].format().hide_border_top();

  animal.add_row({animal_properties});
  animal.add_row({animal_methods});
  animal[2].format().hide_border_top();

  class_diagram.add_row({animal});

  // Add rows in the class diagram for the up-facing arrow
  // THanks to center alignment, these will align just fine
  class_diagram.add_row({""});
  class_diagram[1][0].format().hide_border_top().multi_byte_characters(true); // ▲ is multi-byte
  
  class_diagram.add_row({"|"});
  class_diagram[2].format().hide_border_top();
  class_diagram.add_row({"|"});
  class_diagram[3].format().hide_border_top();

  // Duck class
  Table duck;
  duck.add_row({"Duck"});
  duck[0].format().font_align(FontAlign::center);

  // Duck proeperties nested table
  Table duck_properties;
  duck_properties.format().width(40);
  duck_properties.add_row({"+beakColor: String = \"yellow\""});

  // Duck methods nested table
  Table duck_methods;
  duck_methods.format().width(40);
  duck_methods.add_row({"+swim()"});
  duck_methods.add_row({"+quack()"});
  duck_methods[1].format().hide_border_top();

  duck.add_row({duck_properties});
  duck.add_row({duck_methods});
  duck[2].format().hide_border_top();

  class_diagram.add_row({duck});
  class_diagram[4].format().hide_border_top();

  std::cout << class_diagram << std::endl;
}

UTF-8 Support

In *nix, wcswidth is used to compute the display width of multi-byte characters. Column alignment works well when your system supports the necessary locale, e.g., I've noticed on MacOS 10 there is no Arabic locale (searched with locale -a) and this ends up causing alignment issues when using Arabic text, e.g., "ٲنَا بحِبَّك (Ana bahebak)" in tables.

The following table prints the phrase I love you in different languages. Note the use of .format().multi_byte_characters(true) for the second column. Remember to do this when dealing with multi-byte characters.

#include <tabulate/table.hpp>
using namespace tabulate;

int main() {
  Table table;

  table.format().corner("")
    .font_style({FontStyle::bold})
    .corner_color(Color::magenta)
    .border_color(Color::magenta);

  table.add_row({"English", "I love you"});
  table.add_row({"French", "Je t’aime"});
  table.add_row({"Spanish", "Te amo"});
  table.add_row({"German", "Ich liebe Dich"});
  table.add_row({"Mandarin Chinese", "我爱你"});
  table.add_row({"Japanese", "愛してる"});
  table.add_row({"Korean", "사랑해 (Saranghae)"});
  table.add_row({"Greek", "Σ΄αγαπώ (Se agapo)"});
  table.add_row({"Italian", "Ti amo"});
  table.add_row({"Russian", "Я тебя люблю (Ya tebya liubliu)"});
  table.add_row({"Hebrew", "אני אוהב אותך (Ani ohev otakh)"});

  // Column 1 is using mult-byte characters
  table.column(1).format()
    .multi_byte_characters(true);

  std::cout << table << std::endl;
}

You can explicitly set the locale for a cell using .format().locale(value). Note that the locale string is system-specific. So, the following code might throw std::runtime_error locale::facet::_S_create_c_locale name not valid on your system.

  // Set English-US locale for first column
  table.column(0).format().locale("en_US.UTF-8");
  table[0][1].format().locale("en_US.UTF-8");

  // Set locale for individual cells
  table[1][1].format().locale("fr_FR.UTF-8");  // French
  table[2][1].format().locale("es_ES.UTF-8");  // Spanish
  table[3][1].format().locale("de_DE.UTF-8");  // German
  table[4][1].format().locale("zh_CN.UTF-8");  // Chinese
  table[5][1].format().locale("ja_JP.UTF-8");  // Japanese
  table[6][1].format().locale("ko_KR.UTF-8");  // Korean
  table[7][1].format().locale("el_GR.UTF-8");  // Greek
  table[8][1].format().locale("it_IT.UTF-8");  // Italian
  table[9][1].format().locale("ru_RU.UTF-8");  // Russian
  table[10][1].format().locale("he_IL.UTF-8"); // Hebrew

Exporters

Markdown

Tables can be exported to GitHub-flavored markdown using a MarkdownExporter. Simply create an exporter object and call exporter.dump(table) to generate a Markdown-formatted std::string.

#include <tabulate/markdown_exporter.hpp>
using namespace tabulate;

int main() {
  Table movies;
  movies.add_row({"S/N", "Movie Name", "Director", "Estimated Budget", "Release Date"});  
  movies.add_row({"tt1979376", "Toy Story 4", "Josh Cooley", "$200,000,000", "21 June 2019"});
  movies.add_row({"tt3263904", "Sully", "Clint Eastwood", "$60,000,000", "9 September 2016"});
  movies.add_row(
      {"tt1535109", "Captain Phillips", "Paul Greengrass", "$55,000,000", " 11 October 2013"});

  // center align 'Director' column
  movies.column(2).format().font_align(FontAlign::center);

  // right align 'Estimated Budget' column
  movies.column(3).format().font_align(FontAlign::right);

  // right align 'Release Date' column
  movies.column(4).format().font_align(FontAlign::right);

  // Color header cells
  for (size_t i = 0; i < 5; ++i) {
    movies[0][i].format().font_color(Color::yellow).font_style({FontStyle::bold});
  }

  // Export to Markdown
  MarkdownExporter exporter;
  auto markdown = exporter.dump(movies);

  // tabulate::table
  std::cout << movies << "\n\n";

  // Exported Markdown
  std::cout << markdown << std::endl;
}

The above table renders in Markdown like below.

NOTE: Unlike tabulate, you cannot align individual cells in Markdown. Alignment is on a per-column basis. Markdown allows a second header row where such column-wise alignment can be specified. The MarkdownExporter uses the formatting of the header cells in the original tabulate::Table to decide how to align each column. As per the Markdown spec, columns are left-aligned by default.

S/N Movie Name Director Estimated Budget Release Date
tt1979376 Toy Story 4 Josh Cooley $200,000,000 21 June 2019
tt3263904 Sully Clint Eastwood $60,000,000 9 September 2016
tt1535109 Captain Phillips Paul Greengrass $55,000,000 11 October 2013

AsciiDoc

Tabulate can export tables as AsciiDoc using an AsciiDocExporter.

#include <tabulate/asciidoc_exporter.hpp>
using namespace tabulate;

int main() {
  Table movies;
  movies.add_row({"S/N", "Movie Name", "Director", "Estimated Budget", "Release Date"});
  movies.add_row({"tt1979376", "Toy Story 4", "Josh Cooley", "$200,000,000", "21 June 2019"});
  movies.add_row({"tt3263904", "Sully", "Clint Eastwood", "$60,000,000", "9 September 2016"});
  movies.add_row(
      {"tt1535109", "Captain Phillips", "Paul Greengrass", "$55,000,000", " 11 October 2013"});

  // center align 'Director' column
  movies.column(2).format().font_align(FontAlign::center);

  // right align 'Estimated Budget' column
  movies.column(3).format().font_align(FontAlign::right);

  // right align 'Release Date' column
  movies.column(4).format().font_align(FontAlign::right);

  movies[1][2].format().font_style({FontStyle::bold, FontStyle::italic});
  movies[2][1].format().font_style({FontStyle::italic});

  // Color header cells
  for (size_t i = 0; i < 5; ++i) {
    movies[0][i]
        .format()
        .font_color(Color::white)
        .font_style({FontStyle::bold})
        .background_color(Color::blue);
  }

  AsciiDocExporter exporter;
  auto asciidoc = exporter.dump(movies);

  // tabulate::table
  std::cout << movies << "\n\n";

  // Exported AsciiDoc
  std::cout << asciidoc << std::endl;
}

Below is the export of the example above:

[cols="<,<,^,>,>"]
|===
|*S/N*|*Movie Name*|*Director*|*Estimated Budget*|*Release Date*

|tt1979376|Toy Story 4|*_Josh Cooley_*|$200,000,000|21 June 2019
|tt3263904|_Sully_|Clint Eastwood|$60,000,000|9 September 2016
|tt1535109|Captain Phillips|Paul Greengrass|$55,000,000| 11 October 2013
|===

The rendered output you can see here: http://tpcg.io/pbbfU3ks

NOTE Alignment is only supported per column. The font styles FontStyle::bold and FontStyle::italic can be used for each cell, also in combination.

Building Samples

There are a number of samples in the samples/ directory, e.g., Mario. You can build these samples by running the following commands.

mkdir build
cd build
cmake -DSAMPLES=ON -DUSE_CPP17=ON ..
make
./samples/mario

Note the USE_CPP17 variable. Tabulate uses std::variant and std::optional. If you do not have C++17 compiler support for these data structures, build without this flag. Tabulate will then use variant-lite and optional-lite.

Generating Single Header

python3 utils/amalgamate/amalgamate.py -c single_include.json -s .

Contributing

Contributions are welcome, have a look at the CONTRIBUTING.md document for more information.

License

The project is available under the MIT license.

Issues
  • Weird exeption when using with OpenGL 4.3

    Weird exeption when using with OpenGL 4.3

    Whenever I try to create a table and show it, it will do so. But then it will throw me an exception in my case that the position of my OpenGL framebuffer object could not be read. I tried both c++14 and c++17 and it's a x64 bit executable if that matters.

    (Win32): "C:\Windows\System32\TextInputFramework.dll" loaded. Exception thrown at 0x00007FF6D4FC4D3E in .exe: 0xC0000005: access violation at position 0x0000000000000000.

    opened by ENGY-ORG 6
  • How to give array as an input in table.add_row()?

    How to give array as an input in table.add_row()?

    Hey just want to know is there any facility to pass an array or vector to table.add_row() so that required row is generated from arrray/vector itself?

    opened by shie-ld 5
  • Put

    Put "requires C++17" with variant and optional utilities support

    Modern C++ is C++17 however on the internet "modern" is synonymous with C++11 at minimum. I didn't see any notes anywhere trying to compile but #include <variant> and #include <optional> gave it away...

    On that same note, my mingw tools for gcc on windows have the std::optional utility under experimental/*.

    I don't think there's a substitute for variant under experimental but a way to be able to swap it out (and optional too) for a custom structures could be achieved for those < C++17. Variants and optional are very simple structures. They're not fundamentally difficult to write and would open the lib up to C++14 at least.

    opened by TheMaverickProgrammer 5
  • Question - Dynamically Change the tables Content

    Question - Dynamically Change the tables Content

    Dear Contributors,

    Thanks for your useful library, I am trying to use this table objects in real-time terminal application and show the columns contents dynamically, when they changed, for example during the execution the contents of tables needs to change (like top command it refreshed the generated output), is it possible to do it ?

    Thanks :)

    opened by mohsenomidi 4
  • format border commands have no effect

    format border commands have no effect

    I'm trying to print tables without any border characters. When I use the .format().border_top(" ") etc type of commands, it has no effect and always prints the default +----+ type borders. Similarly using output_table.format().hide_border(); also has no effect, and still prints with the default borders. Am I using this wrong or is it a bug?

    opened by mlohry 4
  • New tagged version on github?

    New tagged version on github?

    Hey @p-ranav, would be nice to have a new version of tabulate on conda :)

    I can of course create the new version on conda, but for that I need a new tagged version on github.

    Lemme know if you want any help to get this going.

    Thanks!

    opened by marimeireles 3
  • add_row signature changed in a backward-incompatible way in 1.3

    add_row signature changed in a backward-incompatible way in 1.3

    First, we are super grateful for this package which is super nice!

    FYI, it seems that this change is backward incompatible because of the change in the signature.

    Maybe this should have been a 2.0 change?

    Ping @marimeireles

    opened by SylvainCorlay 3
  • Make tabulate compatible with mac's SDK 10.9

    Make tabulate compatible with mac's SDK 10.9

    In our project we have a restriction that doesn't allow us to use a macOS SDK older than 10.9. The problem is that 10.9 doesn't offer full support to c++ 17 features, so things like optional and variant won't work well.

    In order for it to work in 10.9 I had to make some changes, there is no value() method for optional and no get for variant, fortunately it's possible to use the equivalents * and get_info, and that's what I'm doing in this PR.

    opened by marimeireles 3
  • Issues I'm facing

    Issues I'm facing

    Hello, what am I doing wrong? The special characters, emoji and table graph are incorrect picture: https://i.imgur.com/f0Fj1Fe.png

    the github link isn't underlined or in italic either. Usual visual studio 16.0.29709

    ps. is there a single header available?

    opened by Indra-db 3
  • Using tabulate in different Translation Unit leads to multiple definition at link time

    Using tabulate in different Translation Unit leads to multiple definition at link time

    Use Tabulate in two different .cpp and link the result leads to multiple definition errors. I think most of the functions in the header shoudl be marked inline.

    opened by jfalcou 3
  • How to add a row from a vector?

    How to add a row from a vector?

    I know that we can do this: tabulate::Table t; t.add_row({"col1", "col2"}); But how can I add existing data into the table? Say I have a variable named data, whose type is vector and I would like to add it to the table, how do I write the code? The following code won't compile: t.add_row(data)

    opened by pthreadself 2
  • Hide border doesn't affect the output once the table has been printed

    Hide border doesn't affect the output once the table has been printed

    Hello there,

    Thanks very much for this library. I'm working on bindings for the R language. I encountered this behavior where modifying hide_border_bottom() won't modify the output if the table has been printed some time before.

    For example:

    #include <tabulate/table.hpp>
    using namespace tabulate;
    using Row_t = Table::Row_t;
    
    int main() {
      Table table;
      table.add_row(Row_t{"hello"});
      table.add_row(Row_t{"world"});
    
      std::cout << table << std::endl;
    
      table.format().hide_border_bottom();
    
      std::cout << table << std::endl;
    
      table.format().width(50);
    
      std::cout << table << std::endl;
    }
    

    Returns:

    +-------+
    | hello |
    +-------+
    | world |
    +-------+
    +-------+
    | hello |
    +-------+
    | world |
    +-------+
    +--------------------------------------------------+
    | hello                                            |
    +--------------------------------------------------+
    | world                                            |
    +--------------------------------------------------+
    
    opened by dfalbel 0
  • Support true color and colorful markdown

    Support true color and colorful markdown

    1. Support True Color via ANSI escape sequences foreground color: CSI 38 : 2 : r : g : b m backround color: CSI 48 : 2 : r : g : b m
    2. Colorful markdown with embedded html ..... or markdown builtin syntax

    FYI, https://github.com/vxfury/tabulate.git

    opened by vxfury 0
  • std::cout << tab really slow?

    std::cout << tab really slow?

    Hi, tabulate is very beatiful.

    but compare with plain cout, it seems much slower.

    my plain cout cost 0.002s but after i use tabulate, it cost 0.05 about 25 times comparing with plain.

    Is there any method to speed up?

    ps. i always use tabulate to show a stl map. using table, add key row and column row, set some show style.

    Did i miss anything?

    thanks

    ps. this is my show code:

    #pragma once
    #include <unordered_map>
    #include <iomanip>
    #include <locale>
    #include <iostream>
    #include <tabulate.hpp>
    
    namespace util {
      namespace visual {
        template<class Key>
        std::vector<std::string> unfold(const std::pair<const Key, std::string>& p) {
          std::stringstream key_stream, val_stream;
          std::locale loc("C");
          key_stream.imbue(loc); val_stream.imbue(loc);
          const Key& key = p.first; const std::string& val = p.second;
          key_stream << key;
          val_stream << val;
          return {key_stream.str(), val_stream.str()};
        }
    
        template<class Key, class Value>
        std::vector<std::string> unfold(const std::pair<const Key, Value>& p) {
          std::stringstream key_stream, val_stream;
          std::locale loc("C");
          key_stream.imbue(loc); val_stream.imbue(loc);
          const Key& key = p.first; const Value& val = p.second;
          // printf("key = %d, val = %d\n", std::is_same<typename std::decay<Key>::type, std::string>::value, std::is_same<typename std::decay<Value>::type, std::string>::value);
          key_stream << key;
          if (val > 10 || val < -10) val_stream << (int64_t)val;
          else val_stream << std::fixed << std::setprecision(2) << val;
          return {key_stream.str(), val_stream.str()};
        }
    
        inline std::vector<std::string> unfold(const std::string & val) { return {val}; }
    
        template<typename T>
        void show(const T &m, const std::string& color="", const std::string& header = "") {
          std::cout.sync_with_stdio(false);
          std::cin.tie(nullptr);
          if (m.empty()) return;
          tabulate::Table tab;
          std::vector<std::vector<variant<std::string, const char *, tabulate::Table> > > vals;
          vals.resize(2);
          size_t count_ = 0;
          for (const auto & i : m) {
            const auto & j = unfold(i);
            size_t count = 0;
          for (const auto & i : m) {
            const auto & j = unfold(i);
            size_t count = 0;
            for (const auto& k : j) { /*printf("count=%d k=%s\n", count, k.c_str());*/ vals[count++].push_back(k); }
            count_ = count;
          }
          for (size_t i = 0 ; i < count_; ++i) tab.add_row(vals[i]);
          for (size_t i = 0; i < m.size(); ++i) {
            if (color == "red") tab[0][i].format().font_color(tabulate::Color::red).font_align(tabulate::FontAlign::center).font_style({tabulate::FontStyle::bold});
            else if (color == "green") tab[0][i].format().font_color(tabulate::Color::green).font_align(tabulate::FontAlign::center).font_style({tabulate::FontStyle::bold});
            else if (color == "yellow") tab[0][i].format().font_color(tabulate::Color::yellow).font_align(tabulate::FontAlign::center).font_style({tabulate::FontStyle::bold});
            else if (color == "blue") tab[0][i].format().font_color(tabulate::Color::blue).font_align(tabulate::FontAlign::center).font_style({tabulate::FontStyle::bold});
            else if (color == "magenta") tab[0][i].format().font_color(tabulate::Color::magenta).font_align(tabulate::FontAlign::center).font_style({tabulate::FontStyle::bold});
            else if (color == "cyan") tab[0][i].format().font_color(tabulate::Color::cyan).font_align(tabulate::FontAlign::center).font_style({tabulate::FontStyle::bold});
            else tab[0][i].format().font_align(tabulate::FontAlign::center).font_style({tabulate::FontStyle::bold});
          }
          if (vals.size() > 1) {
            auto & columns = tab.row(0);
            size_t count = 0;
            for (auto& c: columns) {
              const std::string& col = c.get_text();
              if (col.find("PNL") != std::string::npos) tab.column(count).format().width(12);
              if (col.find("MAX") != std::string::npos) tab.column(count).format().width(10);
              count++;
            }
          }
          for (size_t i = 0; i < m.size(); ++i) tab.column(i).format().font_align(tabulate::FontAlign::center);
          if (!header.empty()) std::cout << header << std::endl;
          std::cout << tab << std::endl;
        }
      }
    }
     
    
    
    
    opened by nickhuangxinyu 0
  • Possibility to merge cells?

    Possibility to merge cells?

    Hi, very nice project. Considering to use it in my own. I was wondering whether it is possible to merge cells, like multicol or multirow stuff. E.g. table with 4 columns, and I want to merge col 1 and 2 into single column for selected rows. Somehow did not found it in the examples.

    opened by rlalik 2
  • Color is not working in nested tables

    Color is not working in nested tables

    When I try to put a Table with a colored cell into another Table the color is not working anymore.

    Here is an example:

    #include "tabulate/tabulate.hpp"
    #include <iostream>
    
    int main()
    {
        using namespace tabulate;
    
        Table inner;
        inner.add_row({"A"});
        inner[0][0].format().font_color(Color::green);
        std::cout << "Here 'A' is green:\n" << inner << std::endl;
    
        Table outer;
        outer.add_row({inner});
        std::cout << "Here 'A' is not green:\n" << outer << std::endl;
        return 0;
    }
    

    which gives the following output on Ubuntu:

    Here 'A' is green:
    +---+
    | A |
    +---+
    Here 'A' is not green:
    +-------+
    | +---+ |
    | | A | |
    | +---+ |
    +-------+
    
    opened by maximiliank 5
  • Is it possible to print table rows sequentially?

    Is it possible to print table rows sequentially?

    Is there a possibility to update the table via adding new rows and flushing them to the standard output during runtime?

    The idea is:

    1. Firstly, i added the header row and printed it.
    2. Then made some computations, added a row to the table, then printed that row.
    3. And so on...

    I checked the issue #53, but it's not actually what i am looking for.

    opened by jellythefish 1
Releases(v1.4)
Owner
Pranav
Pranav
File's sizes as a markdown table (CLI)

File's sizes as a markdown table (CLI)

Reaper 5 Feb 6, 2022
A library for interactive command line interfaces in modern C++

cli A cross-platform header only C++14 library for interactive command line interfaces (Cisco style) Features Header only Cross-platform (linux and wi

Daniele Pallastrelli 782 May 9, 2022
Activity Indicators for Modern C++

Highlights Thread-safe progress bars and spinners Header-only library. Grab a copy of include/indicators. Single-header version in single_include/indi

Pranav 2k May 17, 2022
Contour - A modern C++ Terminal Emulator

contour is a modern terminal emulator, for everyday use. It is aiming for power users with a modern feature mindset.

Contour Terminal Emulator 805 May 10, 2022
ssheven - A modern SSH client for Mac OS 7/8/9.

ssheven - A modern SSH client for Mac OS 7/8/9.

null 434 May 11, 2022
Argument Parser for Modern C++

Highlights Single header file Requires C++17 MIT License Quick Start Simply include argparse.hpp and you're good to go. #include <argparse/argparse.hp

Pranav 1.1k May 14, 2022
easy to use, powerful & expressive command line argument parsing for modern C++ / single header / usage & doc generation

clipp - command line interfaces for modern C++ Easy to use, powerful and expressive command line argument handling for C++11/14/17 contained in a sing

André Müller 872 May 11, 2022
A modern frontend for Neovim.

A modern frontend for Neovim.

Rohit Pradhan 1.5k May 10, 2022
Free open-source modern C++17 / C++20 framework to create console, forms (GUI like WinForms) and unit test applications on Microsoft Windows, Apple macOS and Linux.

xtd Modern C++17/20 framework to create console (CLI), forms (GUI like WinForms) and tunit (unit tests like Microsoft Unit Testing Framework) applicat

Gammasoft 292 May 14, 2022
Modern C++ Undo / Redo framework

History Hello Developers! I present to you History, a modern C++ (C++17) Undo / Redo framework. My goal was to create a non-intrusive, compact and int

null 14 Jan 11, 2022
Table Maker for Modern C++

Source for the above image can be found here Table of Contents Quick Start Formatting Options Style Inheritance Model Word Wrapping Font Alignment Fon

Pranav 1.2k May 17, 2022
Table Maker for Modern C++

Source for the above image can be found here Table of Contents Quick Start Formatting Options Style Inheritance Model Word Wrapping Font Alignment Fon

Pranav 1.2k May 15, 2022
Minimalist video maker -- simplify your music score video making process!

VisualScores 极简视频制作程序,简化你的乐谱视频制作! 如果需要编译,请解压 lib 文件夹中压缩包。 使用前请参考 manual 文件夹中的用户手册。 请勿修改、移动或删除 resource 文件夹中的任何文件。 VisualScores Minimalist video maker

Chen and Sim 5 Jan 11, 2022
KEM Keyboard Extender Maker

KEM Keyboard Extender Maker KEM Keyboard Extender Maker Las principales características de KE-M son: 8 teclas configurables en dos posibles modos: --

akirasan 5 Apr 6, 2022
A header maker, this project will create your header file with all your declaration in

Headermaker Install: git clone https://github.com/rmechety42/Headermaker.git cd Headermaker make install Usage: Headermaker src_folder_you_want_to

Rayan Mechety 33 Apr 10, 2022
Maker of special .exe, which contains additional files which are unpacked when .exe is run

exe-archivator Program that make exec-me.exe, which contains additional files which are unpacked when exec-me.exe is run. After compleating unpacking

Roman Karetnikov 4 Dec 17, 2021
Level viewer for Super Mario Maker 2, based on JiXiaomai's work

Toost Level viewer for Super Mario Maker 2, based on JiXiaomai's work How to build If building for desktop, obtain development files for sdl2, glew, g

TheGreatRambler 45 May 4, 2022
Lectronizer - A client for the lectronz.com maker marketplace.

Lectronizer A client for the lectronz.com maker marketplace. Still in early development. Many things might not work or be broken.

arturo182 6 Feb 18, 2022
A fast hash map/hash table (whatever you want to call it) for the C programming language.

C HashMap A fast hash map/hash table (whatever you want to call it) for the C programming language. It can associate a key with a pointer or integer v

Mashpoe 59 May 17, 2022
ESE is an embedded / ISAM-based database engine, that provides rudimentary table and indexed access.

Extensible-Storage-Engine A Non-SQL Database Engine The Extensible Storage Engine (ESE) is one of those rare codebases having proven to have a more th

Microsoft 778 May 7, 2022
Simple hash table implemented in C

Simple hash table written in C. To go with my article How to implement a hash table (in C). This is a learning exercise, not a battle-tested data stru

Ben Hoyt 62 May 9, 2022
The simple UEFI application to create a Windows Platform Binary Table (WPBT) from the UEFI shell.

WPBT Builder This is a simple UEFI application to create a Windows Platform Binary Table (WPBT) from the UEFI shell. Motivation WPBT is one of the Adv

Satoshi Tanda 57 Feb 7, 2022
simple hash table linear probing method can expand/reduce

hash table a simple c hash table implementation based on https://benhoyt.com/writings/hash-table-in-c/ project can store different data types (data al

Fabio Murer 1 Oct 3, 2021
Explore building a hash table with two different hash functions that balances chain length

hash-duo Explore building a hash table with two different hash functions that balances chain length. There is a really cool article called Don't Throw

Terence Parr 3 May 7, 2022
Code for our ECE445/ME470 design: Wireless Charging Table with Automatic Alignment

Qi Wireless Charging Table with Automatic Alignment Code for ECE445/ME470 Senior Design Project SP21 at ZJUI. Team 24: Kaiwen Cao, Tianyi Han, Tingkai

Zikai Liu 2 May 1, 2022
Project uses an Arduino Leonardo to interface an A1UP Street Fighter Table controller boards with a pc.

Street Fighter Arcade1Up Table Arduino Interface Goal of this project Arcade1Up uses proprietary circuit boards to interface with the game's circuit b

Christopher Perkins 1 Oct 27, 2021
Code for an air hockey table for an engineering project.

Project: Air Hockey Table Code for an air hockey table. Step 1: Installation Step 2: Assemble the circuit Assemble the circuit following the diagram l

William Rice 3 Jan 21, 2022
File table expansion for The Legend of Zelda: Ocarina of Time.

z64ext <z64.me> SYNOPSIS z64ext is a file table expansion patch for The Legend of Zelda: Ocarina of Time. It is meant to be used in tandem

z64me 1 Nov 2, 2021
About A TreeSitter parser for Neorg's `table` Tag

NFF Table-Tag TreeSitter Parser A TreeSitter grammar for Neorg's table format. Available Commands Command Result yarn installs needed dependencies (on

Neorg 7 Feb 12, 2022