report.h

Go to the documentation of this file.

#pragma once

#include <cinttypes>
#include <cstdio>
#include <string>
#include <string_view>

#include "stx/common.h"

STX_BEGIN_NAMESPACE

#ifndef STX_REPORT_RESERVE_SIZE
constexpr size_t kReportReserveSize = 128;
#else
constexpr size_t kReportReserveSize = STX_REPORT_RESERVE_SIZE;
#endif

constexpr char const kReportTruncationMessage[] =
    "... (error report truncated)";

// this also ensures we don't perform an out-of-bounds access on the reserve
static_assert(kReportReserveSize > (sizeof(kReportTruncationMessage) - 1),
              "STX_REPORT_RESERVE_SIZE must contain truncation message");

struct ReportQuery {};

constexpr ReportQuery const report_query{};

// rather than having one report type and paying at runtime by having a `bool`
// to tell if the report string is allocated on the stack or is a forwarding
// reference we pay for it at compile-time by tag dispatch

// rather than having a `bool` to tell if this is allocated on the stack or is a
// forwarding reference we pay for it at compile time by tag dispatch
class [[nodiscard]] FixedReport {
 public:
  using storage_type = char[kReportReserveSize];

  constexpr FixedReport() noexcept : reserve_{}, report_size_{0} {}

  constexpr FixedReport(const char* str, size_t size) noexcept
      : reserve_{}, report_size_{size} {
    *this = FixedReport(std::string_view(str, size));
  }

  explicit constexpr FixedReport(std::string_view const& info) noexcept
      : reserve_{}, report_size_{0} {
    // account for truncation
    // check bounds
    size_t const str_size = info.size();
    bool const should_truncate = str_size > kReportReserveSize;
    size_t const str_clip_size =
        should_truncate
            ? (kReportReserveSize - (sizeof(kReportTruncationMessage) - 1))
            : str_size;

    size_t pos = 0;
    for (; pos < str_clip_size; pos++) {
      reserve_[pos] = info[pos];
    }

    if (should_truncate) {
      for (; pos < kReportReserveSize; pos++) {
        reserve_[pos] = kReportTruncationMessage[pos - str_clip_size];
      }
    }

    report_size_ = pos;
  }

  constexpr FixedReport(FixedReport const&) noexcept = default;
  constexpr FixedReport(FixedReport &&) noexcept = default;
  constexpr FixedReport& operator=(FixedReport const&) noexcept = default;
  constexpr FixedReport& operator=(FixedReport&&) noexcept = default;
  ~FixedReport() noexcept = default;

  [[nodiscard]] constexpr std::string_view what() const noexcept {
    return std::string_view(reserve_, report_size_);
  };

 private:
  storage_type reserve_;
  size_t report_size_;
};

class [[nodiscard]] SpanReport {
 public:
  // maintains a reference to a string, instead of using a stack
  // allocated reservation buffer
  // it does not own the contents, so make sure the referenced buffer lives
  // longer than this object

  constexpr SpanReport() noexcept : custom_payload_{nullptr}, report_size_{0} {}

  constexpr SpanReport(const char* str, size_t size) noexcept
      : custom_payload_{str}, report_size_{size} {}

  explicit constexpr SpanReport(std::string_view const& str) noexcept
      : custom_payload_{str.data()}, report_size_{str.size()} {}

  [[nodiscard]] constexpr std::string_view what() const noexcept {
    return std::string_view(custom_payload_, report_size_);
  };

  constexpr SpanReport(SpanReport const&) noexcept = default;
  constexpr SpanReport(SpanReport &&) noexcept = default;
  constexpr SpanReport& operator=(SpanReport const&) noexcept = default;
  constexpr SpanReport& operator=(SpanReport&&) noexcept = default;
  ~SpanReport() noexcept = default;

 private:
  const char* custom_payload_;
  size_t report_size_;
};

class [[nodiscard]] ReportPayload {
 public:
  explicit constexpr ReportPayload(FixedReport const& report) noexcept
      : content_{report.what()} {}

  explicit constexpr ReportPayload(SpanReport const& report) noexcept
      : content_{report.what()} {}

