asio_sink.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
 
// std-interop-file: opt-in Boost.Asio/std::ostream sink adapters, not pulled in by the default umbrella.
 
#include "../microfmt.hpp"
#include "../reloco.hpp"
#include <boost/asio/buffer.hpp>
#include <boost/asio/streambuf.hpp>
#include <cstddef>
#include <cstring>
#include <ostream>
 
namespace microfmt {
 
class MICROFMT_API_CLASS RELOCO_POINTER asio_mutable_buffer_sink {
public:
  explicit asio_mutable_buffer_sink(
      boost::asio::mutable_buffer buf RELOCO_LIFETIMEBOUND RELOCO_LIFETIME_CAPTURE_BY_THIS) noexcept
      : data_(static_cast<char *>(buf.data())), capacity_(buf.size()) {}
 
  asio_mutable_buffer_sink(const asio_mutable_buffer_sink &) = delete;
  asio_mutable_buffer_sink &operator=(const asio_mutable_buffer_sink &) = delete;
  asio_mutable_buffer_sink(asio_mutable_buffer_sink &&) noexcept = default;
  asio_mutable_buffer_sink &operator=(asio_mutable_buffer_sink &&) noexcept = default;
 
  [[nodiscard]] sink as_sink() noexcept RELOCO_LIFETIMEBOUND { return sink{this, &write_impl}; }
 
  [[nodiscard]] size_t size() const noexcept { return size_; }
 
  [[nodiscard]] boost::asio::const_buffer written_buffer() const noexcept RELOCO_LIFETIMEBOUND {
    return boost::asio::const_buffer(data_, size_);
  }
 
private:
  static void write_impl(void *ctx, microfmt::string_view str) noexcept {
    auto *self = static_cast<asio_mutable_buffer_sink *>(ctx);
 
    if (self->size_ >= self->capacity_)
      return;
 
    size_t to_copy = str.size();
    if (self->size_ + to_copy > self->capacity_) {
      to_copy = self->capacity_ - self->size_;
    }
 
    RELOCO_BEGIN_UNSAFE_BUFFER_USAGE;
    std::memcpy(self->data_ + self->size_, str.data(), to_copy);
    RELOCO_END_UNSAFE_BUFFER_USAGE;
 
    self->size_ += to_copy;
  }
 
  char *data_;
  size_t capacity_;
  size_t size_{0};
};
 
class MICROFMT_API_CLASS RELOCO_POINTER asio_streambuf_sink {
public:
  explicit asio_streambuf_sink(boost::asio::streambuf &buf RELOCO_LIFETIMEBOUND RELOCO_LIFETIME_CAPTURE_BY_THIS,
                               size_t max_chars = 1024) noexcept
      : streambuf_(&buf), max_chars_(max_chars) {}
 
  [[nodiscard]] sink as_sink() noexcept RELOCO_LIFETIMEBOUND { return sink{this, &write_impl}; }
 
private:
  static void write_impl(void *ctx, microfmt::string_view str) noexcept {
    auto *self = static_cast<asio_streambuf_sink *>(ctx);
 
    if (self->written_ >= self->max_chars_)
      return;
 
    size_t len = str.size();
    if (self->written_ + len > self->max_chars_) {
      len = self->max_chars_ - self->written_;
    }
 
    // Append via std::ostream so Boost.Asio grows the streambuf as needed.
    std::ostream os(self->streambuf_);
    os.write(str.data(), static_cast<std::streamsize>(len));
    self->written_ += len;
  }
 
  boost::asio::streambuf *streambuf_;
  size_t max_chars_;
  size_t written_{0};
};
 
} // namespace microfmt