formats.hpp

Go to the documentation of this file.

/*
 
Copyright 2025 Matthew Tolman
 
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
 
   http://www.apache.org/licenses/LICENSE-2.0
 
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
 
*/
 
#ifndef MTCORE_FORMATS_HPP
#define MTCORE_FORMATS_HPP
 
#include "mtcore/alloc.hpp"
#include "mtcore/ascii.hpp"
#include "mtcore/colls/bitset.hpp"
#include "floats.hpp"
#include "format.hpp"
#include "writer.hpp"
#include <cstdio>
 
namespace mtcore::io {
  enum class ContentAlignment {
    LEFT,
    RIGHT,
    CENTER,
  };

  struct PaddingOptions {
    ContentAlignment alignment;
    size_t padLen;
    char pad;
    size_t endPos;
  };

  inline Optional<PaddingOptions> extract_padding_options(Slice<const char> formatStr) {
    if (formatStr.empty()) {
      return nullopt;
    }
    auto semiColon = slices::first_index_not_proceeded_by('\\', ';', formatStr);
    if (!semiColon.has_value()) {
      return nullopt;
    }
 
    auto checkWriter = void_writer<char>();
    // This checks if we have an effective single character
    auto has_single_char = [&checkWriter](Slice<const char> s) {
      auto res = ascii::write_unescaped(checkWriter, s);
      // void writers don't error out, so only error is a bad format string
      ensure(res.is_success(), "BAD FORMAT STRING!");
      return res.value() == 1;
    };
 
    auto alignmentSearchSpace = formatStr.sub(0, semiColon.value());
    auto leftPadLoc           = slices::first_index_not_proceeded_by('\\', '<', alignmentSearchSpace);
    if (leftPadLoc.has_value() && leftPadLoc.value() > 0) {
      auto n = alignmentSearchSpace.sub(leftPadLoc.value() + 1);
      if (!n.empty() && ascii::is_pos_int_str(n)) {
        auto pad = formatStr.sub(0, leftPadLoc.value());
        if (has_single_char(pad)) {
          auto len = ascii::base10_to_int<size_t>(n).value();
          return PaddingOptions{
            .alignment = ContentAlignment::LEFT,
            .padLen    = len,
            .pad       = ascii::unescape_char(pad).value(),
            .endPos    = semiColon.value(),
          };
        }
      }
    }
 
    auto rightPadLoc = slices::first_index_not_proceeded_by('\\', '>', alignmentSearchSpace);
    if (rightPadLoc.has_value() && rightPadLoc.value() > 0) {
      auto n = alignmentSearchSpace.sub(rightPadLoc.value() + 1);
      if (!n.empty() && ascii::is_pos_int_str(n)) {
        auto pad = formatStr.sub(0, rightPadLoc.value());
        if (has_single_char(pad)) {
          auto len = ascii::base10_to_int<size_t>(n).value();
          return PaddingOptions{
            .alignment = ContentAlignment::RIGHT,
            .padLen    = len,
            .pad       = ascii::unescape_char(pad).value(),
            .endPos    = semiColon.value(),
          };
        }
      }
    }
 
    auto centerPadLoc = slices::first_index_not_proceeded_by('\\', '^', alignmentSearchSpace);
    if (centerPadLoc.has_value() && centerPadLoc.value() > 0) {
      auto n = alignmentSearchSpace.sub(centerPadLoc.value() + 1);
      if (!n.empty() && ascii::is_pos_int_str(n)) {
        auto pad = formatStr.sub(0, centerPadLoc.value());
        if (has_single_char(pad)) {
          auto len = ascii::base10_to_int<size_t>(n).value();
          return PaddingOptions{
            .alignment = ContentAlignment::CENTER,
            .padLen    = len,
            .pad       = ascii::unescape_char(pad).value(),
            .endPos    = semiColon.value(),
          };
        }
      }
    }
 
    return nullopt;
  }

