writer.hpp

#pragma once
 
#include <array>
#include <bit>
#include <cmath>
#include <concepts>
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <limits>
#include <string>
#include <string_view>
#include <tuple>
#include <type_traits>
#include <utility>
 
#include "../libxr_def.hpp"
#include "format_argument.hpp"
#include "format_protocol.hpp"
#include "print_contract.hpp"
 
namespace LibXR::Print
{
namespace Detail::WriterFloatLimit
{
[[nodiscard]] constexpr size_t DecimalDigitCount(size_t value)
{
  size_t digits = 1;
  while (value >= 10)
  {
    value /= 10;
    ++digits;
  }
  return digits;
}
 
template <typename Float>
[[nodiscard]] constexpr size_t FixedTextLimit()
{
  constexpr size_t decimal_point =
      (Config::max_float_precision != 0 || Config::enable_alternate) ? 1U : 0U;
  return Config::max_float_integer_digits + decimal_point +
         static_cast<size_t>(Config::max_float_precision);
}
 
template <typename Float>
[[nodiscard]] constexpr size_t ScientificTextLimit()
{
  constexpr size_t decimal_point =
      (Config::max_float_precision != 0 || Config::enable_alternate) ? 1U : 0U;
  constexpr size_t exponent_digits =
      DecimalDigitCount(static_cast<size_t>(std::numeric_limits<Float>::max_exponent10));
  return 1U + decimal_point + static_cast<size_t>(Config::max_float_precision) + 2U +
         exponent_digits;
}
 
template <typename Float>
[[nodiscard]] constexpr size_t FloatTextLimit()
{
  constexpr size_t fixed_limit = FixedTextLimit<Float>();
  constexpr size_t scientific_limit = ScientificTextLimit<Float>();
  return fixed_limit > scientific_limit ? fixed_limit : scientific_limit;
}
 
[[nodiscard]] constexpr size_t ComputeBufferCapacity()
{
  size_t capacity = 4;
  if constexpr (Config::enable_float_fixed || Config::enable_float_scientific ||
                Config::enable_float_general)
  {
    capacity = FloatTextLimit<float>();
  }
  if constexpr (Config::enable_float_double)
  {
    constexpr size_t double_limit = FloatTextLimit<double>();
    capacity = capacity > double_limit ? capacity : double_limit;
  }
  if constexpr (Config::enable_float_long_double)
  {
    constexpr size_t long_double_limit = FloatTextLimit<long double>();
    capacity = capacity > long_double_limit ? capacity : long_double_limit;
  }
  return capacity;
}
}  // namespace Detail::WriterFloatLimit
 
class Writer
{
 public:
  template <typename Sink, typename Format, auto ArgumentOrder, typename... Args>
    requires OutputSink<Sink> && CompiledFormat<std::remove_cvref_t<Format>>
  [[nodiscard]] static ErrorCode RunArgumentOrder(Sink& sink, const Format&,
                                                  Args&&... args)
  {
    using Built = std::remove_cvref_t<Format>;
    static_assert(ArgumentOrder.size() == Built::ArgumentList().size(),
                  "LibXR::Print::Writer: argument reorder list must match the "
                  "compiled field count");
    static_assert(
        Built::template Matches<Args...>(),
        "LibXR::Print::Writer::RunArgumentOrder: format arguments do not match");
 
    return RunTaggedArgumentOrder<Sink, Built::ArgumentList(), ArgumentOrder,
                                  Built::Profile()>(sink, Built::Codes().data(),
                                                    std::forward<Args>(args)...);
  }
 
 private:
  static constexpr uint8_t unspecified_precision = 0xFF;
  template <FormatPackKind K>
  static constexpr bool dependent_false_v = false;
  static constexpr size_t float_buffer_capacity =
      Detail::WriterFloatLimit::ComputeBufferCapacity();
 
  [[nodiscard]] static constexpr bool HasFlag(uint8_t flags, uint8_t bit)
  {
    return (flags & bit) != 0;
  }
 
