display.hpp

Go to the documentation of this file.

#pragma once
 
#include "presentation.hpp"
 
#include <fmt/core.h>
#include <fmt/format.h>
 
#include <cstddef>
#include <functional>
#include <initializer_list>
#include <optional>
#include <source_location>
#include <string>
#include <string_view>
#include <type_traits>
#include <utility>
#include <variant>
#include <vector>
 
namespace uni20::display
{
 
enum class stream
{
  out,
  err
};
 
enum class column_width_mode
{
  fixed,
  share,
  fit
};
 
struct column_width
{
    column_width_mode mode = column_width_mode::share;
    std::size_t value = 1;
    std::size_t minimum = 1;
};
 
namespace width
{
[[nodiscard]] column_width fixed(std::size_t cells);
 
[[nodiscard]] column_width share(std::size_t weight = 1, std::size_t minimum = 1);
 
[[nodiscard]] column_width fit(std::size_t minimum = 1);
} // namespace width
 
enum class column_value_kind
{
  automatic,
  text,
  number
};
 
struct column_format
{
    column_value_kind kind = column_value_kind::automatic;
    std::string pattern = "{}";
    terminal::TerminalStyle style = {};
    terminal::TerminalStyle exception_style = {};
    std::size_t minimum_width = 0;
};
 
namespace format
{
[[nodiscard]] column_format text(terminal::TerminalStyle style = {});
 
[[nodiscard]] column_format number(std::string pattern = "{}", terminal::TerminalStyle style = {});
 
[[nodiscard]] column_format fixed(int precision, terminal::TerminalStyle style = {});
 
[[nodiscard]] column_format scientific(int precision, terminal::TerminalStyle style = {});
 
[[nodiscard]] column_format general(int precision, terminal::TerminalStyle style = {});
} // namespace format
 
struct formatted_cell
{
    presentation::styled_text text;
    bool decimal_candidate = false;
    bool decimal_exception = false;
    bool keep_together = false;
};
 
using event_content = std::variant<presentation::styled_text, presentation::report_builder>;
 
struct event
{
    stream destination = stream::err;
    event_content content;
    bool newline = true;
    std::string context;
    std::source_location where;
    bool preserve_layout = false;
};
 
using sink = std::function<void(event const&)>;
 
template <typename... Args> struct format_string
{
    fmt::format_string<Args...> format;
    std::source_location where;
 
    template <typename String>
    consteval format_string(String const& value, std::source_location location = std::source_location::current())
        : format(value), where(location)
    {}
};
 
template <typename... Args> using checked_format_string = std::type_identity_t<format_string<Args...>>;
 
void set_sink(sink replacement);
 
void reset_sink();
 
[[nodiscard]] sink current_sink();
 
class scoped_sink {
  public:
    explicit scoped_sink(sink replacement);
    scoped_sink(scoped_sink const&) = delete;
    scoped_sink& operator=(scoped_sink const&) = delete;
    scoped_sink(scoped_sink&& other) noexcept;
    scoped_sink& operator=(scoped_sink&& other) noexcept;
    ~scoped_sink();
 
  private:
    sink previous_;
    bool active_ = true;
};
 
class streaming_table {
  public:
    explicit streaming_table(std::string title = {}, stream destination = stream::out);
 
    streaming_table& column(std::string heading, column_width width_spec = width::share(),
                            presentation::table_alignment alignment = presentation::table_alignment::right,
                            column_format format = {});
    streaming_table& column(std::string heading, presentation::table_alignment alignment);
    streaming_table& column(std::string heading, column_format format);
    streaming_table& column(std::string heading, column_width width_spec, column_format format);
    streaming_table& column(std::string heading, presentation::table_alignment alignment, column_format format);
    streaming_table& wrap_width(std::size_t width);
    streaming_table& header_separator(bool enabled = true);
    streaming_table& output(sink destination, presentation::output_policy policy);
 
    void row(std::vector<formatted_cell> cells, std::source_location where = std::source_location::current());
 
    void row(std::vector<presentation::styled_text> cells,
             std::source_location where = std::source_location::current());
    void row(std::vector<std::string> cells, std::source_location where = std::source_location::current());
    void row(std::initializer_list<std::string> cells, std::source_location where = std::source_location::current());
 
    template <typename... Values> void row(Values&&... values);
 
