foreign_string_view.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 "../microfmt.hpp"
#include "address_space.hpp"
 
#include <cstddef>
#include <cstdint>
#include <string_view>
 
namespace microfmt {
 
// ============================================================================
// Foreign String View
// ============================================================================
 
class MICROFMT_API_CLASS RELOCO_POINTER foreign_string_view {
public:
  constexpr foreign_string_view() noexcept = default;
 
  constexpr foreign_string_view(uintptr_t addr, address_space_ref space,
                                span<char> scratch RELOCO_LIFETIMEBOUND RELOCO_LIFETIME_CAPTURE_BY_THIS,
                                size_t max_limit = 4096) noexcept
      : addr_(addr), space_(space), scratch_(scratch), max_limit_(max_limit) {}
 
  template <size_t N>
  constexpr foreign_string_view(uintptr_t addr, address_space_ref space,
                                char (&scratch RELOCO_LIFETIMEBOUND RELOCO_LIFETIME_CAPTURE_BY_THIS)[N],
                                size_t max_limit = 4096) noexcept
      : addr_(addr), space_(space), scratch_(scratch, N), max_limit_(max_limit) {}
 
  [[nodiscard]] constexpr uintptr_t address() const noexcept { return addr_; }
 
  [[nodiscard]] constexpr address_space_ref space() const noexcept { return space_; }
 
  [[nodiscard]] constexpr span<char> scratch() const noexcept RELOCO_LIFETIMEBOUND { return scratch_; }
 
  [[nodiscard]] constexpr size_t max_limit() const noexcept { return max_limit_; }
 
private:
  uintptr_t addr_{0};
  address_space_ref space_{};
  span<char> scratch_{};
  size_t max_limit_{4096};
};
 
// ============================================================================
// microfmt Formatter Specialization
// ============================================================================
 
template <> struct formatter<foreign_string_view> {
  constexpr void parse(format_parse_context &) noexcept {}
 
  void format(const foreign_string_view &view, const sink &out) const noexcept {
    if (view.address() == 0) {
      out.write("(null)");
      return;
    }
 
    if (!view.space() || view.scratch().empty()) {
      microfmt::format_to(out, "<invalid-foreign@{:#x}>", view.address());
      return;
    }
 
    uintptr_t cur = view.address();
    size_t total = 0;
 
    while (total < view.max_limit()) {
      auto chunk = view.space().read_string_chunk(cur, view.scratch());
      if (!chunk) {
        if (total == 0) {
          microfmt::format_to(out, "<fault@{:#x}>", view.address());
        } else {
          out.write("<fault>");
        }
        return;
      }
 
      const size_t chunk_len = chunk->length;
      if (chunk_len > 0) {
        const size_t limit_left = view.max_limit() - total;
        const size_t to_write = (chunk_len > limit_left) ? limit_left : chunk_len;
        const auto scratch = view.scratch();
        out.write(microfmt::string_view(scratch.data(), to_write));
        total += to_write;
        cur += to_write;
      }
 
      if (chunk->null_terminated || total >= view.max_limit()) {
        break;
      }
    }
 
    if (total >= view.max_limit()) {
      out.write("...");
    }
  }
};
 
} // namespace microfmt