  struct Spec
  {
    uint8_t flags = 0;  
    char fill = ' ';    
    uint8_t width = 0;  
    uint8_t precision = unspecified_precision;  
 
    [[nodiscard]] constexpr bool LeftAlign() const
    {
      return Writer::HasFlag(flags, static_cast<uint8_t>(FormatFlag::LeftAlign));
    }
 
    [[nodiscard]] constexpr bool ForceSign() const
    {
      return Writer::HasFlag(flags, static_cast<uint8_t>(FormatFlag::ForceSign));
    }
 
    [[nodiscard]] constexpr bool CenterAlign() const
    {
      return Writer::HasFlag(flags, static_cast<uint8_t>(FormatFlag::CenterAlign));
    }
 
    [[nodiscard]] constexpr bool SpaceSign() const
    {
      return Writer::HasFlag(flags, static_cast<uint8_t>(FormatFlag::SpaceSign));
    }
 
    [[nodiscard]] constexpr bool Alternate() const
    {
      return Writer::HasFlag(flags, static_cast<uint8_t>(FormatFlag::Alternate));
    }
 
    [[nodiscard]] constexpr bool ZeroPad() const
    {
      return Writer::HasFlag(flags, static_cast<uint8_t>(FormatFlag::ZeroPad));
    }
 
    [[nodiscard]] constexpr bool UpperCase() const
    {
      return Writer::HasFlag(flags, static_cast<uint8_t>(FormatFlag::UpperCase));
    }
 
    [[nodiscard]] constexpr bool HasPrecision() const
    {
      return precision != unspecified_precision;
    }
  };
 
  template <size_t N>
  [[nodiscard]] static constexpr size_t BoundedTextLength(const char (&text)[N]) noexcept;
 
  template <typename T>
  [[nodiscard]] static constexpr std::string_view ToStringView(const T& text);
 
  template <FormatPackKind pack, typename T>
  [[nodiscard]] static constexpr auto PackValue(T&& value);
 
  template <typename T>
  static void StoreArgument(uint8_t*& out, const T& value);
 
  template <auto ArgumentInfoList>
  [[nodiscard]] static consteval size_t PackedArgumentBytes();
 
  template <auto ArgumentInfoList, auto ArgumentOrder, typename Tuple>
  static void StoreArgumentsOrdered(uint8_t*& out, Tuple& tuple);
 
  template <std::unsigned_integral UInt, uint8_t Base>
  [[nodiscard]] static consteval size_t UnsignedDigitCapacity();
 
  template <uint8_t Base, bool UpperCase = false, size_t N, std::unsigned_integral UInt>
  [[nodiscard]] static size_t AppendUnsigned(char (&out)[N], UInt value);
 
  template <size_t N>
  [[nodiscard]] static size_t AppendSmallUnsigned(char (&out)[N], uint8_t value);
 
  [[nodiscard]] static constexpr size_t FieldPadding(uint8_t width, size_t payload_size);
 
  [[nodiscard]] static constexpr size_t IntegerPrecisionZeros(const Spec& spec,
                                                              size_t digit_count);
 
  template <std::unsigned_integral UInt>
  [[nodiscard]] static constexpr std::string_view IntegerPrefix(FormatType type,
                                                                const Spec& spec,
                                                                UInt value);
 
  template <std::unsigned_integral UInt>
  [[nodiscard]] static size_t ApplyAlternateOctal(char* digits, size_t digit_count,
                                                  const Spec& spec, UInt value);
 
  [[nodiscard]] static constexpr bool UsesFloatTextBackend(FormatType type);
 
  [[nodiscard]] static constexpr bool FloatEnabled(FormatType type);
  [[nodiscard]] static constexpr uint8_t DefaultFloatPrecision();
  template <typename Float>
  [[nodiscard]] static bool ExceedsFixedIntegerDigits(Float value, uint8_t precision);
 
