1// -*- C++ -*- 2//===----------------------------------------------------------------------===// 3// 4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 5// See https://llvm.org/LICENSE.txt for license information. 6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 7// 8//===----------------------------------------------------------------------===// 9 10#ifndef _LIBCPP_FORMAT 11#define _LIBCPP_FORMAT 12 13/* 14 15namespace std { 16 // [format.context], class template basic_format_context 17 template<class Out, class charT> class basic_format_context; 18 using format_context = basic_format_context<unspecified, char>; 19 using wformat_context = basic_format_context<unspecified, wchar_t>; 20 21 // [format.args], class template basic_format_args 22 template<class Context> class basic_format_args; 23 using format_args = basic_format_args<format_context>; 24 using wformat_args = basic_format_args<wformat_context>; 25 26 // [format.functions], formatting functions 27 template<class... Args> 28 string format(string_view fmt, const Args&... args); 29 template<class... Args> 30 wstring format(wstring_view fmt, const Args&... args); 31 template<class... Args> 32 string format(const locale& loc, string_view fmt, const Args&... args); 33 template<class... Args> 34 wstring format(const locale& loc, wstring_view fmt, const Args&... args); 35 36 string vformat(string_view fmt, format_args args); 37 wstring vformat(wstring_view fmt, wformat_args args); 38 string vformat(const locale& loc, string_view fmt, format_args args); 39 wstring vformat(const locale& loc, wstring_view fmt, wformat_args args); 40 41 template<class Out, class... Args> 42 Out format_to(Out out, string_view fmt, const Args&... args); 43 template<class Out, class... Args> 44 Out format_to(Out out, wstring_view fmt, const Args&... args); 45 template<class Out, class... Args> 46 Out format_to(Out out, const locale& loc, string_view fmt, const Args&... args); 47 template<class Out, class... Args> 48 Out format_to(Out out, const locale& loc, wstring_view fmt, const Args&... args); 49 50 template<class Out> 51 Out vformat_to(Out out, string_view fmt, format_args args); 52 template<class Out> 53 Out vformat_to(Out out, wstring_view fmt, wformat_args args); 54 template<class Out> 55 Out vformat_to(Out out, const locale& loc, string_view fmt, 56 format_args char> args); 57 template<class Out> 58 Out vformat_to(Out out, const locale& loc, wstring_view fmt, 59 wformat_args args); 60 61 template<class Out> struct format_to_n_result { 62 Out out; 63 iter_difference_t<Out> size; 64 }; 65 template<class Out, class... Args> 66 format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n, 67 string_view fmt, const Args&... args); 68 template<class Out, class... Args> 69 format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n, 70 wstring_view fmt, const Args&... args); 71 template<class Out, class... Args> 72 format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n, 73 const locale& loc, string_view fmt, 74 const Args&... args); 75 template<class Out, class... Args> 76 format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n, 77 const locale& loc, wstring_view fmt, 78 const Args&... args); 79 80 template<class... Args> 81 size_t formatted_size(string_view fmt, const Args&... args); 82 template<class... Args> 83 size_t formatted_size(wstring_view fmt, const Args&... args); 84 template<class... Args> 85 size_t formatted_size(const locale& loc, string_view fmt, const Args&... args); 86 template<class... Args> 87 size_t formatted_size(const locale& loc, wstring_view fmt, const Args&... args); 88 89 // [format.formatter], formatter 90 template<class T, class charT = char> struct formatter; 91 92 // [format.parse.ctx], class template basic_format_parse_context 93 template<class charT> class basic_format_parse_context; 94 using format_parse_context = basic_format_parse_context<char>; 95 using wformat_parse_context = basic_format_parse_context<wchar_t>; 96 97 // [format.arguments], arguments 98 // [format.arg], class template basic_format_arg 99 template<class Context> class basic_format_arg; 100 101 template<class Visitor, class Context> 102 see below visit_format_arg(Visitor&& vis, basic_format_arg<Context> arg); 103 104 // [format.arg.store], class template format-arg-store 105 template<class Context, class... Args> struct format-arg-store; // exposition only 106 107 template<class Context = format_context, class... Args> 108 format-arg-store<Context, Args...> 109 make_format_args(const Args&... args); 110 template<class... Args> 111 format-arg-store<wformat_context, Args...> 112 make_wformat_args(const Args&... args); 113 114 // [format.error], class format_error 115 class format_error; 116} 117 118*/ 119 120// Make sure all feature-test macros are available. 121#include <version> 122// Enable the contents of the header only when libc++ was built with LIBCXX_ENABLE_INCOMPLETE_FEATURES. 123#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT) 124 125#include <__algorithm/clamp.h> 126#include <__config> 127#include <__debug> 128#include <__format/format_arg.h> 129#include <__format/format_args.h> 130#include <__format/format_context.h> 131#include <__format/format_error.h> 132#include <__format/format_fwd.h> 133#include <__format/format_parse_context.h> 134#include <__format/format_string.h> 135#include <__format/format_to_n_result.h> 136#include <__format/formatter.h> 137#include <__format/formatter_bool.h> 138#include <__format/formatter_char.h> 139#include <__format/formatter_floating_point.h> 140#include <__format/formatter_integer.h> 141#include <__format/formatter_pointer.h> 142#include <__format/formatter_string.h> 143#include <__format/parser_std_format_spec.h> 144#include <__variant/monostate.h> 145#include <array> 146#include <concepts> 147#include <string> 148#include <string_view> 149#include <type_traits> 150 151#ifndef _LIBCPP_HAS_NO_LOCALIZATION 152#include <locale> 153#endif 154 155#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 156# pragma GCC system_header 157#endif 158 159_LIBCPP_BEGIN_NAMESPACE_STD 160 161#if _LIBCPP_STD_VER > 17 162 163// TODO FMT Move the implementation in this file to its own granular headers. 164 165// TODO FMT Evaluate which templates should be external templates. This 166// improves the efficiency of the header. However since the header is still 167// under heavy development and not all classes are stable it makes no sense 168// to do this optimization now. 169 170using format_args = basic_format_args<format_context>; 171#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 172using wformat_args = basic_format_args<wformat_context>; 173#endif 174 175template <class _Context, class... _Args> 176struct _LIBCPP_TEMPLATE_VIS __format_arg_store { 177 // TODO FMT Use a built-in array. 178 array<basic_format_arg<_Context>, sizeof...(_Args)> __args; 179}; 180 181template <class _Context = format_context, class... _Args> 182_LIBCPP_HIDE_FROM_ABI __format_arg_store<_Context, _Args...> 183make_format_args(const _Args&... __args) { 184 return {basic_format_arg<_Context>(__args)...}; 185} 186 187#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 188template <class... _Args> 189_LIBCPP_HIDE_FROM_ABI __format_arg_store<wformat_context, _Args...> 190make_wformat_args(const _Args&... __args) { 191 return _VSTD::make_format_args<wformat_context>(__args...); 192} 193#endif 194 195namespace __format { 196 197template <class _CharT, class _ParseCtx, class _Ctx> 198_LIBCPP_HIDE_FROM_ABI const _CharT* 199__handle_replacement_field(const _CharT* __begin, const _CharT* __end, 200 _ParseCtx& __parse_ctx, _Ctx& __ctx) { 201 __format::__parse_number_result __r = 202 __format::__parse_arg_id(__begin, __end, __parse_ctx); 203 204 switch (*__r.__ptr) { 205 case _CharT(':'): 206 // The arg-id has a format-specifier, advance the input to the format-spec. 207 __parse_ctx.advance_to(__r.__ptr + 1); 208 break; 209 case _CharT('}'): 210 // The arg-id has no format-specifier. 211 __parse_ctx.advance_to(__r.__ptr); 212 break; 213 default: 214 __throw_format_error( 215 "The replacement field arg-id should terminate at a ':' or '}'"); 216 } 217 218 _VSTD::visit_format_arg( 219 [&](auto __arg) { 220 if constexpr (same_as<decltype(__arg), monostate>) 221 __throw_format_error("Argument index out of bounds"); 222 else if constexpr (same_as<decltype(__arg), typename basic_format_arg<_Ctx>::handle>) 223 __arg.format(__parse_ctx, __ctx); 224 else { 225 formatter<decltype(__arg), _CharT> __formatter; 226 __parse_ctx.advance_to(__formatter.parse(__parse_ctx)); 227 __ctx.advance_to(__formatter.format(__arg, __ctx)); 228 } 229 }, 230 __ctx.arg(__r.__value)); 231 232 __begin = __parse_ctx.begin(); 233 if (__begin == __end || *__begin != _CharT('}')) 234 __throw_format_error("The replacement field misses a terminating '}'"); 235 236 return ++__begin; 237} 238 239template <class _ParseCtx, class _Ctx> 240_LIBCPP_HIDE_FROM_ABI typename _Ctx::iterator 241__vformat_to(_ParseCtx&& __parse_ctx, _Ctx&& __ctx) { 242 using _CharT = typename _ParseCtx::char_type; 243 static_assert(same_as<typename _Ctx::char_type, _CharT>); 244 245 const _CharT* __begin = __parse_ctx.begin(); 246 const _CharT* __end = __parse_ctx.end(); 247 typename _Ctx::iterator __out_it = __ctx.out(); 248 while (__begin != __end) { 249 switch (*__begin) { 250 case _CharT('{'): 251 ++__begin; 252 if (__begin == __end) 253 __throw_format_error("The format string terminates at a '{'"); 254 255 if (*__begin != _CharT('{')) [[likely]] { 256 __ctx.advance_to(_VSTD::move(__out_it)); 257 __begin = 258 __handle_replacement_field(__begin, __end, __parse_ctx, __ctx); 259 __out_it = __ctx.out(); 260 261 // The output is written and __begin points to the next character. So 262 // start the next iteration. 263 continue; 264 } 265 // The string is an escape character. 266 break; 267 268 case _CharT('}'): 269 ++__begin; 270 if (__begin == __end || *__begin != _CharT('}')) 271 __throw_format_error( 272 "The format string contains an invalid escape sequence"); 273 274 break; 275 } 276 277 // Copy the character to the output verbatim. 278 *__out_it++ = *__begin++; 279 } 280 return __out_it; 281} 282 283} // namespace __format 284 285template <class _OutIt, class _CharT, class _FormatOutIt> 286requires(output_iterator<_OutIt, const _CharT&>) _LIBCPP_HIDE_FROM_ABI _OutIt 287 __vformat_to( 288 _OutIt __out_it, basic_string_view<_CharT> __fmt, 289 basic_format_args<basic_format_context<_FormatOutIt, _CharT>> __args) { 290 if constexpr (same_as<_OutIt, _FormatOutIt>) 291 return _VSTD::__format::__vformat_to( 292 basic_format_parse_context{__fmt, __args.__size()}, 293 _VSTD::__format_context_create(_VSTD::move(__out_it), __args)); 294 else { 295 basic_string<_CharT> __str; 296 _VSTD::__format::__vformat_to( 297 basic_format_parse_context{__fmt, __args.__size()}, 298 _VSTD::__format_context_create(_VSTD::back_inserter(__str), __args)); 299 return _VSTD::copy_n(__str.begin(), __str.size(), _VSTD::move(__out_it)); 300 } 301} 302 303template <output_iterator<const char&> _OutIt> 304_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt 305vformat_to(_OutIt __out_it, string_view __fmt, format_args __args) { 306 return _VSTD::__vformat_to(_VSTD::move(__out_it), __fmt, __args); 307} 308 309#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 310template <output_iterator<const wchar_t&> _OutIt> 311_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt 312vformat_to(_OutIt __out_it, wstring_view __fmt, wformat_args __args) { 313 return _VSTD::__vformat_to(_VSTD::move(__out_it), __fmt, __args); 314} 315#endif 316 317template <output_iterator<const char&> _OutIt, class... _Args> 318_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt 319format_to(_OutIt __out_it, string_view __fmt, const _Args&... __args) { 320 return _VSTD::vformat_to(_VSTD::move(__out_it), __fmt, 321 _VSTD::make_format_args(__args...)); 322} 323 324#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 325template <output_iterator<const wchar_t&> _OutIt, class... _Args> 326_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt 327format_to(_OutIt __out_it, wstring_view __fmt, const _Args&... __args) { 328 return _VSTD::vformat_to(_VSTD::move(__out_it), __fmt, 329 _VSTD::make_wformat_args(__args...)); 330} 331#endif 332 333_LIBCPP_ALWAYS_INLINE inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT string 334vformat(string_view __fmt, format_args __args) { 335 string __res; 336 _VSTD::vformat_to(_VSTD::back_inserter(__res), __fmt, __args); 337 return __res; 338} 339 340#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 341_LIBCPP_ALWAYS_INLINE inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT wstring 342vformat(wstring_view __fmt, wformat_args __args) { 343 wstring __res; 344 _VSTD::vformat_to(_VSTD::back_inserter(__res), __fmt, __args); 345 return __res; 346} 347#endif 348 349template <class... _Args> 350_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT string 351format(string_view __fmt, const _Args&... __args) { 352 return _VSTD::vformat(__fmt, _VSTD::make_format_args(__args...)); 353} 354 355#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 356template <class... _Args> 357_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT wstring 358format(wstring_view __fmt, const _Args&... __args) { 359 return _VSTD::vformat(__fmt, _VSTD::make_wformat_args(__args...)); 360} 361#endif 362 363template <output_iterator<const char&> _OutIt, class... _Args> 364_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT format_to_n_result<_OutIt> 365format_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n, string_view __fmt, 366 const _Args&... __args) { 367 // TODO FMT Improve PoC: using std::string is inefficient. 368 string __str = _VSTD::vformat(__fmt, _VSTD::make_format_args(__args...)); 369 iter_difference_t<_OutIt> __s = __str.size(); 370 iter_difference_t<_OutIt> __m = 371 _VSTD::clamp(__n, iter_difference_t<_OutIt>(0), __s); 372 __out_it = _VSTD::copy_n(__str.begin(), __m, _VSTD::move(__out_it)); 373 return {_VSTD::move(__out_it), __s}; 374} 375 376#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 377template <output_iterator<const wchar_t&> _OutIt, class... _Args> 378_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT format_to_n_result<_OutIt> 379format_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n, wstring_view __fmt, 380 const _Args&... __args) { 381 // TODO FMT Improve PoC: using std::string is inefficient. 382 wstring __str = _VSTD::vformat(__fmt, _VSTD::make_wformat_args(__args...)); 383 iter_difference_t<_OutIt> __s = __str.size(); 384 iter_difference_t<_OutIt> __m = 385 _VSTD::clamp(__n, iter_difference_t<_OutIt>(0), __s); 386 __out_it = _VSTD::copy_n(__str.begin(), __m, _VSTD::move(__out_it)); 387 return {_VSTD::move(__out_it), __s}; 388} 389#endif 390 391template <class... _Args> 392_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT size_t 393formatted_size(string_view __fmt, const _Args&... __args) { 394 // TODO FMT Improve PoC: using std::string is inefficient. 395 return _VSTD::vformat(__fmt, _VSTD::make_format_args(__args...)).size(); 396} 397 398#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 399template <class... _Args> 400_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT size_t 401formatted_size(wstring_view __fmt, const _Args&... __args) { 402 // TODO FMT Improve PoC: using std::string is inefficient. 403 return _VSTD::vformat(__fmt, _VSTD::make_wformat_args(__args...)).size(); 404} 405#endif 406 407#ifndef _LIBCPP_HAS_NO_LOCALIZATION 408 409template <class _OutIt, class _CharT, class _FormatOutIt> 410requires(output_iterator<_OutIt, const _CharT&>) _LIBCPP_HIDE_FROM_ABI _OutIt 411 __vformat_to( 412 _OutIt __out_it, locale __loc, basic_string_view<_CharT> __fmt, 413 basic_format_args<basic_format_context<_FormatOutIt, _CharT>> __args) { 414 if constexpr (same_as<_OutIt, _FormatOutIt>) 415 return _VSTD::__format::__vformat_to( 416 basic_format_parse_context{__fmt, __args.__size()}, 417 _VSTD::__format_context_create(_VSTD::move(__out_it), __args, 418 _VSTD::move(__loc))); 419 else { 420 basic_string<_CharT> __str; 421 _VSTD::__format::__vformat_to( 422 basic_format_parse_context{__fmt, __args.__size()}, 423 _VSTD::__format_context_create(_VSTD::back_inserter(__str), __args, 424 _VSTD::move(__loc))); 425 return _VSTD::copy_n(__str.begin(), __str.size(), _VSTD::move(__out_it)); 426 } 427} 428 429template <output_iterator<const char&> _OutIt> 430_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt vformat_to( 431 _OutIt __out_it, locale __loc, string_view __fmt, format_args __args) { 432 return _VSTD::__vformat_to(_VSTD::move(__out_it), _VSTD::move(__loc), __fmt, 433 __args); 434} 435 436#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 437template <output_iterator<const wchar_t&> _OutIt> 438_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt vformat_to( 439 _OutIt __out_it, locale __loc, wstring_view __fmt, wformat_args __args) { 440 return _VSTD::__vformat_to(_VSTD::move(__out_it), _VSTD::move(__loc), __fmt, 441 __args); 442} 443#endif 444 445template <output_iterator<const char&> _OutIt, class... _Args> 446_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt format_to( 447 _OutIt __out_it, locale __loc, string_view __fmt, const _Args&... __args) { 448 return _VSTD::vformat_to(_VSTD::move(__out_it), _VSTD::move(__loc), __fmt, 449 _VSTD::make_format_args(__args...)); 450} 451 452#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 453template <output_iterator<const wchar_t&> _OutIt, class... _Args> 454_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT _OutIt format_to( 455 _OutIt __out_it, locale __loc, wstring_view __fmt, const _Args&... __args) { 456 return _VSTD::vformat_to(_VSTD::move(__out_it), _VSTD::move(__loc), __fmt, 457 _VSTD::make_wformat_args(__args...)); 458} 459#endif 460 461_LIBCPP_ALWAYS_INLINE inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT string 462vformat(locale __loc, string_view __fmt, format_args __args) { 463 string __res; 464 _VSTD::vformat_to(_VSTD::back_inserter(__res), _VSTD::move(__loc), __fmt, 465 __args); 466 return __res; 467} 468 469#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 470_LIBCPP_ALWAYS_INLINE inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT wstring 471vformat(locale __loc, wstring_view __fmt, wformat_args __args) { 472 wstring __res; 473 _VSTD::vformat_to(_VSTD::back_inserter(__res), _VSTD::move(__loc), __fmt, 474 __args); 475 return __res; 476} 477#endif 478 479template <class... _Args> 480_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT string 481format(locale __loc, string_view __fmt, const _Args&... __args) { 482 return _VSTD::vformat(_VSTD::move(__loc), __fmt, 483 _VSTD::make_format_args(__args...)); 484} 485 486#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 487template <class... _Args> 488_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT wstring 489format(locale __loc, wstring_view __fmt, const _Args&... __args) { 490 return _VSTD::vformat(_VSTD::move(__loc), __fmt, 491 _VSTD::make_wformat_args(__args...)); 492} 493#endif 494 495template <output_iterator<const char&> _OutIt, class... _Args> 496_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT format_to_n_result<_OutIt> 497format_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n, locale __loc, 498 string_view __fmt, const _Args&... __args) { 499 // TODO FMT Improve PoC: using std::string is inefficient. 500 string __str = _VSTD::vformat(_VSTD::move(__loc), __fmt, 501 _VSTD::make_format_args(__args...)); 502 iter_difference_t<_OutIt> __s = __str.size(); 503 iter_difference_t<_OutIt> __m = 504 _VSTD::clamp(__n, iter_difference_t<_OutIt>(0), __s); 505 __out_it = _VSTD::copy_n(__str.begin(), __m, _VSTD::move(__out_it)); 506 return {_VSTD::move(__out_it), __s}; 507} 508 509#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 510template <output_iterator<const wchar_t&> _OutIt, class... _Args> 511_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT format_to_n_result<_OutIt> 512format_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n, locale __loc, 513 wstring_view __fmt, const _Args&... __args) { 514 // TODO FMT Improve PoC: using std::string is inefficient. 515 wstring __str = _VSTD::vformat(_VSTD::move(__loc), __fmt, 516 _VSTD::make_wformat_args(__args...)); 517 iter_difference_t<_OutIt> __s = __str.size(); 518 iter_difference_t<_OutIt> __m = 519 _VSTD::clamp(__n, iter_difference_t<_OutIt>(0), __s); 520 __out_it = _VSTD::copy_n(__str.begin(), __m, _VSTD::move(__out_it)); 521 return {_VSTD::move(__out_it), __s}; 522} 523#endif 524 525template <class... _Args> 526_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT size_t 527formatted_size(locale __loc, string_view __fmt, const _Args&... __args) { 528 // TODO FMT Improve PoC: using std::string is inefficient. 529 return _VSTD::vformat(_VSTD::move(__loc), __fmt, 530 _VSTD::make_format_args(__args...)) 531 .size(); 532} 533 534#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 535template <class... _Args> 536_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT size_t 537formatted_size(locale __loc, wstring_view __fmt, const _Args&... __args) { 538 // TODO FMT Improve PoC: using std::string is inefficient. 539 return _VSTD::vformat(_VSTD::move(__loc), __fmt, 540 _VSTD::make_wformat_args(__args...)) 541 .size(); 542} 543#endif 544 545#endif // _LIBCPP_HAS_NO_LOCALIZATION 546 547#endif //_LIBCPP_STD_VER > 17 548 549_LIBCPP_END_NAMESPACE_STD 550 551#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT) 552 553#endif // _LIBCPP_FORMAT 554