  template<typename T>
  struct Padded {
    template<WriterImpl WI>
    static Result<size_t, typename Writer<WI>::ErrType> write_padded(Writer<WI> &writer, const PaddingOptions &padOpts,
                                                                     const FormatOptions &opts, const T &elem);
  };

  template<>
  struct Formatter<char> {
    template<WriterImpl WI>
    static Result<size_t, typename Writer<WI>::ErrType> fmt(Writer<WI> &writer, const FormatOptions &opts,
                                                            const char &ch);
  };

  template<std::integral T>
  struct Formatter<T> {
    static constexpr auto digitTable = std::array{
      static_cast<i64>(1ll),
      static_cast<i64>(10ll),
      static_cast<i64>(100ll),
      static_cast<i64>(1000ll),
      static_cast<i64>(10000ll),
      static_cast<i64>(100000ll),
      static_cast<i64>(1000000ll),
      static_cast<i64>(10000000ll),
      static_cast<i64>(100000000ll),
      static_cast<i64>(1000000000ll),
      static_cast<i64>(10000000000ll),
      static_cast<i64>(100000000000ll),
      static_cast<i64>(1000000000000ll),
      static_cast<i64>(10000000000000ll),
      static_cast<i64>(100000000000000ll),
      static_cast<i64>(1000000000000000ll),
      static_cast<i64>(10000000000000000ll),
      static_cast<i64>(100000000000000000ll),
      static_cast<i64>(1000000000000000000ll),
    };
 