  [[nodiscard]] static bool AppendBufferChar(char* buffer, size_t capacity, size_t& size,
                                             char ch);
 
  [[nodiscard]] static bool AppendBufferText(char* buffer, size_t capacity, size_t& size,
                                             std::string_view text);
 
  [[nodiscard]] static bool AppendBufferU32ZeroPad(char* buffer, size_t capacity,
                                                   size_t& size, uint32_t value,
                                                   uint8_t width);
 
#if LIBXR_PRINT_ENABLE_FLOAT
  template <typename Float>
  struct DecimalScale;
 
  template <typename Float>
  struct ScientificDigits;
 
  template <typename Float>
  [[nodiscard]] static Float Power10(int exponent);
 
  template <typename Float>
  [[nodiscard]] static Float RoundDecimal(Float value, uint8_t precision);
 
  template <typename Float>
  [[nodiscard]] static ScientificDigits<Float> RoundScientificDigits(Float value,
                                                                     uint8_t precision);
 
  template <typename Float>
  [[nodiscard]] static DecimalScale<Float> NormalizeDecimal(Float value);
 
  template <typename Float>
  [[nodiscard]] static uint8_t ExtractDigit(Float& value, Float scale);
 
  [[nodiscard]] static size_t TrimGeneralText(char* text, size_t size);
 
  template <typename Float>
  [[nodiscard]] static bool FormatFixedText(Float value, uint8_t precision,
                                            bool alternate, char* out, size_t& out_size);
 
  [[nodiscard]] static bool AppendExponentText(char* out, size_t& out_size, int exponent,
                                               bool upper_case);
 
  template <typename Float>
  [[nodiscard]] static bool FormatScientificText(Float value, uint8_t precision,
                                                 bool alternate, bool upper_case,
                                                 char* out, size_t& out_size);
 
  template <typename Float>
  [[nodiscard]] static bool FormatFloatText(FormatType type, const Spec& spec,
                                            Float value, char* out, size_t& out_size);
#endif
 
  class CodeReader;
  class ArgumentReader;
 
  template <OutputSink Sink>
  class Executor;
 
  template <OutputSink Sink, FormatProfile Profile>
  [[nodiscard]] static LIBXR_NOINLINE ErrorCode Execute(Sink& sink, const uint8_t* codes,
                                                        const uint8_t* args)
  {
    return Executor<Sink>(sink, codes, args).template Run<Profile>();
  }
 
  template <OutputSink Sink, auto ArgumentInfoList, auto ArgumentOrder,
            FormatProfile Profile, typename... Args>
  [[nodiscard]] static LIBXR_NOINLINE ErrorCode
  RunTaggedArgumentOrder(Sink& sink, const uint8_t* codes, Args&&... args)
  {
    if constexpr (ArgumentInfoList.size() == 0)
    {
      return Execute<Sink, Profile>(sink, codes, nullptr);
    }
    else
    {
      constexpr size_t packed_arg_bytes = PackedArgumentBytes<ArgumentInfoList>();
      uint8_t packed[packed_arg_bytes];
      auto tuple = std::forward_as_tuple(std::forward<Args>(args)...);
      auto* cursor = packed;
      StoreArgumentsOrdered<ArgumentInfoList, ArgumentOrder>(cursor, tuple);
      return Execute<Sink, Profile>(sink, codes, packed);
    }
  }
};
 
// These implementation headers form an ordered dependency chain.
// clang-format off
#include "writer/writer_argument.hpp"
#include "writer/writer_integer.hpp"
#if LIBXR_PRINT_ENABLE_FLOAT
#include "writer/writer_float_runtime.hpp"
#include "writer/writer_float_math.hpp"
#include "writer/writer_float_fixed.hpp"
#include "writer/writer_float_general.hpp"
#endif
#include "writer/writer_reader.hpp"
#include "writer/writer_executor.hpp"
// clang-format on
}  // namespace LibXR::Print