mtcore::io::Formatter< char > Struct Reference

Formatter for characters Format specifier options for output: More...

#include <formats.hpp>

Inheritance diagram for mtcore::io::Formatter< char >:

Collaboration diagram for mtcore::io::Formatter< char >:

Static Public Member Functions
template<WriterImpl WI>
static Result< size_t, typename Writer< WI >::ErrType >	fmt (Writer< WI > &writer, const FormatOptions &opts, const char &ch)

Detailed Description

Formatter for characters Format specifier options for output:

• Format padding options (e.g. 0<2;) - Must come before other options if present (i.e. 0<2;x not x0<2;)
• x for lowercase hex
• X for uppercase hex
• o for octal
• b for binary
• d for decimal (numeric, base 10)
• s (or none) for string

See also

extract_padding_options

Definition at line 174 of file formats.hpp.

Member Function Documentation

fmt()

template<WriterImpl WI>

Result< size_t, typename Writer< WI >::ErrType > mtcore::io::Formatter< char >::fmt ( Writer< WI > & writer, const FormatOptions & opts, const char & ch )

static

Definition at line 700 of file formats.hpp.

                                                                                    {
    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));
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this struct was generated from the following file:

• formats.hpp