    template<WriterImpl WI>
    static Result<size_t, typename Writer<WI>::ErrType> fmt(Writer<WI> &writer, const FormatOptions &opts,
                                                            const T &val) {
      auto padOpts = extract_padding_options(opts.formatStr);
      if (padOpts.has_value()) {
        return Padded<T>::write_padded(writer, padOpts.value(), {opts.formatStr.sub(padOpts->endPos + 1)}, val);
      }
 
      size_t written = 0;
 
      u64 uval;
      if constexpr (std::is_signed_v<T>) {
        // We want to copy cast the bits without changing the value
        // we also want to 0 fill the sign bit when casting up, that way we get the right hex/binary
        // without a lot of extra padding
        auto tmp    = val;
        auto tmpPtr = reinterpret_cast<std::make_unsigned_t<T> *>(&tmp);
        uval        = *tmpPtr;
      }
      else {
        uval = val;
      }
 
      if (str_equal(opts.formatStr, "X")) {
        static constexpr auto chars = slice_from("0123456789ABCDEF");
 
        auto hexChars = std::array<char, 16>{
          static_cast<char>(chars[(uval >> 60) & 0xfull]), static_cast<char>(chars[(uval >> 56) & 0xfull]),
          static_cast<char>(chars[(uval >> 52) & 0xfull]), static_cast<char>(chars[(uval >> 48) & 0xfull]),
          static_cast<char>(chars[(uval >> 44) & 0xfull]), static_cast<char>(chars[(uval >> 40) & 0xfull]),
          static_cast<char>(chars[(uval >> 36) & 0xfull]), static_cast<char>(chars[(uval >> 32) & 0xfull]),
          static_cast<char>(chars[(uval >> 28) & 0xfull]), static_cast<char>(chars[(uval >> 24) & 0xfull]),
          static_cast<char>(chars[(uval >> 20) & 0xfull]), static_cast<char>(chars[(uval >> 16) & 0xfull]),
          static_cast<char>(chars[(uval >> 12) & 0xfull]), static_cast<char>(chars[(uval >> 8) & 0xfull]),
          static_cast<char>(chars[(uval >> 4) & 0xfull]),  static_cast<char>(chars[(uval >> 0) & 0xfull]),
        };
 
        auto hex   = slice_from(hexChars);
        auto start = slices::first_index_not('0', hex);
 
        if (start.has_value()) {
          auto out = hex.sub(start.value());
          written += out.size();
          auto res = writer.write_all(out);
          return res.with_success_val(written);
        }
        else {
          ++written;
          return writer.write('0').with_success_val(written);
        }
      }
 
      if (str_equal(opts.formatStr, "x")) {
        static constexpr auto chars = slice_from("0123456789abcdef");
 
        auto hexChars = std::array<char, 16>{
          static_cast<char>(chars[(uval >> 60) & 0xfull]), static_cast<char>(chars[(uval >> 56) & 0xfull]),
          static_cast<char>(chars[(uval >> 52) & 0xfull]), static_cast<char>(chars[(uval >> 48) & 0xfull]),
          static_cast<char>(chars[(uval >> 44) & 0xfull]), static_cast<char>(chars[(uval >> 40) & 0xfull]),
          static_cast<char>(chars[(uval >> 36) & 0xfull]), static_cast<char>(chars[(uval >> 32) & 0xfull]),
          static_cast<char>(chars[(uval >> 28) & 0xfull]), static_cast<char>(chars[(uval >> 24) & 0xfull]),
          static_cast<char>(chars[(uval >> 20) & 0xfull]), static_cast<char>(chars[(uval >> 16) & 0xfull]),
          static_cast<char>(chars[(uval >> 12) & 0xfull]), static_cast<char>(chars[(uval >> 8) & 0xfull]),
          static_cast<char>(chars[(uval >> 4) & 0xfull]),  static_cast<char>(chars[(uval >> 0) & 0xfull]),
        };
 
        auto hex   = slice_from(hexChars);
        auto start = slices::first_index_not('0', hex);
 
        if (start.has_value()) {
          auto out = hex.sub(start.value());
          written += out.size();
          auto res = writer.write_all(out);
          return res.with_success_val(written);
        }
        else {
          ++written;
          return writer.write('0').with_success_val(written);
        }
      }
 
      if (str_equal(opts.formatStr, "o")) {
        static constexpr auto chars = slice_from("01234567");
 
        auto hexChars = std::array<char, 22>{
          static_cast<char>(chars[(uval >> 63) & 0x1ull]), static_cast<char>(chars[(uval >> 60) & 0x7ull]),
          static_cast<char>(chars[(uval >> 57) & 0x7ull]), static_cast<char>(chars[(uval >> 54) & 0x7ull]),
          static_cast<char>(chars[(uval >> 51) & 0x7ull]), static_cast<char>(chars[(uval >> 48) & 0x7ull]),
          static_cast<char>(chars[(uval >> 45) & 0x7ull]), static_cast<char>(chars[(uval >> 42) & 0x7ull]),
          static_cast<char>(chars[(uval >> 39) & 0x7ull]), static_cast<char>(chars[(uval >> 36) & 0x7ull]),
          static_cast<char>(chars[(uval >> 33) & 0x7ull]), static_cast<char>(chars[(uval >> 30) & 0x7ull]),
          static_cast<char>(chars[(uval >> 27) & 0x7ull]), static_cast<char>(chars[(uval >> 24) & 0x7ull]),
          static_cast<char>(chars[(uval >> 21) & 0x7ull]), static_cast<char>(chars[(uval >> 18) & 0x7ull]),
          static_cast<char>(chars[(uval >> 15) & 0x7ull]), static_cast<char>(chars[(uval >> 12) & 0x7ull]),
          static_cast<char>(chars[(uval >> 9) & 0x7ull]),  static_cast<char>(chars[(uval >> 6) & 0x7ull]),
          static_cast<char>(chars[(uval >> 3) & 0x7ull]),  static_cast<char>(chars[(uval >> 0) & 0x7ull]),
        };
 
        auto hex   = slice_from(hexChars);
        auto start = slices::first_index_not('0', hex);
 
        if (start.has_value()) {
          auto out = hex.sub(start.value());
          written += out.size();
          auto res = writer.write_all(out);
          return res.with_success_val(written);
        }
        else {
          ++written;
          return writer.write('0').with_success_val(written);
        }
      }
 
      if (str_equal(opts.formatStr, "b")) {
        mtcore::BitsetFixed bits;
        bits.init(uval);
 
        // to print properly to make sense to humans, we actually print "backwards"
        // This is because high bits are traditionally on the left while low bits are traditionally on the right
        auto firstBit = bits.first_set();
        auto lastBit  = bits.last_set();
        if (firstBit.has_value()) {
          ensure(lastBit.has_value());
          for (size_t j = lastBit.value() + 1; j > 0; --j) {
            auto i = j - 1;
            ensure(i < j);
            auto chRes = writer.write(bits.at(i) ? '1' : '0');
            if (chRes.is_error()) {
              return chRes.error();
            }
            ++written;
          }
          return written;
        }
        else {
          ++written;
          return writer.write('0').with_success_val(written);
        }
      }
 
      if constexpr (std::is_signed_v<T>) {
        if (val < 0) {
          if (auto signRes = writer.write('-'); signRes.is_error()) {
            return signRes.error();
          }
          written += 1;
        }
      }
 
      if (val == 0) {
        if (auto zRes = writer.write('0'); zRes.is_error()) {
          return zRes.error();
        }
        written += 1;
      }
      else {
        auto v = val;
        if (val > 0) {
          for (auto numDigits = num_digits(val); numDigits > 0; --numDigits) {
            auto digit = (v / digitTable[numDigits - 1]);
            ensure(digit >= 0 && digit < 10);
            if (auto chRes = writer.write(digit + '0'); chRes.is_error()) {
              return chRes.error();
            }
            ++written;
            v -= digit * digitTable[numDigits - 1];
          }
        }
        else {
          for (auto numDigits = num_digits(val); numDigits > 0; --numDigits) {
            auto digit = -(v / digitTable[numDigits - 1]);
            ensure(digit >= 0 && digit < 10);
            if (auto chRes = writer.write(digit + '0'); chRes.is_error()) {
              return chRes.error();
            }
            ++written;
            v += digit * digitTable[numDigits - 1];
          }
        }
      }
 
      return success(written);
    }
 
