11.4.3 Locale-Dependent Output

This means that to use a locale-dependent notation, you have to use the L specifier and either pass the locale as the first argument to std::format() or set the global locale before calling it. For example:

In several cases, you can even use an alternative locale’s representation according to strftime() and ISO 8601:2004, which you can specify with a leading O or E in front of the conversion specifier:

•E can be used as the locale’s alternate representations in front of c, C, x, X, y, Y, and z

•O can be used as the locale’s alternate numeric symbols in front of d, e, H, I, m, M, S, u, U V, w, W, y, and z

11.4.4 Formatted Input

The chrono library also supports formatted input. You have two options:

•A free-standing function std::chrono::from_stream() is provided by certain date/time types to read in a specific value according to a passed format string.

•A manipulator std::chrono::parse() allows us to use from_stream() as part of a bigger parsing with the input operator >>.

Using from_stream()

The following code demonstrates how to use from_stream() by parsing a full timepoint:

std::chrono::sys_seconds tp; std::istringstream sstrm{"2021-2-28 17:30:00"};

std::chrono::from_stream(sstrm, "%F %T", tp); if (sstrm) {

std::cout << "tp: " << tp << '\n';

}

else {

std::cerr << "reading into tp failed\n";

}

The code generates the following output:

tp: 2021-02-28 17:30:00

As another example, you can parse a year_month from a sequence of characters specifying the full month name and the year, among other things, as follows:

std::chrono::year_month m;

std::istringstream sstrm{"Monday, April 5, 2021"}; std::chrono::from_stream(sstrm, "%A, %B %d, %Y", m); if (sstrm) {

std::cout << "month: " << m << '\n'; // prints: month: 2021/Apr

}

The format string accepts all conversion specifiers of formatted output except %q and %Q with improved flexibility. For example:

•%d stands for one or two characters to specify the day and with %4d, you can specify that even up to four characters are parsed.

•%n stands for exactly one whitespace character.

•%t stands for zero or one whitespace character.

•A whitespace character such as a space represents an arbitrary number of whitespaces (including zero whitespaces).

from_stream() is provided for the following types:

•A duration<> of any type

•A sys_time<>, utc_time<>, gps_time<>, tai_time<>, local_time<>, or file_time<> of any duration

•A day, a month, or a year

•A year_month, a month_day, or a year_month_day

•A weekday

The format has to be a C string of type const char*. It must match the characters in the input stream and the value to parse. The parsing fails if:

•The input sequence of characters does not match the required format

•The format does not provide enough information for the value

•The parsed date is not valid

In that case, the failbit of the stream is set, which you can test with by calling fail() or using the stream as a Boolean value.

A Generic Function for Parsing Dates/Times

In practice, dates and times are rarely hard-coded. However, when testing code, you often need an easy way to specify a date/time value.

chr::sys_days tp; chr::hours h; chr::minutes m;

// parse date into tp, hour into h and minute into m: std::istringstream{"12/24/21 18:00"} >> chr::parse("%D", tp)

>>chr::parse(" %H", h)

>>chr::parse(":%M", m);

std::cout << tp << " at " << h << ' ' << m << '\n';

This code outputs:

2021-12-24 at 18h 0min

Again, note that you might have to explicitly convert the string literals "%D", " %H", and ":%M" to strings.

Parsing Timezones

Parsing timezones is a little tricky because timezone abbreviations are not unique: To help here, from_stream() has the following formats:

istream from_stream(istream, format, value)

istream from_stream(istream, format, value, abbrevPtr)

istream from_stream(istream, format, value, abbrevPtr, offsetPtr)

As you can see, you can optionally pass the address of a std::string to store a parsed timezone abbreviation into the string and the address of a std::chrono::minutes object to store a parsed timezone offset into that string. In both cases nullptr can be passed.

However, you still have to be careful:

• The following works:

chr::sys_seconds tp;

std::istringstream sstrm{"2021-4-13 12:00 UTC"}; chr::from_stream(sstrm, "%F %R %Z", tp);

std::cout << std::format("{:%F %R %Z}\n", tp); // 2021-04-13 12:00 UTC

However, it works only because system timepoints use UTC anyway.

• The following does not work because it ignores the timezone: chr::sys_seconds tp;

std::istringstream sstrm{"2021-4-13 12:00 MST"}; chr::from_stream(sstrm, "%F %R %Z", tp);

std::cout << std::format("{:%F %R %Z}", tp); // 2021-04-13 12:00 UTC %Z is used to parse MST but there is no parameter to store the value.

• The following seems to work: chr::sys_seconds tp; std::string tzAbbrev;

std::istringstream sstrm{"2021-4-13 12:00 MST"}; chr::from_stream(sstrm, "%F %R %Z", tp, &tzAbbrev);

std::cout << tzAbbrev << '\n'; // MST

However, if you compute the zoned time, you see that you are converting a UTC time to a different timezone:

std::string tzAbbrev;

std::istringstream sstrm{"2021-4-13 12:00 MST"}; chr::from_stream(sstrm, "%F %R %Z", tp, &tzAbbrev);

However, we were lucky that MST is one of the few abbreviations available as a deprecated entry in the timezone database. The moment you use this code with CEST or CST, it throws an exception when initializing the zoned_time.

• Therefore, either use only tzAbbrev instead of zoned_time and %Z: chr::local_seconds tp; // local time

std::string tzAbbrev;

std::istringstream sstrm{"2021-4-13 12:00 CST"}; chr::from_stream(sstrm, "%F %R %Z", tp, &tzAbbrev);

std::cout << std::format("{:%F %R} {}", tp, tzAbbrev); // 2021-04-13 12:00 CST or you have to deal with code to map a timezone abbreviation to a timezone.

Note that %Z cannot parse the pseudo timezones GPS and TAI.