writer_executor_field.hpp

#pragma once
 
template <OutputSink Sink>
ErrorCode Writer::Executor<Sink>::WriteRaw(std::string_view text)
{
  return sink_.Write(text);
}
 
template <OutputSink Sink>
ErrorCode Writer::Executor<Sink>::WritePadding(char fill, size_t count)
{
  char chunk[16];
  std::memset(chunk, fill, sizeof(chunk));
 
  while (count != 0)
  {
    size_t step = (count < sizeof(chunk)) ? count : sizeof(chunk);
    auto ec = WriteRaw(std::string_view(chunk, step));
    if (ec != ErrorCode::OK)
    {
      return ec;
    }
    count -= step;
  }
 
  return ErrorCode::OK;
}
 
template <OutputSink Sink>
ErrorCode Writer::Executor<Sink>::WriteTextField(std::string_view text, const Spec& spec)
{
  size_t pad = FieldPadding(spec.width, text.size());
  size_t left_pad = 0;
  size_t right_pad = 0;
  if (spec.LeftAlign())
  {
    right_pad = pad;
  }
  else if (spec.CenterAlign())
  {
    left_pad = pad / 2;
    right_pad = pad - left_pad;
  }
  else
  {
    left_pad = pad;
  }
 
  if (auto ec = WritePadding(spec.fill, left_pad); ec != ErrorCode::OK)
  {
    return ec;
  }
  if (auto ec = WriteRaw(text); ec != ErrorCode::OK)
  {
    return ec;
  }
  return WritePadding(spec.fill, right_pad);
}
 
template <OutputSink Sink>
ErrorCode Writer::Executor<Sink>::WriteIntegerField(char sign_char,
                                                    std::string_view prefix,
                                                    std::string_view digits,
                                                    const Spec& spec)
{
  auto write_char = [this](char ch) -> ErrorCode
  {
    if (ch == '\0')
    {
      return ErrorCode::OK;
    }
    return WriteRaw(std::string_view(&ch, 1));
  };
  auto write_text = [this](std::string_view text) -> ErrorCode
  {
    if (text.empty())
    {
      return ErrorCode::OK;
    }
    return WriteRaw(text);
  };
 
  size_t zeros = IntegerPrecisionZeros(spec, digits.size());
  size_t total =
      digits.size() + zeros + prefix.size() + static_cast<size_t>(sign_char != '\0');
  size_t pad = FieldPadding(spec.width, total);
  bool zero_fill =
      spec.ZeroPad() && !spec.LeftAlign() && !spec.CenterAlign() && !spec.HasPrecision();
  size_t left_pad = 0;
  size_t middle_zeros = zero_fill ? pad : 0;
  size_t right_pad = 0;
  if (!zero_fill)
  {
    if (spec.LeftAlign())
    {
      right_pad = pad;
    }
    else if (spec.CenterAlign())
    {
      left_pad = pad / 2;
      right_pad = pad - left_pad;
    }
    else
    {
      left_pad = pad;
    }
  }
 
  if (auto ec = WritePadding(spec.fill, left_pad); ec != ErrorCode::OK)
  {
    return ec;
  }
  if (auto ec = write_char(sign_char); ec != ErrorCode::OK)
  {
    return ec;
  }
  if (auto ec = write_text(prefix); ec != ErrorCode::OK)
  {
    return ec;
  }
  if (auto ec = WritePadding('0', middle_zeros); ec != ErrorCode::OK)
  {
    return ec;
  }
  if (auto ec = WritePadding('0', zeros); ec != ErrorCode::OK)
  {
    return ec;
  }
  if (auto ec = write_text(digits); ec != ErrorCode::OK)
  {
    return ec;
  }
  return WritePadding(spec.fill, right_pad);
}
 
template <OutputSink Sink>
ErrorCode Writer::Executor<Sink>::WriteFloatField(char sign_char, std::string_view text,
                                                  const Spec& spec)
{
  auto write_char = [this](char ch) -> ErrorCode
  {
    if (ch == '\0')
    {
      return ErrorCode::OK;
    }
    return WriteRaw(std::string_view(&ch, 1));
  };
 
  size_t total = text.size() + static_cast<size_t>(sign_char != '\0');
  size_t pad = FieldPadding(spec.width, total);
  bool zero_fill = spec.ZeroPad() && !spec.LeftAlign() && !spec.CenterAlign();
  size_t left_pad = 0;
  size_t middle_zeros = zero_fill ? pad : 0;
  size_t right_pad = 0;
  if (!zero_fill)
  {
    if (spec.LeftAlign())
    {
      right_pad = pad;
    }
    else if (spec.CenterAlign())
    {
      left_pad = pad / 2;
      right_pad = pad - left_pad;
    }
    else
    {
      left_pad = pad;
    }
  }
 
  if (auto ec = WritePadding(spec.fill, left_pad); ec != ErrorCode::OK)
  {
    return ec;
  }
  if (auto ec = write_char(sign_char); ec != ErrorCode::OK)
  {
    return ec;
  }
  if (auto ec = WritePadding('0', middle_zeros); ec != ErrorCode::OK)
  {
    return ec;
  }
  if (auto ec = WriteRaw(text); ec != ErrorCode::OK)
  {
    return ec;
  }
  return WritePadding(spec.fill, right_pad);
}