    static size_t num_digits(const T &val) {
      if constexpr (std::is_signed_v<T>) {
        if (val < 0) {
          const i64 v = val;
          for (size_t i = 0; i < digitTable.size(); ++i) {
            if (v > -digitTable[i]) {
              return i;
            }
          }
          return digitTable.size();
        }
      }
 
      for (size_t i = 0; i < digitTable.size(); ++i) {
        if (val < static_cast<T>(digitTable[i])) {
          return i;
        }
      }
      return digitTable.size();
    }
  };

  template<std::floating_point T>
  struct Formatter<T> {
    template<WriterImpl WI>
    static Result<size_t, typename Writer<WI>::ErrType> fmt(Writer<WI> &writer, const FormatOptions &opts, T val) {
      auto padOpts = extract_padding_options(opts.formatStr);
      if (padOpts.has_value()) {
        return Padded<T>::write_padded(writer, padOpts.value(), {opts.formatStr.sub(padOpts->endPos + 1)}, val);
      }
      return floats::dragonbox::format_float(writer, static_cast<f64>(val), opts.formatStr);
    }
  };

  template<Iterable T>
  struct Formatter<T> {
    using ElemType = std::remove_const_t<typename decltype(std::declval<T>().iter())::IterElem>;
 
    template<WriterImpl WI>
    static Result<size_t, typename Writer<WI>::ErrType> fmt(Writer<WI> &writer, FormatOptions opts, const T &iterable) {
      size_t maxElems = std::numeric_limits<size_t>::max();
 
      auto endMaxElemPos = slices::first_index_not_proceeded_by('\\', '!', opts.formatStr);
      if (endMaxElemPos.has_value()) {
        auto rng = opts.formatStr.sub(0, endMaxElemPos.value());
        if (!rng.empty() && ascii::is_pos_int_str(rng)) {
          maxElems       = ascii::base10_to_int(rng).value();
          opts.formatStr = opts.formatStr.sub(endMaxElemPos.value() + 1);
        }
      }
 
      auto padOpts = extract_padding_options(opts.formatStr);
      if (padOpts.has_value()) {
        return Padded<T>::write_padded(writer, padOpts.value(), {opts.formatStr.sub(padOpts->endPos + 1)}, iterable);
      }
 
      // default separator
      auto sep = slice_from(" ");
      if constexpr (std::is_same_v<ElemType, char>) {
        if (opts.formatStr.empty()) {
          sep = slice_from("");
        }
      }
 
      auto sepIndex = slices::first_index_not_proceeded_by('\\', ':', opts.formatStr);
      if (sepIndex.has_value()) {
        sep            = opts.formatStr.sub(0, sepIndex.value());
        opts.formatStr = opts.formatStr.sub(sepIndex.value() + 1);
      }
 
      auto iter = iterable.iter();
      ElemType cur;
      auto first     = true;
      size_t written = 0;
      size_t elem    = 0;
      while (elem++ < maxElems && iter.next().move_if_present(cur)) {
        if (first) {
          first = false;
        }
        else {
          auto sepRes = ascii::write_unescaped(writer, sep);
          if (sepRes.is_error()) {
            auto errCode = sepRes.error().code;
            ensure(!std::holds_alternative<ascii::UnescapeError>(errCode), "BAD FORMAT STRING");
            return error(std::get<typename Writer<WI>::ErrType>(errCode));
          }
          written += sepRes.value();
        }
 
        auto fmtSegEnd =
          opts.formatStr.empty() ? Optional<size_t>{} : slices::first_index_not_proceeded_by('\\', '|', opts.formatStr);
        auto fullOpts = opts.formatStr;
        if (fmtSegEnd.has_value()) {
          opts.formatStr = opts.formatStr.sub(0, fmtSegEnd.value());
        }
        mtdefer {
          if (fmtSegEnd.has_value()) {
            opts.formatStr = fullOpts.sub(fmtSegEnd.value() + 1);
          }
        };
        auto elemRes = Formatter<ElemType>::fmt(writer, opts, cur);
        if (elemRes.is_error()) {
          return elemRes.error();
        }
        written += elemRes.value();
      }
      return success(written);
    }
  };

