Table.hpp

Go to the documentation of this file.

#pragma once
 
#include <string>
#include <vector>

namespace ppforest2::io::layout {
  enum class Align { left, right };

  inline int visual_width(std::string const& s) {
    int width      = 0;
    bool in_escape = false;
 
    for (char c : s) {
      if (in_escape) {
        if (c == 'm')
          in_escape = false;
      } else if (c == '\033') {
        in_escape = true;
      } else {
        ++width;
      }
    }
 
    return width;
  }

  inline std::string pad(std::string const& s, int width, Align align = Align::right) {
    int gap = width - visual_width(s);
 
    if (gap <= 0)
      return s;
 
    std::string spaces(static_cast<std::size_t>(gap), ' ');
 
    return align == Align::right ? spaces + s : s + spaces;
  }

  struct Column {
    std::string label;
    int width;
    Align align  = Align::right;
    bool enabled = true;
  };

  using Row = std::vector<std::string>;

  inline std::string format_row(std::vector<Column> const& columns, Row const& cells, std::string const& sep = "  ") {
    std::string line;
    bool first = true;
 
    for (std::size_t i = 0; i < columns.size() && i < cells.size(); ++i) {
      if (!columns[i].enabled) {
        continue;
      }
 
      if (!first) {
        line += sep;
      }
 
      first = false;
      line += pad(cells[i], columns[i].width, columns[i].align);
    }
 
    return line;
  }

  inline std::string format_separator(std::vector<Column> const& columns, std::string const& sep = "  ") {
    int total  = 0;
    bool first = true;
 
    for (std::size_t i = 0; i < columns.size(); ++i) {
      if (!columns[i].enabled) {
        continue;
      }
 
      if (!first) {
        total += static_cast<int>(sep.size());
      }
 
      first = false;
      total += columns[i].width;
    }
 
    return std::string(static_cast<std::size_t>(total), '-');
  }

  inline Row header_labels(std::vector<Column> const& columns) {
    Row labels;
    labels.reserve(columns.size());
 
    for (auto const& col : columns) {
      labels.push_back(col.label);
    }
 
    return labels;
  }

  inline std::string format_md_row(Row const& cells, std::vector<Column> const& columns = {}) {
    std::string line = "|";
 
    for (std::size_t i = 0; i < cells.size(); ++i) {
      if (!columns.empty() && i < columns.size() && !columns[i].enabled) {
        continue;
      }
 
      line += " " + cells[i] + " |";
    }
 
    return line;
  }

  inline std::string format_md_separator(std::vector<Column> const& columns) {
    std::string line = "|";
 
    for (auto const& col : columns) {
      if (!col.enabled) {
        continue;
      }
 
      line += (col.align == Align::right) ? "---:|" : ":---|";
    }
 
    return line;
  }
}