  private:
    struct column_spec
    {
        std::string heading;
        column_width width;
        presentation::table_alignment alignment = presentation::table_alignment::right;
        column_format format;
    };
 
    std::string title_;
    stream destination_ = stream::out;
    presentation::output_policy policy_;
    std::vector<column_spec> columns_;
    std::vector<std::size_t> widths_;
    std::vector<std::optional<std::size_t>> decimal_positions_;
    bool header_separator_ = true;
    bool header_emitted_ = false;
    bool widths_resolved_ = false;
    bool vertical_fallback_ = false;
    sink output_ = {};
 
    void ensure_can_change_schema() const;
    void resolve_widths();
    void expand_fit_columns(std::vector<formatted_cell> const& cells);
    void emit_rows(std::vector<formatted_cell> const& cells, std::source_location where);
    void emit_text(presentation::styled_text text, bool newline, std::source_location where);
};
 
[[nodiscard]] streaming_table table(std::string title = {}, stream destination = stream::out);
 
template <typename... Args>
[[nodiscard]] presentation::styled_text status_cell(presentation::semantic_glyph glyph,
                                                    checked_format_string<Args...> format, Args&&... args);
 
void emit(presentation::styled_text text, stream destination = stream::err, bool newline = true,
          std::source_location where = std::source_location::current());
 
void emit(presentation::report_builder report, stream destination = stream::err, bool newline = true,
          std::source_location where = std::source_location::current());
 
template <typename... Args>
void status(presentation::semantic_glyph glyph, checked_format_string<Args...> format, Args&&... args);
 
template <typename... Args> void info(checked_format_string<Args...> format, Args&&... args);
 
template <typename... Args> void success(checked_format_string<Args...> format, Args&&... args);
 
template <typename... Args> void warning(checked_format_string<Args...> format, Args&&... args);
 
template <typename... Args> void failure(checked_format_string<Args...> format, Args&&... args);
 
template <typename... Args> void fatal(checked_format_string<Args...> format, Args&&... args);
 
template <typename... Args> void partial(checked_format_string<Args...> format, Args&&... args);
 
template <typename... Args> void deferred(checked_format_string<Args...> format, Args&&... args);
 
template <typename... Args> void skipped(checked_format_string<Args...> format, Args&&... args);
 
namespace detail
{
[[nodiscard]] terminal::TerminalStyle status_style(presentation::semantic_glyph glyph);
 
template <typename T>
inline constexpr bool display_numeric_value =
    std::is_arithmetic_v<std::remove_cvref_t<T>> && !std::is_same_v<std::remove_cvref_t<T>, bool> &&
    !std::is_same_v<std::remove_cvref_t<T>, char> && !std::is_same_v<std::remove_cvref_t<T>, signed char> &&
    !std::is_same_v<std::remove_cvref_t<T>, unsigned char>;
 
[[nodiscard]] inline bool expects_number(column_format const& format)
{
  return format.kind == column_value_kind::number;
}
 
[[nodiscard]] inline formatted_cell make_text_cell(presentation::styled_text value, column_format const& format = {})
{
  auto const exception = expects_number(format);
  return formatted_cell{.text = std::move(value), .decimal_candidate = false, .decimal_exception = exception};
}
 
[[nodiscard]] inline formatted_cell format_cell_value(column_format const& format, presentation::styled_text value)
{
  return make_text_cell(std::move(value), format);
}
 
[[nodiscard]] inline formatted_cell format_cell_value(column_format const& format,
                                                      presentation::table_cell const& value)
{
  return make_text_cell(value.content, format);
}
 
[[nodiscard]] inline presentation::styled_text make_plain_cell(std::string_view value,
                                                               terminal::TerminalStyle style = {})
{
  presentation::styled_text text;
  text.append(value, std::move(style));
  return text;
}
 
[[nodiscard]] inline formatted_cell format_cell_value(column_format const& format, char const* value)
{
  auto const exception = expects_number(format);
  return formatted_cell{.text = make_plain_cell(value != nullptr ? std::string_view(value) : std::string_view{},
                                                exception ? format.exception_style : format.style),
                        .decimal_candidate = false,
                        .decimal_exception = exception};
}
 
template <typename T> [[nodiscard]] formatted_cell format_cell_value(column_format const& format, T&& value)
{
  using value_type = std::remove_cvref_t<T>;
  if constexpr (display_numeric_value<T>)
  {
    auto const numeric = expects_number(format);
    auto const finite = uni20::isfinite(value);
    auto text = make_plain_cell(numeric ? fmt::format(fmt::runtime(format.pattern), std::forward<T>(value))
                                        : fmt::format("{}", std::forward<T>(value)),
                                finite ? format.style : format.exception_style);
    return formatted_cell{.text = std::move(text),
                          .decimal_candidate = numeric && finite,
                          .decimal_exception = numeric && !finite,
                          .keep_together = true};
  }
  else if constexpr (std::is_same_v<value_type, std::string>)
  {
    auto const exception = expects_number(format);
    return formatted_cell{
        .text = make_plain_cell(std::forward<T>(value), exception ? format.exception_style : format.style),
        .decimal_candidate = false,
        .decimal_exception = exception};
  }
  else if constexpr (std::is_same_v<value_type, std::string_view>)
  {
    auto const exception = expects_number(format);
    return formatted_cell{.text = make_plain_cell(value, exception ? format.exception_style : format.style),
                          .decimal_candidate = false,
                          .decimal_exception = exception};
  }
  else if constexpr (std::is_array_v<value_type>)
  {
    auto const exception = expects_number(format);
    return formatted_cell{
        .text = make_plain_cell(std::string_view(value), exception ? format.exception_style : format.style),
        .decimal_candidate = false,
        .decimal_exception = exception};
  }
  else if constexpr (std::is_convertible_v<T, char const*>)
  {
    return format_cell_value(format, static_cast<char const*>(value));
  }
  else
  {
    auto const exception = expects_number(format);
    return formatted_cell{.text = make_plain_cell(fmt::format("{}", std::forward<T>(value)),
                                                  exception ? format.exception_style : format.style),
                          .decimal_candidate = false,
                          .decimal_exception = exception};
  }
}
} // namespace detail
 
template <typename... Args>
presentation::styled_text status_cell(presentation::semantic_glyph glyph, checked_format_string<Args...> format,
                                      Args&&... args)
{
  auto style = detail::status_style(glyph);
  presentation::styled_text text;
  text.append(glyph, style).append(" ").append(fmt::format(format.format, std::forward<Args>(args)...), style);
  return text;
}
 
template <typename... Args>
void status(presentation::semantic_glyph glyph, checked_format_string<Args...> format, Args&&... args)
{
  emit(status_cell(glyph, format, std::forward<Args>(args)...), stream::err, true, format.where);
}
 
template <typename... Args> void info(checked_format_string<Args...> format, Args&&... args)
{
  status(presentation::semantic_glyph::info, format, std::forward<Args>(args)...);
}
 
template <typename... Args> void success(checked_format_string<Args...> format, Args&&... args)
{
  status(presentation::semantic_glyph::success, format, std::forward<Args>(args)...);
}
 
template <typename... Args> void warning(checked_format_string<Args...> format, Args&&... args)
{
  status(presentation::semantic_glyph::warning, format, std::forward<Args>(args)...);
}
 
template <typename... Args> void failure(checked_format_string<Args...> format, Args&&... args)
{
  status(presentation::semantic_glyph::failure, format, std::forward<Args>(args)...);
}
 
template <typename... Args> void fatal(checked_format_string<Args...> format, Args&&... args)
{
  status(presentation::semantic_glyph::fatal, format, std::forward<Args>(args)...);
}
 
template <typename... Args> void partial(checked_format_string<Args...> format, Args&&... args)
{
  status(presentation::semantic_glyph::partial, format, std::forward<Args>(args)...);
}
 
template <typename... Args> void deferred(checked_format_string<Args...> format, Args&&... args)
{
  status(presentation::semantic_glyph::deferred, format, std::forward<Args>(args)...);
}
 
template <typename... Args> void skipped(checked_format_string<Args...> format, Args&&... args)
{
  status(presentation::semantic_glyph::skipped, format, std::forward<Args>(args)...);
}
 
template <typename... Values> void streaming_table::row(Values&&... values)
{
  std::vector<formatted_cell> cells;
  cells.reserve(sizeof...(Values));
  std::size_t column = 0;
  ((cells.push_back(detail::format_cell_value(column < columns_.size() ? columns_[column].format : column_format{},
                                              std::forward<Values>(values))),
    ++column),
   ...);
  this->emit_rows(cells, std::source_location::current());
}
 
} // namespace uni20::display