remote_container.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Jarosław Pelczar <jarek@jpelczar.com>
//
// SPDX-License-Identifier: BSD-2-Clause
 
// ============================================================================
// General Type-Erased Remote Container View & Context Builder Pattern
// ============================================================================
 
#pragma once
 
#include "address_space.hpp"
#include <cstddef>
#include <cstdint>
 
namespace microfmt {
 
class remote_container_view;
 
struct MICROFMT_API_CLASS RELOCO_POINTER container_options {
  bool print_key{true};
  bool print_value{true};
  microfmt::string_view kv_separator{": "};
  microfmt::string_view entry_separator{", "};
  microfmt::string_view open_bracket{"{"};
  microfmt::string_view close_bracket{"}"};
  size_t max_print{64};
};
 
template <typename IteratorState, typename FormatterFn> class RELOCO_OWNER container_context {
public:
  constexpr container_context(IteratorState initial_state, FormatterFn formatter) noexcept
      : state_(initial_state), formatter_fn_(formatter) {}
 
  static bool format_thunk(void *raw_ctx, address_space_ref space, span<std::byte> scratch, const sink &out,
                           const container_options &opts) noexcept {
    auto *self = static_cast<container_context *>(raw_ctx);
    return self->formatter_fn_(self->state_, opts, space, scratch, out);
  }
 
  [[nodiscard]] constexpr IteratorState &state() & noexcept RELOCO_LIFETIMEBOUND { return state_; }
  [[nodiscard]] constexpr const IteratorState &state() const & noexcept RELOCO_LIFETIMEBOUND { return state_; }
 
  [[nodiscard]] constexpr const IteratorState &state() const && = delete;
 
private:
  IteratorState state_;
  FormatterFn formatter_fn_;
};
 
template <typename Tag, typename Dispatcher> class RELOCO_OWNER basic_remote_container {
public:
  using traits_type = typename Dispatcher::traits_type;
  using context_type = typename traits_type::context_type;
 
  constexpr basic_remote_container(uintptr_t container_addr, context_type context) noexcept
      : container_addr_(container_addr), context_(std::move(context)) {}
 
  [[nodiscard]] constexpr uintptr_t container_address() const noexcept { return container_addr_; }
 
  [[nodiscard]] constexpr value_ref<context_type> context() & noexcept RELOCO_LIFETIMEBOUND {
    return value_ref<context_type>(context_);
  }
 
  [[nodiscard]] constexpr value_ref<const context_type> context() const & noexcept RELOCO_LIFETIMEBOUND {
    return value_ref<const context_type>(context_);
  }
 
  value_ref<context_type> context() && = delete;
  value_ref<const context_type> context() const && = delete;
 
  [[nodiscard]] constexpr remote_container_view view(address_space_ref space,
                                                     span<std::byte> scratch RELOCO_LIFETIMEBOUND,
                                                     container_options options = {}) & noexcept RELOCO_LIFETIMEBOUND;
 
  remote_container_view view(address_space_ref, span<std::byte>, container_options = {}) && = delete;
 
  static bool format_thunk(void *raw_ctx, address_space_ref space, span<std::byte> scratch, const sink &out,
                           const container_options &opts) noexcept {
    auto &self = *static_cast<basic_remote_container *>(raw_ctx);
    return Dispatcher::format(value_ref<const context_type>(self.context_), self.container_addr_, opts, space, scratch,
                              out);
  }
 
private:
  uintptr_t container_addr_;
  context_type context_;
};
 
template <typename IteratorState, typename FormatterFn>
[[nodiscard]] constexpr auto make_container_context(IteratorState initial_state, FormatterFn formatter) noexcept {
  return container_context<IteratorState, FormatterFn>(initial_state, formatter);
}
 
class MICROFMT_API_CLASS RELOCO_POINTER remote_container_view {
public:
  using format_fn_t = bool (*)(void *ctx, address_space_ref space, span<std::byte> scratch, const sink &out,
                               const container_options &opts) noexcept;
 
  constexpr remote_container_view() noexcept = default;
 
  template <typename Context>
  constexpr remote_container_view(uintptr_t container_addr, address_space_ref space,
                                  span<std::byte> scratch RELOCO_LIFETIMEBOUND RELOCO_LIFETIME_CAPTURE_BY_THIS,
                                  value_ref<Context> ctx RELOCO_LIFETIME_CAPTURE_BY_THIS,
                                  container_options options = {}) noexcept
      : container_addr_(container_addr), space_(space), scratch_(scratch), ctx_(ctx.pointer()),
        format_fn_(&Context::format_thunk), options_(options) {}
 
  [[nodiscard]] constexpr uintptr_t container_address() const noexcept { return container_addr_; }
  [[nodiscard]] constexpr address_space_ref space() const noexcept { return space_; }
  [[nodiscard]] constexpr span<std::byte> scratch() const noexcept RELOCO_LIFETIMEBOUND { return scratch_; }
  [[nodiscard]] constexpr const container_options &options() const & noexcept RELOCO_LIFETIMEBOUND { return options_; }
  const container_options &options() const && = delete;
  [[nodiscard]] constexpr bool is_null() const noexcept { return container_addr_ == 0 || !ctx_; }
 
  bool format(const sink &out) const noexcept {
    if (format_fn_ == nullptr || !ctx_)
      return false;
    return format_fn_(ctx_.get(), space_, scratch_, out, options_);
  }
 
  [[nodiscard]] constexpr explicit operator bool() const noexcept { return !is_null(); }
 
private:
  uintptr_t container_addr_{0};
  address_space_ref space_{};
  span<std::byte> scratch_{};
  value_ptr<void> ctx_{};
  format_fn_t format_fn_{nullptr};
  container_options options_;
};
 
template <typename Tag, typename Dispatcher>
[[nodiscard]] constexpr remote_container_view
basic_remote_container<Tag, Dispatcher>::view(address_space_ref space, span<std::byte> scratch,
                                              container_options options) & noexcept {
  return remote_container_view(container_addr_, space, scratch, value_ref<basic_remote_container>(*this), options);
}
 
} // namespace microfmt
 
// ============================================================================
// Formatter for remote_container_view
// ============================================================================
 
template <> struct microfmt::formatter<microfmt::remote_container_view> {
  constexpr void parse(microfmt::format_parse_context &) noexcept {}
 
  void format(const microfmt::remote_container_view &view, const microfmt::sink &out) const noexcept {
    if (view.is_null()) {
      out.write("<null>");
      return;
    }
    if (!view.format(out)) {
      out.write("<fault>");
    }
  }
};