sink_provider.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 <type_traits>
#include <utility>
 
namespace microfmt {
 
template <typename Tag> struct sink_provider_traits;
 
namespace detail {
 
template <typename Tag, typename = void> struct has_sink_provider_flush : std::false_type {};
 
template <typename Tag>
struct has_sink_provider_flush<Tag, std::void_t<decltype(sink_provider_traits<Tag>::flush(
                                        std::declval<value_ref<typename sink_provider_traits<Tag>::context_type>>()))>>
    : std::true_type {};
 
template <typename Tag, typename = void> struct has_stateless_sink_provider_flush : std::false_type {};
 
template <typename Tag>
struct has_stateless_sink_provider_flush<Tag, std::void_t<decltype(sink_provider_traits<Tag>::flush())>>
    : std::true_type {};
 
} // namespace detail
 
class MICROFMT_API_CLASS RELOCO_POINTER sink_provider_ref {
public:
  struct vtable {
    void (*write)(void *ctx, microfmt::string_view sv) noexcept = nullptr;
    void (*flush)(void *ctx) noexcept = nullptr;
  };
 
  constexpr sink_provider_ref() noexcept = default;
 
  template <typename Tag, typename Traits = sink_provider_traits<Tag>,
            std::enable_if_t<std::is_void_v<typename Traits::context_type>, int> = 0>
  constexpr explicit sink_provider_ref(Tag) noexcept : ctx_(nullptr), vtbl_(&s_vtbl<Tag>) {}
 
  template <typename Tag, typename Context, typename Traits = sink_provider_traits<Tag>,
            std::enable_if_t<!std::is_void_v<typename Traits::context_type> &&
                                 std::is_convertible_v<Context *, typename Traits::context_type *>,
                             int> = 0>
  constexpr sink_provider_ref(Tag, Context &ctx RELOCO_LIFETIMEBOUND RELOCO_LIFETIME_CAPTURE_BY_THIS) noexcept
      : ctx_(&ctx), vtbl_(&s_vtbl<Tag>) {}
 
  // Refuses to bind to a temporary context, which would leave ctx_ dangling
  // the moment this constructor returns.
  template <typename Tag, typename Context, std::enable_if_t<!std::is_lvalue_reference_v<Context>, int> = 0>
  constexpr sink_provider_ref(Tag, Context &&) = delete;
 
  void write(microfmt::string_view sv) const noexcept {
    if (vtbl_ != nullptr && !sv.empty()) {
      vtbl_->write(ctx_.get(), sv);
    }
  }
 
  [[nodiscard]] constexpr bool can_flush() const noexcept { return vtbl_ != nullptr && vtbl_->flush != nullptr; }
 
  void flush() const noexcept {
    if (can_flush()) {
      vtbl_->flush(ctx_.get());
    }
  }
 
  [[nodiscard]] constexpr explicit operator bool() const noexcept { return vtbl_ != nullptr; }
 
  [[nodiscard]] constexpr sink as_sink() const noexcept RELOCO_LIFETIMEBOUND {
    return sink{ctx_.get(), vtbl_ != nullptr ? vtbl_->write : nullptr};
  }
 
private:
  template <typename Tag> static void write_entry(void *ctx, microfmt::string_view sv) noexcept {
    using context_type = typename sink_provider_traits<Tag>::context_type;
    if constexpr (std::is_void_v<context_type>) {
      (void)ctx;
      sink_provider_traits<Tag>::write(sv);
    } else {
      auto &typed = *static_cast<context_type *>(ctx);
      sink_provider_traits<Tag>::write(value_ref<context_type>(typed), sv);
    }
  }
 
  template <typename Tag> [[nodiscard]] static constexpr auto flush_entry() noexcept {
    using context_type = typename sink_provider_traits<Tag>::context_type;
    if constexpr (std::is_void_v<context_type>) {
      if constexpr (detail::has_stateless_sink_provider_flush<Tag>::value) {
        return +[](void *) noexcept { sink_provider_traits<Tag>::flush(); };
      } else {
        return static_cast<void (*)(void *) noexcept>(nullptr);
      }
    } else if constexpr (detail::has_sink_provider_flush<Tag>::value) {
      return +[](void *ctx) noexcept {
        auto &typed = *static_cast<context_type *>(ctx);
        sink_provider_traits<Tag>::flush(value_ref<context_type>(typed));
      };
    } else {
      return static_cast<void (*)(void *) noexcept>(nullptr);
    }
  }
 
  template <typename Tag> static constexpr vtable s_vtbl{&write_entry<Tag>, flush_entry<Tag>()};
 
  value_ptr<void> ctx_{};
  const vtable *vtbl_{nullptr};
};
 
template <typename Tag> class sink_provider {
public:
  using traits_type = sink_provider_traits<Tag>;
  using context_type = typename traits_type::context_type;
  static_assert(!std::is_void_v<context_type>, "sink_provider<Tag> requires a stateful backend; construct "
                                               "sink_provider_ref{Tag{}} directly for stateless backends");
 
  constexpr explicit sink_provider(context_type context) noexcept : context_(std::move(context)) {}
 
  [[nodiscard]] constexpr sink_provider_ref ref() & noexcept RELOCO_LIFETIMEBOUND {
    return sink_provider_ref(Tag{}, context_);
  }
 
  [[nodiscard]] constexpr sink as_sink() & noexcept RELOCO_LIFETIMEBOUND {
    // Clang can't detect that ref() just forwards our context reference to context_
#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wreturn-stack-address"
#pragma clang diagnostic ignored "-Wdangling-gsl"
#endif
 
    return ref().as_sink();
 
#if defined(__clang__)
#pragma clang diagnostic pop
#endif
  }
 
private:
  context_type context_;
};
 
// ============================================================================
// Built-in Backends
// ============================================================================
 
struct null_sink_provider_tag {};
 
template <> struct sink_provider_traits<null_sink_provider_tag> {
  using context_type = void;
 
  static void write(microfmt::string_view) noexcept {
    // Intentionally discards every write.
  }
};
 
struct span_sink_provider_tag {};
 
struct MICROFMT_API_CLASS RELOCO_POINTER span_sink_provider_context {
  span<char> buffer;
  size_t pos{0};
};
 
template <> struct sink_provider_traits<span_sink_provider_tag> {
  using context_type = span_sink_provider_context;
 
  static void write(value_ref<context_type> ctx, microfmt::string_view sv) noexcept {
    const size_t avail = (ctx->pos < ctx->buffer.size()) ? (ctx->buffer.size() - ctx->pos) : 0;
    const size_t n = std::min(sv.size(), avail);
    if (n > 0) {
      RELOCO_BEGIN_UNSAFE_BUFFER_USAGE;
      std::copy_n(sv.data(), n, ctx->buffer.data() + ctx->pos);
      RELOCO_END_UNSAFE_BUFFER_USAGE;
      ctx->pos += n;
    }
  }
};
 
} // namespace microfmt