styled_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
 
#include "../microfmt.hpp"
#include <cstddef>
#include <cstdint>
#include <string_view>
#include <utility>
 
namespace microfmt {
 
enum class char_transform : uint8_t {
  none = 0,
  to_upper,
  to_lower,
  sanitize_ascii // Replaces non-printable control chars with '.'
};
 
class MICROFMT_API_CLASS RELOCO_POINTER transform_sink {
public:
  explicit constexpr transform_sink(sink target RELOCO_LIFETIME_CAPTURE_BY_THIS,
                                    char_transform t = char_transform::none) noexcept
      : target_(target), transform_(t) {}
 
  transform_sink(const transform_sink &) = delete;
  transform_sink &operator=(const transform_sink &) = delete;
  transform_sink(transform_sink &&) noexcept = default;
  transform_sink &operator=(transform_sink &&) noexcept = default;
 
  [[nodiscard]] sink as_sink() & noexcept RELOCO_LIFETIMEBOUND {
    return sink{this,
                [](void *ctx, microfmt::string_view sv) noexcept { static_cast<transform_sink *>(ctx)->write(sv); }};
  }
 
  void set_transform(char_transform t) noexcept { transform_ = t; }
 
  void put(char c) noexcept { target_.put(apply_char(c)); }
 
  void write(microfmt::string_view sv) noexcept {
    for (char c : sv) {
      target_.put(apply_char(c));
    }
  }
 
private:
  // bridges to a C/platform API (FILE*, syslog, android log, raw chunk storage) that takes raw pointers.
  RELOCO_BEGIN_UNSAFE_CODE
  [[nodiscard]] constexpr char apply_char(char c) const noexcept {
    switch (transform_) {
    case char_transform::to_upper:
      if (c >= 'a' && c <= 'z')
        return static_cast<char>(c - ('a' - 'A'));
      return c;
    case char_transform::to_lower:
      if (c >= 'A' && c <= 'Z')
        return static_cast<char>(c + ('a' - 'A'));
      return c;
    case char_transform::sanitize_ascii:
      if ((static_cast<uint8_t>(c) < 0x20 || c == '\x7f') && c != '\n' && c != '\r' && c != '\t') {
        return '.';
      }
      return c;
    case char_transform::none:
    default:
      return c;
    }
  }
  RELOCO_END_UNSAFE_CODE
 
  sink target_;
  char_transform transform_{char_transform::none};
};
 
class MICROFMT_API_CLASS RELOCO_POINTER prefix_sink {
public:
  explicit constexpr prefix_sink(sink target RELOCO_LIFETIME_CAPTURE_BY_THIS,
                                 microfmt::string_view prefix RELOCO_LIFETIME_CAPTURE_BY_THIS = "  ") noexcept
      : target_(target), prefix_(prefix) {}
 
  prefix_sink(const prefix_sink &) = delete;
  prefix_sink &operator=(const prefix_sink &) = delete;
  prefix_sink(prefix_sink &&) noexcept = default;
  prefix_sink &operator=(prefix_sink &&) noexcept = default;
 
  [[nodiscard]] sink as_sink() & noexcept RELOCO_LIFETIMEBOUND {
    return sink{this, [](void *ctx, microfmt::string_view sv) noexcept { static_cast<prefix_sink *>(ctx)->write(sv); }};
  }
 
  void set_prefix(microfmt::string_view p RELOCO_LIFETIME_CAPTURE_BY_THIS) noexcept { prefix_ = p; }
 
  void put(char c) noexcept {
    if (at_line_start_) {
      target_.write(prefix_);
      at_line_start_ = false;
    }
 
    target_.put(c);
 
    if (c == '\n') {
      at_line_start_ = true;
    }
  }
 
  void write(microfmt::string_view sv) noexcept {
    for (char c : sv) {
      put(c);
    }
  }
 
private:
  sink target_;
  microfmt::string_view prefix_{"  "};
  bool at_line_start_{true};
};
 
class MICROFMT_API_CLASS RELOCO_POINTER limit_sink {
public:
  explicit constexpr limit_sink(sink target RELOCO_LIFETIME_CAPTURE_BY_THIS, size_t max_bytes) noexcept
      : target_(target), remaining_(max_bytes) {}
 
  limit_sink(const limit_sink &) = delete;
  limit_sink &operator=(const limit_sink &) = delete;
  limit_sink(limit_sink &&) noexcept = default;
  limit_sink &operator=(limit_sink &&) noexcept = default;
 
  [[nodiscard]] sink as_sink() & noexcept RELOCO_LIFETIMEBOUND {
    return sink{this, [](void *ctx, microfmt::string_view sv) noexcept { static_cast<limit_sink *>(ctx)->write(sv); }};
  }
 
  void put(char c) noexcept {
    if (remaining_ > 0) {
      target_.put(c);
      --remaining_;
    }
  }
 
  void write(microfmt::string_view sv) noexcept {
    if (remaining_ == 0 || sv.empty())
      return;
 
    const size_t to_write = (sv.size() <= remaining_) ? sv.size() : remaining_;
    target_.write(sv.substr(0, to_write));
    remaining_ -= to_write;
  }
 
  [[nodiscard]] constexpr size_t remaining() const noexcept { return remaining_; }
  [[nodiscard]] constexpr bool capped() const noexcept { return remaining_ == 0; }
 
private:
  sink target_;
  size_t remaining_{0};
};
 
} // namespace microfmt