  template<StdIterable T>
  struct Formatter<T> {
    using ElemType = std::remove_reference_t<std::remove_const_t<decltype(*std::begin(std::declval<T &>()))>>;
 
    template<WriterImpl WI>
    static Result<size_t, typename Writer<WI>::ErrType> fmt(Writer<WI> &writer, FormatOptions opts, const T &iterable) {
      size_t maxElems = std::numeric_limits<size_t>::max();
 
      if (!opts.formatStr.empty()) {
        auto endMaxElemPos = slices::first_index_not_proceeded_by('\\', '!', opts.formatStr);
        if (endMaxElemPos.has_value()) {
          auto rng = opts.formatStr.sub(0, endMaxElemPos.value());
          if (!rng.empty() && ascii::is_pos_int_str(rng)) {
            maxElems       = ascii::base10_to_int(rng).value();
            opts.formatStr = opts.formatStr.sub(endMaxElemPos.value() + 1);
          }
        }
      }
 
      auto padOpts = extract_padding_options(opts.formatStr);
      if (padOpts.has_value()) {
        return Padded<T>::write_padded(writer, padOpts.value(), {opts.formatStr.sub(padOpts->endPos + 1)}, iterable);
      }
 
      // default separator
      auto sep = slice_from(" ");
      if constexpr (std::is_same_v<ElemType, char>) {
        if (opts.formatStr.empty()) {
          sep = slice_from("");
        }
      }
 
      auto sepIndex = slices::first_index_not_proceeded_by('\\', ':', opts.formatStr);
      if (sepIndex.has_value()) {
        sep            = opts.formatStr.sub(0, sepIndex.value());
        opts.formatStr = opts.formatStr.sub(sepIndex.value() + 1);
      }
 
      auto first     = true;
      size_t written = 0;
      size_t elem    = 0;
      for (const auto &cur: iterable) {
        if (elem++ >= maxElems) {
          break;
        }
        if (first) {
          first = false;
        }
        else {
          auto sepRes = ascii::write_unescaped(writer, sep);
          if (sepRes.is_error()) {
            auto errCode = sepRes.error().code;
            ensure(!std::holds_alternative<ascii::UnescapeError>(errCode), "BAD FORMAT STRING");
            return error(std::get<typename Writer<WI>::ErrType>(errCode));
          }
          written += sepRes.value();
        }
 
        auto fmtSegEnd =
          opts.formatStr.empty() ? Optional<size_t>{} : slices::first_index_not_proceeded_by('\\', '|', opts.formatStr);
        auto fullOpts = opts.formatStr;
        if (fmtSegEnd.has_value()) {
          opts.formatStr = opts.formatStr.sub(0, fmtSegEnd.value());
        }
        mtdefer {
          if (fmtSegEnd.has_value()) {
            opts.formatStr = fullOpts.sub(fmtSegEnd.value() + 1);
          }
        };
        auto elemRes = Formatter<ElemType>::fmt(writer, opts, cur);
        if (elemRes.is_error()) {
          return elemRes.error();
        }
        written += elemRes.value();
      }
      return success(written);
    }
  };
 