  constexpr ReportPayload(ReportPayload const&) noexcept = default;
  constexpr ReportPayload(ReportPayload &&) noexcept = default;
  constexpr ReportPayload& operator=(ReportPayload const&) noexcept = default;
  constexpr ReportPayload& operator=(ReportPayload&&) noexcept = default;
  ~ReportPayload() noexcept = default;

  [[nodiscard]] constexpr std::string_view const& data() const noexcept {
    return content_;
  }

 private:
  std::string_view content_;
};

// this allows tolerance for platforms without snprintf.
constexpr char const kFormatError[] = "<format error>";
constexpr size_t const kFormatErrorSize = sizeof(kFormatError) - 1;

template <typename T>
[[nodiscard]] inline SpanReport operator>>(ReportQuery, T const&) noexcept {
  return SpanReport();
}

#define STX_INTERNAL_MAKE_REPORT_(STX_ARG_SIZE, STX_ARG_FORMAT, STX_ARG_VALUE) \
  /* string size + terminating null character */                               \
  char fmt_buffer[STX_ARG_SIZE + 1];                                           \
  int fmt_buffer_size = std::snprintf(fmt_buffer, STX_ARG_SIZE + 1,            \
                                      STX_ARG_FORMAT, STX_ARG_VALUE);          \
  if (fmt_buffer_size < 0 || fmt_buffer_size >= STX_ARG_SIZE + 1) {            \
    return FixedReport(kFormatError, kFormatErrorSize);                        \
  } else {                                                                     \
    return FixedReport(fmt_buffer, fmt_buffer_size);                           \
  }

template <typename T>
[[nodiscard]] inline FixedReport operator>>(ReportQuery,
                                            T const* const& ptr) noexcept {
  STX_INTERNAL_MAKE_REPORT_(internal::kxPtrFmtSize, "0x%" PRIxPTR,
                            reinterpret_cast<uintptr_t const>(ptr));
}

template <typename T>
[[nodiscard]] inline FixedReport operator>>(ReportQuery,
                                            T* const& ptr) noexcept {
  STX_INTERNAL_MAKE_REPORT_(internal::kxPtrFmtSize, "0x%" PRIxPTR,
                            reinterpret_cast<uintptr_t>(ptr));
}

[[nodiscard]] inline FixedReport operator>>(ReportQuery,
                                            int8_t const& v) noexcept {
  STX_INTERNAL_MAKE_REPORT_(internal::kI8FmtSize, "%" PRIi8, v);
}

[[nodiscard]] inline FixedReport operator>>(ReportQuery,
                                            uint8_t const& v) noexcept {
  STX_INTERNAL_MAKE_REPORT_(internal::kU8FmtSize, "%" PRIu8, v);
}

[[nodiscard]] inline FixedReport operator>>(ReportQuery,
                                            int16_t const& v) noexcept {
  STX_INTERNAL_MAKE_REPORT_(internal::kI16FmtSize, "%" PRIi16, v);
}

[[nodiscard]] inline FixedReport operator>>(ReportQuery,
                                            uint16_t const& v) noexcept {
  STX_INTERNAL_MAKE_REPORT_(internal::kU16FmtSize, "%" PRIu16, v);
}

[[nodiscard]] inline FixedReport operator>>(ReportQuery,
                                            int32_t const& v) noexcept {
  STX_INTERNAL_MAKE_REPORT_(internal::kI32FmtSize, "%" PRIi32, v);
}

[[nodiscard]] inline FixedReport operator>>(ReportQuery,
                                            uint32_t const& v) noexcept {
  STX_INTERNAL_MAKE_REPORT_(internal::kU32FmtSize, "%" PRIu32, v);
}

#undef STX_INTERNAL_MAKE_REPORT_

[[nodiscard]] inline SpanReport operator>>(ReportQuery,
                                           std::string_view const& v) noexcept {
  return SpanReport(v);
}

[[nodiscard]] inline SpanReport operator>>(ReportQuery,
                                           std::string const& v) noexcept {
  return SpanReport(v);
}

STX_END_NAMESPACE