print_api.hpp

#pragma once
 
#include <cstddef>
#include <cstring>
#include <limits>
#include <string_view>
#include <utility>
 
#include "format_surface.hpp"
#include "printf.hpp"
#include "writer.hpp"
 
namespace LibXR::Print
{
template <typename Sink, typename Format, typename... Args>
  requires OutputSink<Sink> && CompiledFormat<std::remove_cvref_t<Format>>
[[nodiscard]] inline ErrorCode Write(Sink& sink, const Format& format, Args&&... args)
{
  using Built = std::remove_cvref_t<Format>;
  return Writer::template RunArgumentOrder<Sink, Built, Built::ArgumentOrder()>(
      sink, format, std::forward<Args>(args)...);
}
 
template <OutputSink Sink, typename Format, typename... Args>
[[nodiscard]] inline ErrorCode FormatTo(Sink& sink, const Format& format, Args&&... args)
{
  return Write(sink, format, std::forward<Args>(args)...);
}
 
template <Text Source, OutputSink Sink, typename... Args>
[[nodiscard]] inline ErrorCode FormatTo(Sink& sink, Args&&... args)
{
  constexpr LibXR::Format<Source> format{};
  return FormatTo(sink, format, std::forward<Args>(args)...);
}
 
template <Text Source, OutputSink Sink, typename... Args>
[[nodiscard]] inline ErrorCode PrintfTo(Sink& sink, Args&&... args)
{
  constexpr auto format = Printf::Build<Source>();
  return FormatTo(sink, format, std::forward<Args>(args)...);
}
 
[[nodiscard]] inline int FormatIntoBuffer(char* buffer, size_t capacity,
                                          const auto& format, auto&&... args)
{
  struct BufferSink
  {
    char* buffer = nullptr;
    size_t retain_limit = 0;
    size_t retained_size = 0;
    size_t total_size = 0;
 
    [[nodiscard]] ErrorCode Write(std::string_view chunk)
    {
      total_size += chunk.size();
 
      if (buffer == nullptr || retained_size >= retain_limit)
      {
        return ErrorCode::OK;
      }
 
      size_t writable = retain_limit - retained_size;
      size_t copy_size = chunk.size() < writable ? chunk.size() : writable;
      if (copy_size > 0)
      {
        std::memcpy(buffer + retained_size, chunk.data(), copy_size);
        retained_size += copy_size;
      }
      return ErrorCode::OK;
    }
  };
 
  BufferSink sink{
      .buffer = buffer,
      .retain_limit = capacity > 0 ? capacity - 1 : 0,
  };
  auto ec = Write(sink, format, std::forward<decltype(args)>(args)...);
  if (ec != ErrorCode::OK)
  {
    if (capacity > 0 && buffer != nullptr)
    {
      buffer[0] = '\0';
    }
    return -1;
  }
 
  if (capacity > 0 && buffer != nullptr)
  {
    buffer[sink.retained_size] = '\0';
  }
 
  if (sink.total_size > static_cast<size_t>(std::numeric_limits<int>::max()))
  {
    return -1;
  }
 
  return static_cast<int>(sink.total_size);
}
 
template <Text Source, typename... Args>
[[nodiscard]] inline int FormatIntoBuffer(char* buffer, size_t capacity, Args&&... args)
{
  constexpr LibXR::Format<Source> format{};
  return FormatIntoBuffer(buffer, capacity, format, std::forward<Args>(args)...);
}
 
template <Text Source, typename... Args>
[[nodiscard]] inline int PrintfIntoBuffer(char* buffer, size_t capacity, Args&&... args)
{
  constexpr auto format = Printf::Build<Source>();
  return FormatIntoBuffer(buffer, capacity, format, std::forward<Args>(args)...);
}
 
[[nodiscard]] inline int SNPrintf(char* buffer, size_t capacity, const auto& format,
                                  auto&&... args)
{
  return FormatIntoBuffer(buffer, capacity, format,
                          std::forward<decltype(args)>(args)...);
}
 
template <Text Source, typename... Args>
[[nodiscard]] inline int SNPrintf(char* buffer, size_t capacity, Args&&... args)
{
  constexpr auto format = Printf::Build<Source>();
  return SNPrintf(buffer, capacity, format, std::forward<Args>(args)...);
}
 
}  // namespace LibXR::Print