  template<>
  struct Formatter<char *> {
    template<WriterImpl WI>
    static Result<size_t, typename Writer<WI>::ErrType> fmt(Writer<WI> &writer, const FormatOptions &opts, char *ch) {
      return Formatter<Slice<const char>>::fmt(writer, opts, slice_from(ch));
    }
  };
 

  template<>
  struct Formatter<const char *> {
    template<WriterImpl WI>
    static Result<size_t, typename Writer<WI>::ErrType> fmt(Writer<WI> &writer, const FormatOptions &opts,
                                                            const char *ch) {
      return Formatter<Slice<const char>>::fmt(writer, opts, slice_from(ch));
    }
  };
 
  template<WriterImpl WI>
  Result<size_t, typename Writer<WI>::ErrType> Formatter<char>::fmt(Writer<WI> &writer, const FormatOptions &opts,
                                                                    const char &ch) {
    auto padOpts = extract_padding_options(opts.formatStr);
    if (padOpts.has_value()) {
      return Padded<char>::write_padded(writer, padOpts.value(), {opts.formatStr.sub(padOpts->endPos + 1)}, ch);
    }
 
    if (str_equal(opts.formatStr, "b")) {
      auto bits = std::array<int, 8>{
        (ch >> 7) & 0x1, (ch >> 6) & 0x1, (ch >> 5) & 0x1, (ch >> 4) & 0x1,
        (ch >> 3) & 0x1, (ch >> 2) & 0x1, (ch >> 1) & 0x1, (ch >> 0) & 0x1,
      };
      auto bit   = slice_from(bits);
      auto start = slices::first_index(1, bit);
 
      // write the minimal bits needed
      if (!start.has_value()) {
        return Formatter<int>::fmt(writer, {slice_from("d")}, 0);
      }
      else {
        return Formatter<Slice<const int>>::fmt(writer, FormatOptions{slice_from(":")},
                                                slice_from(bits).sub(start.value()));
      }
    }
    else if (str_equal(opts.formatStr, "X")) {
      constexpr auto chars = "0123456789ABCDEF";
 
      auto c = chars[(ch >> 4) & 0xf];
      // by default, no padding
      if (c != '0') {
        auto ch1 = writer.write(c);
        if (ch1.is_error()) {
          return ch1.error();
        }
      }
      auto ch2 = writer.write(chars[ch & 0xf]);
      if (ch2.is_error()) {
        return ch2.error();
      }
      return static_cast<size_t>(c != '0' ? 2 : 1);
    }
    else if (str_equal(opts.formatStr, "x")) {
      constexpr auto chars = "0123456789abcdef";
      auto c               = chars[(ch >> 4) & 0xf];
      // by default, no padding
      if (c != '0') {
        auto ch1 = writer.write(c);
        if (ch1.is_error()) {
          return ch1.error();
        }
      }
      auto ch2 = writer.write(chars[ch & 0xf]);
      if (ch2.is_error()) {
        return ch2.error();
      }
      return static_cast<size_t>(c != '0' ? 2 : 1);
    }
    else if (str_equal(opts.formatStr, "o")) {
      constexpr auto chars = "01234567";
      auto octalChars      = std::array<char, 22>{
        static_cast<char>(chars[(ch >> 6) & 0x5ull]),
        static_cast<char>(chars[(ch >> 3) & 0x7ull]),
        static_cast<char>(chars[(ch >> 0) & 0x7ull]),
      };
      auto octal = slice_from(octalChars);
      auto start = slices::first_index_not('0', octal);
 
      size_t written = 0;
      if (start.has_value()) {
        auto out = octal.sub(start.value());
        written += out.size();
        auto res = writer.write_all(out);
        return res.with_success_val(written);
      }
      else {
        ++written;
        return writer.write('0').with_success_val(written);
      }
    }
    else if (str_equal(opts.formatStr, "d")) {
      auto v = static_cast<u8>(ch);
      return Formatter<u8>::fmt(writer, {slice_from("d")}, v);
    }
    else {
      return writer.write(ch).with_success_val(static_cast<size_t>(1));
    }
  }
 
