Format strings module

Argument IDs

The arg-id specifier can be used to index arguments manually. If manual indexing is used, all of the indices in a format string must be stated explicitly. The same arg-id can appear in the format string only once, and must refer to a valid argument.

// Format string equivalent to "{0} to {1}"
auto a = scn::scan<int, int>("2 to 300", "{} to {}");
// a->values() == (2, 300)

// Manual indexing
auto b = scn::scan<int, int>("2 to 300", "{1} to {0}");
// b->values() == (3, 200)

// INVALID:
// Automatic and manual indexing is mixed
auto c = scn::scan<int, int>("2 to 300", "{} to {0}");

// INVALID:
// Same argument is referred to multiple times
auto d = scn::scan<int, int>("2 to 300", "{0} to {0}");

// INVALID:
// {2} does not refer to an argument
auto e = scn::scan<int, int>("2 to 300", "{0} to {2}");

Fill and align

Alignment allows for skipping character before and/or after a value. There are three possible values for alignment:

The fill character can be any Unicode code point, except for { and }. The default fill is any whitespace character, as specified above.

For format type specifiers other than c (default for char and wchar_t, available for string and string_view), [...], and the regex /.../, the default alignment is >. In practice, this means that leading whitespace is skipped by default. For the c format type specifier, there's no default alignment, and no fill characters are skipped, including whitespace.

The number of fill characters consumed can be controlled with the width and precision specifiers.

Width

Width specifies the minimum number of characters that will be read from the source range. It can be any unsigned integer. Any fill characters skipped are included in the width.

For the purposes of width calculation, the same algorithm is used that in {fmt}. Every code point has a width of one, except the following ones have a width of 2:

• any code point with the East_Asian_Width="W" or East_Asian_Width="F" Derived Extracted Property as described by UAX#44
• U+4DC0 – U+4DFF (Yijing Hexagram Symbols)
• U+1F300 – U+1F5FF (Miscellaneous Symbols and Pictographs)
• U+1F900 – U+1F9FF (Supplemental Symbols and Pictographs)

Precision

Precision specifies the maximum number of characters that will be read from the source range. The method for counting characters is the same as above, with the width field.

Localized

The L flag enables localized scanning. Its effects are different for each type it is used with:

• For integers, it enables locale-specific thousands separators
• For floating-point numbers, it enables locale-specific thousands and radix (decimal) separators
• For booleans, it enables locale-specific textual representations (for true and false)
• For other types, it has no effect

Type specifier

The type specifier determines how the data is to be scanned. The type of the argument to be scanned determines what flags are valid.

Classes

template <typename CharT, typename Source, typename... Args>

class scn::basic_scan_format_string

template <typename CharT>

struct scn::detail::basic_runtime_format_string

template <typename T>

struct scn::discard

Functions

auto runtime_format(std::string_view s) -> detail::basic_runtime_format_string<char>

Function documentation