libcxx/include/iomanip

   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_IOMANIP
  11 #define _LIBCPP_IOMANIP
  12
  13 /*
  14     iomanip synopsis
  15
  16 namespace std {
  17
  18 // types T1, T2, ... are unspecified implementation types
  19 T1 resetiosflags(ios_base::fmtflags mask);
  20 T2 setiosflags (ios_base::fmtflags mask);
  21 T3 setbase(int base);
  22 template<charT> T4 setfill(charT c);
  23 T5 setprecision(int n);
  24 T6 setw(int n);
  25 template <class moneyT> T7 get_money(moneyT& mon, bool intl = false);
  26 template <class charT, class moneyT> T8 put_money(const moneyT& mon, bool intl = false);
  27 template <class charT> T9 get_time(struct tm* tmb, const charT* fmt);
  28 template <class charT> T10 put_time(const struct tm* tmb, const charT* fmt);
  29
  30 template <class charT>
  31   T11 quoted(const charT* s, charT delim=charT('"'), charT escape=charT('\\')); // C++14
  32
  33 template <class charT, class traits, class Allocator>
  34   T12 quoted(const basic_string<charT, traits, Allocator>& s,
  35              charT delim=charT('"'), charT escape=charT('\\')); // C++14
  36
  37 template <class charT, class traits, class Allocator>
  38   T13 quoted(basic_string<charT, traits, Allocator>& s,
  39              charT delim=charT('"'), charT escape=charT('\\')); // C++14
  40
  41 }  // std
  42
  43 */
  44
  45 #include <__assert> // all public C++ headers provide the assertion handler
  46 #include <__config>
  47 #include <istream>
  48 #include <version>
  49
  50 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
  51 #  pragma GCC system_header
  52 #endif
  53
  54 _LIBCPP_BEGIN_NAMESPACE_STD
  55
  56 // resetiosflags
  57
  58 class __iom_t1
  59 {
  60     ios_base::fmtflags __mask_;
  61 public:
  62     _LIBCPP_INLINE_VISIBILITY
  63     explicit __iom_t1(ios_base::fmtflags __m) : __mask_(__m) {}
  64
  65     template <class _CharT, class _Traits>
  66     friend
  67     _LIBCPP_INLINE_VISIBILITY
  68     basic_istream<_CharT, _Traits>&
  69     operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t1& __x)
  70     {
  71         __is.unsetf(__x.__mask_);
  72         return __is;
  73     }
  74
  75     template <class _CharT, class _Traits>
  76     friend
  77     _LIBCPP_INLINE_VISIBILITY
  78     basic_ostream<_CharT, _Traits>&
  79     operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t1& __x)
  80     {
  81         __os.unsetf(__x.__mask_);
  82         return __os;
  83     }
  84 };
  85
  86 inline _LIBCPP_INLINE_VISIBILITY
  87 __iom_t1
  88 resetiosflags(ios_base::fmtflags __mask)
  89 {
  90     return __iom_t1(__mask);
  91 }
  92
  93 // setiosflags
  94
  95 class __iom_t2
  96 {
  97     ios_base::fmtflags __mask_;
  98 public:
  99     _LIBCPP_INLINE_VISIBILITY
 100     explicit __iom_t2(ios_base::fmtflags __m) : __mask_(__m) {}
 101
 102     template <class _CharT, class _Traits>
 103     friend
 104     _LIBCPP_INLINE_VISIBILITY
 105     basic_istream<_CharT, _Traits>&
 106     operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t2& __x)
 107     {
 108         __is.setf(__x.__mask_);
 109         return __is;
 110     }
 111
 112     template <class _CharT, class _Traits>
 113     friend
 114     _LIBCPP_INLINE_VISIBILITY
 115     basic_ostream<_CharT, _Traits>&
 116     operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t2& __x)
 117     {
 118         __os.setf(__x.__mask_);
 119         return __os;
 120     }
 121 };
 122
 123 inline _LIBCPP_INLINE_VISIBILITY
 124 __iom_t2
 125 setiosflags(ios_base::fmtflags __mask)
 126 {
 127     return __iom_t2(__mask);
 128 }
 129
 130 // setbase
 131
 132 class __iom_t3
 133 {
 134     int __base_;
 135 public:
 136     _LIBCPP_INLINE_VISIBILITY
 137     explicit __iom_t3(int __b) : __base_(__b) {}
 138
 139     template <class _CharT, class _Traits>
 140     friend
 141     _LIBCPP_INLINE_VISIBILITY
 142     basic_istream<_CharT, _Traits>&
 143     operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t3& __x)
 144     {
 145         __is.setf(__x.__base_ == 8  ? ios_base::oct :
 146                   __x.__base_ == 10 ? ios_base::dec :
 147                   __x.__base_ == 16 ? ios_base::hex :
 148                   ios_base::fmtflags(0), ios_base::basefield);
 149         return __is;
 150     }
 151
 152     template <class _CharT, class _Traits>
 153     friend
 154     _LIBCPP_INLINE_VISIBILITY
 155     basic_ostream<_CharT, _Traits>&
 156     operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t3& __x)
 157     {
 158         __os.setf(__x.__base_ == 8  ? ios_base::oct :
 159                   __x.__base_ == 10 ? ios_base::dec :
 160                   __x.__base_ == 16 ? ios_base::hex :
 161                   ios_base::fmtflags(0), ios_base::basefield);
 162         return __os;
 163     }
 164 };
 165
 166 inline _LIBCPP_INLINE_VISIBILITY
 167 __iom_t3
 168 setbase(int __base)
 169 {
 170     return __iom_t3(__base);
 171 }
 172
 173 // setfill
 174
 175 template<class _CharT>
 176 class __iom_t4
 177 {
 178     _CharT __fill_;
 179 public:
 180     _LIBCPP_INLINE_VISIBILITY
 181     explicit __iom_t4(_CharT __c) : __fill_(__c) {}
 182
 183     template <class _Traits>
 184     friend
 185     _LIBCPP_INLINE_VISIBILITY
 186     basic_ostream<_CharT, _Traits>&
 187     operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t4& __x)
 188     {
 189         __os.fill(__x.__fill_);
 190         return __os;
 191     }
 192 };
 193
 194 template<class _CharT>
 195 inline _LIBCPP_INLINE_VISIBILITY
 196 __iom_t4<_CharT>
 197 setfill(_CharT __c)
 198 {
 199     return __iom_t4<_CharT>(__c);
 200 }
 201
 202 // setprecision
 203
 204 class __iom_t5
 205 {
 206     int __n_;
 207 public:
 208     _LIBCPP_INLINE_VISIBILITY
 209     explicit __iom_t5(int __n) : __n_(__n) {}
 210
 211     template <class _CharT, class _Traits>
 212     friend
 213     _LIBCPP_INLINE_VISIBILITY
 214     basic_istream<_CharT, _Traits>&
 215     operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t5& __x)
 216     {
 217         __is.precision(__x.__n_);
 218         return __is;
 219     }
 220
 221     template <class _CharT, class _Traits>
 222     friend
 223     _LIBCPP_INLINE_VISIBILITY
 224     basic_ostream<_CharT, _Traits>&
 225     operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t5& __x)
 226     {
 227         __os.precision(__x.__n_);
 228         return __os;
 229     }
 230 };
 231
 232 inline _LIBCPP_INLINE_VISIBILITY
 233 __iom_t5
 234 setprecision(int __n)
 235 {
 236     return __iom_t5(__n);
 237 }
 238
 239 // setw
 240
 241 class __iom_t6
 242 {
 243     int __n_;
 244 public:
 245     _LIBCPP_INLINE_VISIBILITY
 246     explicit __iom_t6(int __n) : __n_(__n) {}
 247
 248     template <class _CharT, class _Traits>
 249     friend
 250     _LIBCPP_INLINE_VISIBILITY
 251     basic_istream<_CharT, _Traits>&
 252     operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t6& __x)
 253     {
 254         __is.width(__x.__n_);
 255         return __is;
 256     }
 257
 258     template <class _CharT, class _Traits>
 259     friend
 260     _LIBCPP_INLINE_VISIBILITY
 261     basic_ostream<_CharT, _Traits>&
 262     operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t6& __x)
 263     {
 264         __os.width(__x.__n_);
 265         return __os;
 266     }
 267 };
 268
 269 inline _LIBCPP_INLINE_VISIBILITY
 270 __iom_t6
 271 setw(int __n)
 272 {
 273     return __iom_t6(__n);
 274 }
 275
 276 // get_money
 277
 278 template <class _MoneyT> class __iom_t7;
 279
 280 template <class _CharT, class _Traits, class _MoneyT>
 281 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
 282 operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t7<_MoneyT>& __x);
 283
 284 template <class _MoneyT>
 285 class __iom_t7
 286 {
 287     _MoneyT& __mon_;
 288     bool __intl_;
 289 public:
 290     _LIBCPP_INLINE_VISIBILITY
 291     __iom_t7(_MoneyT& __mon, bool __intl)
 292         : __mon_(__mon), __intl_(__intl) {}
 293
 294     template <class _CharT, class _Traits, class _Mp>
 295     friend
 296     basic_istream<_CharT, _Traits>&
 297     operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t7<_Mp>& __x);
 298 };
 299
 300 template <class _CharT, class _Traits, class _MoneyT>
 301 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
 302 operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t7<_MoneyT>& __x)
 303 {
 304 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
 305     try
 306     {
 307 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
 308         typename basic_istream<_CharT, _Traits>::sentry __s(__is);
 309         if (__s)
 310         {
 311             typedef istreambuf_iterator<_CharT, _Traits> _Ip;
 312             typedef money_get<_CharT, _Ip> _Fp;
 313             ios_base::iostate __err = ios_base::goodbit;
 314             const _Fp& __mf = std::use_facet<_Fp>(__is.getloc());
 315             __mf.get(_Ip(__is), _Ip(), __x.__intl_, __is, __err, __x.__mon_);
 316             __is.setstate(__err);
 317         }
 318 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
 319     }
 320     catch (...)
 321     {
 322         __is.__set_badbit_and_consider_rethrow();
 323     }
 324 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
 325     return __is;
 326 }
 327
 328 template <class _MoneyT>
 329 inline _LIBCPP_INLINE_VISIBILITY
 330 __iom_t7<_MoneyT>
 331 get_money(_MoneyT& __mon, bool __intl = false)
 332 {
 333     return __iom_t7<_MoneyT>(__mon, __intl);
 334 }
 335
 336 // put_money
 337
 338 template <class _MoneyT> class __iom_t8;
 339
 340 template <class _CharT, class _Traits, class _MoneyT>
 341 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
 342 operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t8<_MoneyT>& __x);
 343
 344 template <class _MoneyT>
 345 class __iom_t8
 346 {
 347     const _MoneyT& __mon_;
 348     bool __intl_;
 349 public:
 350     _LIBCPP_INLINE_VISIBILITY
 351     __iom_t8(const _MoneyT& __mon, bool __intl)
 352         : __mon_(__mon), __intl_(__intl) {}
 353
 354     template <class _CharT, class _Traits, class _Mp>
 355     friend
 356     basic_ostream<_CharT, _Traits>&
 357     operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t8<_Mp>& __x);
 358 };
 359
 360 template <class _CharT, class _Traits, class _MoneyT>
 361 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
 362 operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t8<_MoneyT>& __x)
 363 {
 364 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
 365     try
 366     {
 367 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
 368         typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
 369         if (__s)
 370         {
 371             typedef ostreambuf_iterator<_CharT, _Traits> _Op;
 372             typedef money_put<_CharT, _Op> _Fp;
 373             const _Fp& __mf = std::use_facet<_Fp>(__os.getloc());
 374             if (__mf.put(_Op(__os), __x.__intl_, __os, __os.fill(), __x.__mon_).failed())
 375                 __os.setstate(ios_base::badbit);
 376         }
 377 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
 378     }
 379     catch (...)
 380     {
 381         __os.__set_badbit_and_consider_rethrow();
 382     }
 383 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
 384     return __os;
 385 }
 386
 387 template <class _MoneyT>
 388 inline _LIBCPP_INLINE_VISIBILITY
 389 __iom_t8<_MoneyT>
 390 put_money(const _MoneyT& __mon, bool __intl = false)
 391 {
 392     return __iom_t8<_MoneyT>(__mon, __intl);
 393 }
 394
 395 // get_time
 396
 397 template <class _CharT> class __iom_t9;
 398
 399 template <class _CharT, class _Traits>
 400 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
 401 operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t9<_CharT>& __x);
 402
 403 template <class _CharT>
 404 class __iom_t9
 405 {
 406     tm* __tm_;
 407     const _CharT* __fmt_;
 408 public:
 409     _LIBCPP_INLINE_VISIBILITY
 410     __iom_t9(tm* __tm, const _CharT* __fmt)
 411         : __tm_(__tm), __fmt_(__fmt) {}
 412
 413     template <class _Cp, class _Traits>
 414     friend
 415     basic_istream<_Cp, _Traits>&
 416     operator>>(basic_istream<_Cp, _Traits>& __is, const __iom_t9<_Cp>& __x);
 417 };
 418
 419 template <class _CharT, class _Traits>
 420 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
 421 operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t9<_CharT>& __x)
 422 {
 423 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
 424     try
 425     {
 426 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
 427         typename basic_istream<_CharT, _Traits>::sentry __s(__is);
 428         if (__s)
 429         {
 430             typedef istreambuf_iterator<_CharT, _Traits> _Ip;
 431             typedef time_get<_CharT, _Ip> _Fp;
 432             ios_base::iostate __err = ios_base::goodbit;
 433             const _Fp& __tf = std::use_facet<_Fp>(__is.getloc());
 434             __tf.get(_Ip(__is), _Ip(), __is, __err, __x.__tm_,
 435                      __x.__fmt_, __x.__fmt_ + _Traits::length(__x.__fmt_));
 436             __is.setstate(__err);
 437         }
 438 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
 439     }
 440     catch (...)
 441     {
 442         __is.__set_badbit_and_consider_rethrow();
 443     }
 444 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
 445     return __is;
 446 }
 447
 448 template <class _CharT>
 449 inline _LIBCPP_INLINE_VISIBILITY
 450 __iom_t9<_CharT>
 451 get_time(tm* __tm, const _CharT* __fmt)
 452 {
 453     return __iom_t9<_CharT>(__tm, __fmt);
 454 }
 455
 456 // put_time
 457
 458 template <class _CharT> class __iom_t10;
 459
 460 template <class _CharT, class _Traits>
 461 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
 462 operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t10<_CharT>& __x);
 463
 464 template <class _CharT>
 465 class __iom_t10
 466 {
 467     const tm* __tm_;
 468     const _CharT* __fmt_;
 469 public:
 470     _LIBCPP_INLINE_VISIBILITY
 471     __iom_t10(const tm* __tm, const _CharT* __fmt)
 472         : __tm_(__tm), __fmt_(__fmt) {}
 473
 474     template <class _Cp, class _Traits>
 475     friend
 476     basic_ostream<_Cp, _Traits>&
 477     operator<<(basic_ostream<_Cp, _Traits>& __os, const __iom_t10<_Cp>& __x);
 478 };
 479
 480 template <class _CharT, class _Traits>
 481 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
 482 operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t10<_CharT>& __x)
 483 {
 484 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
 485     try
 486     {
 487 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
 488         typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
 489         if (__s)
 490         {
 491             typedef ostreambuf_iterator<_CharT, _Traits> _Op;
 492             typedef time_put<_CharT, _Op> _Fp;
 493             const _Fp& __tf = std::use_facet<_Fp>(__os.getloc());
 494             if (__tf.put(_Op(__os), __os, __os.fill(), __x.__tm_,
 495                          __x.__fmt_, __x.__fmt_ + _Traits::length(__x.__fmt_)).failed())
 496                 __os.setstate(ios_base::badbit);
 497         }
 498 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
 499     }
 500     catch (...)
 501     {
 502         __os.__set_badbit_and_consider_rethrow();
 503     }
 504 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
 505     return __os;
 506 }
 507
 508 template <class _CharT>
 509 inline _LIBCPP_INLINE_VISIBILITY
 510 __iom_t10<_CharT>
 511 put_time(const tm* __tm, const _CharT* __fmt)
 512 {
 513     return __iom_t10<_CharT>(__tm, __fmt);
 514 }
 515
 516 template <class _CharT, class _Traits>
 517 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
 518 __quoted_output(basic_ostream<_CharT, _Traits>& __os,
 519                 const _CharT *__first, const _CharT *__last, _CharT __delim, _CharT __escape)
 520 {
 521     basic_string<_CharT, _Traits> __str;
 522     __str.push_back(__delim);
 523     for (; __first != __last; ++__first) {
 524         if (_Traits::eq(*__first, __escape) || _Traits::eq(*__first, __delim))
 525             __str.push_back(__escape);
 526         __str.push_back(*__first);
 527     }
 528     __str.push_back(__delim);
 529     return _VSTD::__put_character_sequence(__os, __str.data(), __str.size());
 530 }
 531
 532 template <class _CharT, class _Traits, class _String>
 533 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
 534 __quoted_input(basic_istream<_CharT, _Traits>& __is, _String& __string, _CharT __delim, _CharT __escape)
 535 {
 536     __string.clear();
 537     _CharT __c;
 538     __is >> __c;
 539     if (__is.fail())
 540         return __is;
 541
 542     if (!_Traits::eq(__c, __delim)) {
 543         // no delimiter, read the whole string
 544         __is.unget();
 545         __is >> __string;
 546         return __is;
 547     }
 548
 549     __save_flags<_CharT, _Traits> __sf(__is);
 550     std::noskipws(__is);
 551     while (true) {
 552         __is >> __c;
 553         if (__is.fail())
 554             break;
 555         if (_Traits::eq(__c, __escape)) {
 556             __is >> __c;
 557             if (__is.fail())
 558                 break;
 559         } else if (_Traits::eq(__c, __delim))
 560             break;
 561         __string.push_back(__c);
 562     }
 563     return __is;
 564 }
 565
 566 template <class _CharT, class _Traits>
 567 struct _LIBCPP_HIDDEN __quoted_output_proxy
 568 {
 569     const _CharT *__first_;
 570     const _CharT *__last_;
 571     _CharT __delim_;
 572     _CharT __escape_;
 573
 574     _LIBCPP_HIDE_FROM_ABI
 575     explicit __quoted_output_proxy(const _CharT *__f, const _CharT *__l, _CharT __d, _CharT __e)
 576         : __first_(__f), __last_(__l), __delim_(__d), __escape_(__e) {}
 577
 578     template<class _T2, __enable_if_t<_IsSame<_Traits, void>::value || _IsSame<_Traits, _T2>::value>* = nullptr>
 579     friend _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _T2>&
 580     operator<<(basic_ostream<_CharT, _T2>& __os, const __quoted_output_proxy& __p) {
 581         return std::__quoted_output(__os, __p.__first_, __p.__last_, __p.__delim_, __p.__escape_);
 582     }
 583 };
 584
 585 template <class _CharT, class _Traits, class _Allocator>
 586 struct _LIBCPP_HIDDEN __quoted_proxy
 587 {
 588     basic_string<_CharT, _Traits, _Allocator>& __string_;
 589     _CharT __delim_;
 590     _CharT __escape_;
 591
 592     _LIBCPP_HIDE_FROM_ABI
 593     explicit __quoted_proxy(basic_string<_CharT, _Traits, _Allocator>& __s, _CharT __d, _CharT __e)
 594         : __string_(__s), __delim_(__d), __escape_(__e) {}
 595
 596     friend _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
 597     operator<<(basic_ostream<_CharT, _Traits>& __os, const __quoted_proxy& __p) {
 598         return std::__quoted_output(__os, __p.__string_.data(), __p.__string_.data() + __p.__string_.size(), __p.__delim_, __p.__escape_);
 599     }
 600
 601     friend _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
 602     operator>>(basic_istream<_CharT, _Traits>& __is, const __quoted_proxy& __p) {
 603         return std::__quoted_input(__is, __p.__string_, __p.__delim_, __p.__escape_);
 604     }
 605 };
 606
 607 template <class _CharT, class _Traits, class _Allocator>
 608 _LIBCPP_HIDE_FROM_ABI
 609 __quoted_output_proxy<_CharT, _Traits>
 610 __quoted(const basic_string<_CharT, _Traits, _Allocator>& __s, _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\'))
 611 {
 612     return __quoted_output_proxy<_CharT, _Traits>(__s.data(), __s.data() + __s.size(), __delim, __escape);
 613 }
 614
 615 template <class _CharT, class _Traits, class _Allocator>
 616 _LIBCPP_HIDE_FROM_ABI
 617 __quoted_proxy<_CharT, _Traits, _Allocator>
 618 __quoted(basic_string<_CharT, _Traits, _Allocator>& __s, _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\'))
 619 {
 620     return __quoted_proxy<_CharT, _Traits, _Allocator>(__s, __delim, __escape);
 621 }
 622
 623 #if _LIBCPP_STD_VER >= 14
 624
 625 template <class _CharT>
 626 _LIBCPP_HIDE_FROM_ABI
 627 auto quoted(const _CharT *__s, _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\'))
 628 {
 629     const _CharT *__end = __s;
 630     while (*__end) ++__end;
 631     return __quoted_output_proxy<_CharT, void>(__s, __end, __delim, __escape);
 632 }
 633
 634 template <class _CharT, class _Traits, class _Allocator>
 635 _LIBCPP_HIDE_FROM_ABI
 636 auto quoted(const basic_string<_CharT, _Traits, _Allocator>& __s, _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\'))
 637 {
 638     return __quoted_output_proxy<_CharT, _Traits>(__s.data(), __s.data() + __s.size(), __delim, __escape);
 639 }
 640
 641 template <class _CharT, class _Traits, class _Allocator>
 642 _LIBCPP_HIDE_FROM_ABI
 643 auto quoted(basic_string<_CharT, _Traits, _Allocator>& __s, _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\'))
 644 {
 645     return __quoted_proxy<_CharT, _Traits, _Allocator>(__s, __delim, __escape);
 646 }
 647
 648 template <class _CharT, class _Traits>
 649 _LIBCPP_HIDE_FROM_ABI
 650 auto quoted(basic_string_view<_CharT, _Traits> __sv, _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\'))
 651 {
 652     return __quoted_output_proxy<_CharT, _Traits>(__sv.data(), __sv.data() + __sv.size(), __delim, __escape);
 653 }
 654
 655 #endif // _LIBCPP_STD_VER >= 14
 656
 657 _LIBCPP_END_NAMESPACE_STD
 658
 659 #endif // _LIBCPP_IOMANIP