metadata_map.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Jarosław Pelczar <jarek@jpelczar.com>
// SPDX-License-Identifier: BSD-2-Clause
 
#pragma once
 
#include "../markdown.hpp"
#include "../microfmt.hpp"
#include "../reloco.hpp"
#include <reloco/type_id.hpp>
 
namespace microfmt {
 
using property_print_fn_t = void (*)(const void *val_ptr, const sink &out) noexcept;
 
struct MICROFMT_API_CLASS RELOCO_POINTER property_entry {
  microfmt::string_view key{};
  value_ptr<const void> val_ptr{};
  property_print_fn_t print_fn{nullptr};
 
  void format_value(const sink &out) const noexcept {
    if (print_fn != nullptr && val_ptr) {
      print_fn(val_ptr.get(), out);
    } else {
      out.write("null");
    }
  }
};
 
using metadata_next_fn_t = bool (*)(void *ctx, property_entry &out) noexcept;
 
class MICROFMT_API_CLASS RELOCO_POINTER metadata_map {
public:
  constexpr metadata_map(void *ctx RELOCO_LIFETIMEBOUND RELOCO_LIFETIME_CAPTURE_BY_THIS,
                         metadata_next_fn_t next_fn) noexcept
      : m_ctx(ctx), m_next_fn(next_fn) {}
 
  [[nodiscard]] constexpr bool get_next(property_entry &out) const noexcept {
    if (m_next_fn != nullptr && m_ctx) {
      return m_next_fn(m_ctx.get(), out);
    }
    return false;
  }
 
private:
  value_ptr<void> m_ctx{};
  metadata_next_fn_t m_next_fn{nullptr};
};
 
} // namespace microfmt
 
// ============================================================================
// Formatter Specialization for metadata_map (Zero-Overhead while Loop)
// ============================================================================
 
namespace microfmt {
 
template <> struct formatter<microfmt::metadata_map> {
  constexpr void parse(format_parse_context &) noexcept {}
 
  void format(const microfmt::metadata_map &map, const sink &out) const noexcept {
    out.put('{');
    property_entry entry;
    std::size_t idx = 0;
 
    // Direct generator loop minimizing local stack variables and branch overhead
    while (map.get_next(entry)) {
      if (idx > 0) {
        out.write(", ");
      }
      microfmt::format_to(out, "\"{}\": ", entry.key);
      entry.format_value(out);
      ++idx;
    }
    out.put('}');
  }
};
 
} // namespace microfmt
 
namespace microfmt::md {
 
inline void write_metadata_table(writer &w, metadata_map map, span<char> scratch_buf,
                                 string_view title = "Metadata Properties") noexcept {
  // NOLINTNEXTLINE(reloco-no-c-array): fixed-size buffer/table for span APIs
  static constexpr column cols[2] = {{"Property", 12, align::left}, {"Value", 16, align::left}};
 
  w.h3(title);
 
  table_writer<2> tw(w, cols);
 
  // Initialize the caller-provided span_sink scratchpad
  span_sink scratch(scratch_buf);
 
  property_entry entry;
  while (map.get_next(entry)) {
    scratch.reset();                       // Clear workspace for the next row
    entry.format_value(scratch.as_sink()); // Format into scratch buffer
 
    tw.row(entry.key, scratch.view());
  }
}
 
} // namespace microfmt::md
 
// See <reloco/type_id.hpp> for the full RELOCO_TYPE_ID_NAME rationale;
// defined here, alongside property_entry's own definition.
RELOCO_TYPE_ID_NAME(microfmt::property_entry, "microfmt::property_entry");