  template<typename T>
  template<WriterImpl WI>
  Result<size_t, typename Writer<WI>::ErrType>
  Padded<T>::write_padded(Writer<WI> &writer, const PaddingOptions &padOpts, const FormatOptions &opts, const T &elem) {
    // Do a dry run to get what the ending length will be
    // Doing a dry run since we're so disconnected from the logic
    // that we can't accurately tell the final length without "printing"
    auto dryRunWriter = void_writer<typename Writer<WI>::WriteElem>();
    auto sizeRes      = Formatter<T>::fmt(dryRunWriter, opts, elem);
    ensure(sizeRes.is_success());
    size_t len = sizeRes.value();
 
    // If we don't need to pad, just write it directly
    if (len >= padOpts.padLen) {
      return Formatter<T>::fmt(writer, opts, elem);
    }
 
    switch (padOpts.alignment) {
      case ContentAlignment::LEFT: {
        auto padRes = writer.write_n_times(padOpts.pad, padOpts.padLen - len);
        if (padRes.is_error()) {
          return padRes.error();
        }
        return Formatter<T>::fmt(writer, opts, elem).with_success_val(padOpts.padLen);
      }
      case ContentAlignment::RIGHT: {
        auto contentRes = Formatter<T>::fmt(writer, opts, elem);
        if (contentRes.is_error()) {
          return contentRes.error();
        }
        return writer.write_n_times(padOpts.pad, padOpts.padLen - len).with_success_val(padOpts.padLen);
      }
      case ContentAlignment::CENTER: {
        auto leftPad  = (padOpts.padLen - len) / 2;
        auto rightPad = leftPad;
 
        // If we have to be lopsided, put the extra padding on the right
        if (leftPad + rightPad + len != padOpts.padLen) {
          ++rightPad;
        }
        auto padLeftRes = writer.write_n_times(padOpts.pad, leftPad);
        if (padLeftRes.is_error()) {
          return padLeftRes.error();
        }
        auto contentRes = Formatter<T>::fmt(writer, opts, elem);
        if (contentRes.is_error()) {
          return contentRes.error();
        }
        return writer.write_n_times(padOpts.pad, rightPad).with_success_val(padOpts.padLen);
      }
      default:
        unreachable();
    }
  }
}  // namespace mtcore
 
