Format

Built-in formatting options and specifications. More...

Classes
struct	mtcore::io::FormatOptions
	Options for specifying formatting. More...
struct	mtcore::io::Formatter< T >
	Struct to override to specify how a type should be formatted. More...
struct	mtcore::io::PaddingOptions
	Represents parsed padding options for formatting output. More...
struct	mtcore::io::Padded< T >
	Formats data with padding into a writer's output stream Uses Formatter<T> under the hood Usually will use extract_padding_options to get padding options. More...
struct	mtcore::io::Formatter< char >
	Formatter for characters Format specifier options for output: More...
struct	mtcore::io::Formatter< T >
	Formats integer numbers (other than char) such as int, unsigned, long long, etc Format specifier options for output: More...
struct	mtcore::io::Formatter< char * >
	Format specifier for null-terminated char* (mutable C-strings) Has same format options as template<Iterable T> struct Formatter<T> More...
struct	mtcore::io::Formatter< const char * >
	Format specifier for null-terminated const char* (C-strings) Has same format options as template<Iterable T> struct Formatter<T> More...
struct	mtcore::io::Formatter< Optional< T > >
	Formatter for an optional Uses the formatter for the underlying value if available No formatting options. More...
struct	mtcore::io::Formatter< Result< V, E > >
	Formatter for a result Will check if the value has been moved out of the result Uses the formatter for the underlying value and/or error if available No formatting options. More...
struct	mtcore::io::Formatter< IPv4 >
	Formats IPv4 addresses No formatting options are available. More...
struct	mtcore::io::Formatter< IPv6 >
	Formats IPv6 addresses Formatting options: More...
struct	mtcore::io::Formatter< SubnetMaskV4 >
	Formats subnet v4 masks. More...
struct	mtcore::io::Formatter< SubnetMaskV6 >
	Formats subnet v4 masks. More...
struct	mtcore::io::Formatter< SubnetV4 >
	Formats a masked version 4 IP address with a subnet. More...
struct	mtcore::io::Formatter< SubnetV6 >
	Formats a masked version 6 IP address with a subnet. More...

Enumerations
enum class	mtcore::io::ContentAlignment { mtcore::io::ContentAlignment::LEFT , mtcore::io::ContentAlignment::RIGHT , mtcore::io::ContentAlignment::CENTER }
	Represents content alignment options for padded formatting options. More...

Functions
Optional< PaddingOptions >	mtcore::io::extract_padding_options (Slice< const char > formatStr)
	Extracts padding options from a format string if present Padding options are in the following form: (padChar)(padDirection)(padLen); Where padChar is the character to pad with (maybe escaped with \ to avoid interpretation as a control character), padDirection is either < for left pad, > for right pad, or ^ for center padding, and padLen is an integer of the minimum length the output should be.
template<WriterImpl WI, typename... Args>
Result< size_t, typename Writer< WI >::ErrType >	mtcore::io::print (Writer< WI > &writer, const char *fmt, const Args &...args)
	Prints arguments using a format string Element insert points are designated by a pair of curly braces {} Format parameters can be between the curly braces (e.g.
template<WriterImpl WI, typename... Args>
Result< size_t, typename Writer< WI >::ErrType >	mtcore::io::print (Writer< WI > &writer, const Slice< const char > &fmt, const Args &...args)
	Prints arguments using a format string Element insert points are designated by a pair of curly braces {} Format parameters can be between the curly braces (e.g.

Detailed Description

Built-in formatting options and specifications.

Enumeration Type Documentation

ContentAlignment

enum class mtcore::io::ContentAlignment

strong

Represents content alignment options for padded formatting options.

Enumerator
LEFT
RIGHT
CENTER

Definition at line 35 of file formats.hpp.

                              {
    LEFT,
    RIGHT,
    CENTER,
  };

Function Documentation

extract_padding_options()

Optional< PaddingOptions > mtcore::io::extract_padding_options ( Slice< const char > formatStr )

inline

Extracts padding options from a format string if present Padding options are in the following form: (padChar)(padDirection)(padLen); Where padChar is the character to pad with (maybe escaped with \ to avoid interpretation as a control character), padDirection is either < for left pad, > for right pad, or ^ for center padding, and padLen is an integer of the minimum length the output should be.

Note that a semicolon at the end is required.

Examples:

• 0<12; - Left pads with zeros for up to 12 characters
• \^>14; - Right pads with carrots (^) for 14 characters
• ^10; - Centers with spaces for 10 character length

Parameters

formatStr

Format string to parse

Returns

Padding options if present, or nullopt

Definition at line 71 of file formats.hpp.

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

Here is the call graph for this function:

Here is the caller graph for this function:

print() [1/2]

template<WriterImpl WI, typename... Args>

Result< size_t, typename Writer< WI >::ErrType > mtcore::io::print	(	Writer< WI > &	writer,
		const char *	fmt,
		const Args &...	args )

Prints arguments using a format string Element insert points are designated by a pair of curly braces {} Format parameters can be between the curly braces (e.g.

{d}) Escaping characters with backslash \ is supported See the Formatter<> specialization for the type of objects your formatting for their specific formatting string options

General pattern is as follows:

For iterables

• Element limit option (e.g. 5! to limit to 5 elements)
• Full iterable padding option (e.g. <12; to left pad to 12 with space)
• Separator options, also serves as indicator of start of element options (e.g. ,: to join with comma)
• Element option(s) with pipe | separating each (e.g. x|d| <12;)

For paddable elements

• Padding in form of padding character (e.g. .), padding direction (<, ^, or >), padding length (12), padding terminator ;

For numbers

• d for decimal, x for hex, o for octal, b for binary

For print, the arguments may be of different types (e.g. 1, 4.5, "hello")

Template Parameters

WI	Writer implementation
Args	Arguments to format

Parameters

writer	Writer to write to
fmt	Format string to write with
args	Arguments to write

Returns

Number of bytes written, or error

Definition at line 482 of file io/writer.hpp.

                                                                                                             {
    return print(writer, slice_from(fmt), args...);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

print() [2/2]

template<WriterImpl WI, typename... Args>

Result< size_t, typename Writer< WI >::ErrType > mtcore::io::print	(	Writer< WI > &	writer,
		const Slice< const char > &	fmt,
		const Args &...	args )

Prints arguments using a format string Element insert points are designated by a pair of curly braces {} Format parameters can be between the curly braces (e.g.

{d}) Escaping characters with backslash \ is supported See the Formatter<> specialization for the type of objects your formatting for their specific formatting string options

General pattern is as follows:

For iterables

• Element limit option (e.g. 5! to limit to 5 elements)
• Full iterable padding option (e.g. <12; to left pad to 12 with space)
• Separator options, also serves as indicator of start of element options (e.g. ,: to join with comma)
• Element option(s) with pipe | separating each (e.g. x|d| <12;)

For paddable elements

• Padding in form of padding character (e.g. .), padding direction (<, ^, or >), padding length (12), padding terminator ;

For numbers

• d for decimal, x for hex, o for octal, b for binary

For print, the arguments may be of different types (e.g. 1, 4.5, "hello")

Template Parameters

WI	Writer implementation
Args	Arguments to format

Parameters

writer	Writer to write to
fmt	Format string to write with
args	Arguments to write

Returns

Number of bytes written, or error

Definition at line 529 of file io/writer.hpp.

                                                                          {
    return impl::print(0, writer, fmt, args...);
  }