#include "mtcore/csv/common.hpp"
 
namespace mtcore::io {
  template<typename T>
  struct Formatter<Optional<T>> {
    template<WriterImpl WI>
    static Result<size_t, typename Writer<WI>::ErrType> fmt(Writer<WI> &writer, const FormatOptions &, Optional<T> opt) {
      if (!opt.has_value()) {
        return writer.write_all(slice_from("nullopt"));
      }
      if constexpr (is_formattable<T>) {
        return print(writer, "Optional\\{{}\\}", opt.value());
      }
      else {
        return writer.write_all(slice_from("Optional{?}"));
      }
    }
  };

  template<typename V, typename E>
  struct Formatter<Result<V, E>> {
    template<WriterImpl WI>
    static Result<size_t, typename Writer<WI>::ErrType> fmt(Writer<WI> &writer, const FormatOptions &, Result<V, E> res) {
      if (!res.is_success() || !res.is_error()) {
        return writer.write_all(slice_from("Result{<MOVED>}"));
      }
 
      if (res.is_error()) {
        if constexpr (is_formattable<E>) {
          return print(writer, "Result\\{<ERROR> {}\\}", res.error());
        }
        else if constexpr (std::is_convertible_v<E, int>) {
          const auto err = static_cast<int>(res.error());
          auto typeId = typeid(E).name();
          return print(writer, "Result\\{<ERROR> {} {}\\}", slice_from(typeId), err);
        }
        else {
          return writer.write_all(slice_from("Result\\{<ERROR>\\}"));
        }
      }
 
      if constexpr (std::is_same_v<void, V>) {
        return writer.write_all(slice_from("Result{<SUCCESS>}"));
      }
      else if constexpr (is_formattable<V>) {
        return print(writer, "Result\\{<SUCCESS> {}\\}", res.value());
      }
      else {
        return print(writer, "Result\\{<SUCCESS> ?\\}");
      }
    }
  };
}  // namespace mtcore
 
#include "../traits.hpp"

template<mtcore::Pointer T>
struct mtcore::io::Formatter<T> {
  template<WriterImpl WI>
  static Result<size_t, typename Writer<WI>::ErrType> fmt(Writer<WI> &writer, const FormatOptions & opts, T ptr) {
    if (ptr == nullptr) {
      return writer.write_all(slice_from("nullptr"));
    }
 
    if (str_equal(opts.formatStr, "*")) {
      if constexpr (is_formattable<std::remove_cvref_t<std::remove_pointer_t<T>>>) {
        return print(writer, "*{}", *ptr);
      }
      else {
        return writer.write_all(slice_from("*?"));
      }
    }
 
    auto addr = reinterpret_cast<intptr_t>(ptr);
    if (str_equal(opts.formatStr, "x")) {
      return print(writer, "{x}", addr);
    }
    if (str_equal(opts.formatStr, "s")) {
      return print(writer, "0x{x}", addr);
    }
    return print(writer, "Addr 0x{x}", addr);
  }
};
 
template<mtcore::InlineFormattable T>
struct mtcore::io::Formatter<T> {
  template<WriterImpl WI>
  static Result<size_t, typename Writer<WI>::ErrType> fmt(Writer<WI> &writer, const FormatOptions &opts, const T &f) {
    return f.format(writer, opts);
  }
};
 
namespace mtcore::io {
  template<Formattable WI>
  struct EnsureFormattable : std::true_type {};
  static_assert(EnsureFormattable<char>::value);
}
 
#endif  // MTCORE_FORMATS_HPP