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_OSTREAM 11#define _LIBCPP_OSTREAM 12 13/* 14 ostream synopsis 15 16template <class charT, class traits = char_traits<charT> > 17class basic_ostream 18 : virtual public basic_ios<charT,traits> 19{ 20public: 21 // types (inherited from basic_ios (27.5.4)): 22 typedef charT char_type; 23 typedef traits traits_type; 24 typedef typename traits_type::int_type int_type; 25 typedef typename traits_type::pos_type pos_type; 26 typedef typename traits_type::off_type off_type; 27 28 // 27.7.2.2 Constructor/destructor: 29 explicit basic_ostream(basic_streambuf<char_type,traits>* sb); 30 basic_ostream(basic_ostream&& rhs); 31 virtual ~basic_ostream(); 32 33 // 27.7.2.3 Assign/swap 34 basic_ostream& operator=(const basic_ostream& rhs) = delete; // C++14 35 basic_ostream& operator=(basic_ostream&& rhs); 36 void swap(basic_ostream& rhs); 37 38 // 27.7.2.4 Prefix/suffix: 39 class sentry; 40 41 // 27.7.2.6 Formatted output: 42 basic_ostream& operator<<(basic_ostream& (*pf)(basic_ostream&)); 43 basic_ostream& operator<<(basic_ios<charT, traits>& (*pf)(basic_ios<charT,traits>&)); 44 basic_ostream& operator<<(ios_base& (*pf)(ios_base&)); 45 basic_ostream& operator<<(bool n); 46 basic_ostream& operator<<(short n); 47 basic_ostream& operator<<(unsigned short n); 48 basic_ostream& operator<<(int n); 49 basic_ostream& operator<<(unsigned int n); 50 basic_ostream& operator<<(long n); 51 basic_ostream& operator<<(unsigned long n); 52 basic_ostream& operator<<(long long n); 53 basic_ostream& operator<<(unsigned long long n); 54 basic_ostream& operator<<(float f); 55 basic_ostream& operator<<(double f); 56 basic_ostream& operator<<(long double f); 57 basic_ostream& operator<<(const void* p); 58 basic_ostream& operator<<(const volatile void* val); // C++23 59 basic_ostream& operator<<(basic_streambuf<char_type,traits>* sb); 60 basic_ostream& operator<<(nullptr_t); 61 62 // 27.7.2.7 Unformatted output: 63 basic_ostream& put(char_type c); 64 basic_ostream& write(const char_type* s, streamsize n); 65 basic_ostream& flush(); 66 67 // 27.7.2.5 seeks: 68 pos_type tellp(); 69 basic_ostream& seekp(pos_type); 70 basic_ostream& seekp(off_type, ios_base::seekdir); 71protected: 72 basic_ostream(const basic_ostream& rhs) = delete; 73 basic_ostream(basic_ostream&& rhs); 74 // 27.7.3.3 Assign/swap 75 basic_ostream& operator=(basic_ostream& rhs) = delete; 76 basic_ostream& operator=(const basic_ostream&& rhs); 77 void swap(basic_ostream& rhs); 78}; 79 80// 27.7.2.6.4 character inserters 81 82template<class charT, class traits> 83 basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&, charT); 84 85template<class charT, class traits> 86 basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&, char); 87 88template<class traits> 89 basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, char); 90 91// signed and unsigned 92 93template<class traits> 94 basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, signed char); 95 96template<class traits> 97 basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, unsigned char); 98 99// NTBS 100template<class charT, class traits> 101 basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&, const charT*); 102 103template<class charT, class traits> 104 basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&, const char*); 105 106template<class traits> 107 basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, const char*); 108 109// signed and unsigned 110template<class traits> 111basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, const signed char*); 112 113template<class traits> 114 basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, const unsigned char*); 115 116// swap: 117template <class charT, class traits> 118 void swap(basic_ostream<charT, traits>& x, basic_ostream<charT, traits>& y); 119 120template <class charT, class traits> 121 basic_ostream<charT,traits>& endl(basic_ostream<charT,traits>& os); 122 123template <class charT, class traits> 124 basic_ostream<charT,traits>& ends(basic_ostream<charT,traits>& os); 125 126template <class charT, class traits> 127 basic_ostream<charT,traits>& flush(basic_ostream<charT,traits>& os); 128 129// rvalue stream insertion 130template <class Stream, class T> 131 Stream&& operator<<(Stream&& os, const T& x); 132 133template<class traits> 134basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, wchar_t) = delete; // since C++20 135template<class traits> 136basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, char8_t) = delete; // since C++20 137template<class traits> 138basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, char16_t) = delete; // since C++20 139template<class traits> 140basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, char32_t) = delete; // since C++20 141template<class traits> 142basic_ostream<wchar_t, traits>& operator<<(basic_ostream<wchar_t, traits>&, char8_t) = delete; // since C++20 143template<class traits> 144basic_ostream<wchar_t, traits>& operator<<(basic_ostream<wchar_t, traits>&, char16_t) = delete; // since C++20 145template<class traits> 146basic_ostream<wchar_t, traits>& operator<<(basic_ostream<wchar_t, traits>&, char32_t) = delete; // since C++20 147template<class traits> 148basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, const wchar_t*) = delete; // since C++20 149template<class traits> 150basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, const char8_t*) = delete; // since C++20 151template<class traits> 152basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, const char16_t*) = delete; // since C++20 153template<class traits> 154basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, const char32_t*) = delete; // since C++20 155template<class traits> 156basic_ostream<wchar_t, traits>& operator<<(basic_ostream<wchar_t, traits>&, const char8_t*) = delete; // since C++20 157template<class traits> 158basic_ostream<wchar_t, traits>& operator<<(basic_ostream<wchar_t, traits>&, const char16_t*) = delete; // since C++20 159template<class traits> 160basic_ostream<wchar_t, traits>& operator<<(basic_ostream<wchar_t, traits>&, const char32_t*) = delete; // since C++20 161 162} // std 163 164*/ 165 166#include <__assert> // all public C++ headers provide the assertion handler 167#include <__config> 168#include <__memory/shared_ptr.h> 169#include <__memory/unique_ptr.h> 170#include <bitset> 171#include <ios> 172#include <locale> 173#include <new> 174#include <streambuf> 175#include <version> 176 177#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 178# pragma GCC system_header 179#endif 180 181_LIBCPP_BEGIN_NAMESPACE_STD 182 183template <class _CharT, class _Traits> 184class _LIBCPP_TEMPLATE_VIS basic_ostream 185 : virtual public basic_ios<_CharT, _Traits> 186{ 187public: 188 // types (inherited from basic_ios (27.5.4)): 189 typedef _CharT char_type; 190 typedef _Traits traits_type; 191 typedef typename traits_type::int_type int_type; 192 typedef typename traits_type::pos_type pos_type; 193 typedef typename traits_type::off_type off_type; 194 195 // 27.7.2.2 Constructor/destructor: 196 inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 197 explicit basic_ostream(basic_streambuf<char_type, traits_type>* __sb) 198 { this->init(__sb); } 199 ~basic_ostream() override; 200protected: 201 inline _LIBCPP_INLINE_VISIBILITY 202 basic_ostream(basic_ostream&& __rhs); 203 204 // 27.7.2.3 Assign/swap 205 inline _LIBCPP_INLINE_VISIBILITY 206 basic_ostream& operator=(basic_ostream&& __rhs); 207 208 inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 209 void swap(basic_ostream& __rhs) 210 { basic_ios<char_type, traits_type>::swap(__rhs); } 211 212 basic_ostream (const basic_ostream& __rhs) = delete; 213 basic_ostream& operator=(const basic_ostream& __rhs) = delete; 214 215public: 216 // 27.7.2.4 Prefix/suffix: 217 class _LIBCPP_TEMPLATE_VIS sentry; 218 219 // 27.7.2.6 Formatted output: 220 inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 221 basic_ostream& operator<<(basic_ostream& (*__pf)(basic_ostream&)) 222 { return __pf(*this); } 223 224 inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 225 basic_ostream& operator<<(basic_ios<char_type, traits_type>& 226 (*__pf)(basic_ios<char_type,traits_type>&)) 227 { __pf(*this); return *this; } 228 229 inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 230 basic_ostream& operator<<(ios_base& (*__pf)(ios_base&)) 231 { __pf(*this); return *this; } 232 233 basic_ostream& operator<<(bool __n); 234 basic_ostream& operator<<(short __n); 235 basic_ostream& operator<<(unsigned short __n); 236 basic_ostream& operator<<(int __n); 237 basic_ostream& operator<<(unsigned int __n); 238 basic_ostream& operator<<(long __n); 239 basic_ostream& operator<<(unsigned long __n); 240 basic_ostream& operator<<(long long __n); 241 basic_ostream& operator<<(unsigned long long __n); 242 basic_ostream& operator<<(float __f); 243 basic_ostream& operator<<(double __f); 244 basic_ostream& operator<<(long double __f); 245 basic_ostream& operator<<(const void* __p); 246 247#if _LIBCPP_STD_VER > 20 248 _LIBCPP_HIDE_FROM_ABI 249 basic_ostream& operator<<(const volatile void* __p) { 250 return operator<<(const_cast<const void*>(__p)); 251 } 252#endif 253 254 basic_ostream& operator<<(basic_streambuf<char_type, traits_type>* __sb); 255 256#if _LIBCPP_STD_VER > 14 257// LWG 2221 - nullptr. This is not backported to older standards modes. 258// See https://reviews.llvm.org/D127033 for more info on the rationale. 259 _LIBCPP_INLINE_VISIBILITY 260 basic_ostream& operator<<(nullptr_t) 261 { return *this << "nullptr"; } 262#endif 263 264 // 27.7.2.7 Unformatted output: 265 basic_ostream& put(char_type __c); 266 basic_ostream& write(const char_type* __s, streamsize __n); 267 basic_ostream& flush(); 268 269 // 27.7.2.5 seeks: 270 inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 271 pos_type tellp(); 272 inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 273 basic_ostream& seekp(pos_type __pos); 274 inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 275 basic_ostream& seekp(off_type __off, ios_base::seekdir __dir); 276 277protected: 278 _LIBCPP_INLINE_VISIBILITY 279 basic_ostream() {} // extension, intentially does not initialize 280}; 281 282template <class _CharT, class _Traits> 283class _LIBCPP_TEMPLATE_VIS basic_ostream<_CharT, _Traits>::sentry 284{ 285 bool __ok_; 286 basic_ostream<_CharT, _Traits>& __os_; 287 288public: 289 explicit sentry(basic_ostream<_CharT, _Traits>& __os); 290 ~sentry(); 291 sentry(const sentry&) = delete; 292 sentry& operator=(const sentry&) = delete; 293 294 _LIBCPP_INLINE_VISIBILITY 295 explicit operator bool() const {return __ok_;} 296}; 297 298template <class _CharT, class _Traits> 299basic_ostream<_CharT, _Traits>::sentry::sentry(basic_ostream<_CharT, _Traits>& __os) 300 : __ok_(false), 301 __os_(__os) 302{ 303 if (__os.good()) 304 { 305 if (__os.tie()) 306 __os.tie()->flush(); 307 __ok_ = true; 308 } 309} 310 311template <class _CharT, class _Traits> 312basic_ostream<_CharT, _Traits>::sentry::~sentry() 313{ 314 if (__os_.rdbuf() && __os_.good() && (__os_.flags() & ios_base::unitbuf) 315 && !uncaught_exception()) 316 { 317#ifndef _LIBCPP_NO_EXCEPTIONS 318 try 319 { 320#endif // _LIBCPP_NO_EXCEPTIONS 321 if (__os_.rdbuf()->pubsync() == -1) 322 __os_.setstate(ios_base::badbit); 323#ifndef _LIBCPP_NO_EXCEPTIONS 324 } 325 catch (...) 326 { 327 } 328#endif // _LIBCPP_NO_EXCEPTIONS 329 } 330} 331 332template <class _CharT, class _Traits> 333basic_ostream<_CharT, _Traits>::basic_ostream(basic_ostream&& __rhs) 334{ 335 this->move(__rhs); 336} 337 338template <class _CharT, class _Traits> 339basic_ostream<_CharT, _Traits>& 340basic_ostream<_CharT, _Traits>::operator=(basic_ostream&& __rhs) 341{ 342 swap(__rhs); 343 return *this; 344} 345 346template <class _CharT, class _Traits> 347basic_ostream<_CharT, _Traits>::~basic_ostream() 348{ 349} 350 351template <class _CharT, class _Traits> 352basic_ostream<_CharT, _Traits>& 353basic_ostream<_CharT, _Traits>::operator<<(basic_streambuf<char_type, traits_type>* __sb) 354{ 355#ifndef _LIBCPP_NO_EXCEPTIONS 356 try 357 { 358#endif // _LIBCPP_NO_EXCEPTIONS 359 sentry __s(*this); 360 if (__s) 361 { 362 if (__sb) 363 { 364#ifndef _LIBCPP_NO_EXCEPTIONS 365 try 366 { 367#endif // _LIBCPP_NO_EXCEPTIONS 368 typedef istreambuf_iterator<_CharT, _Traits> _Ip; 369 typedef ostreambuf_iterator<_CharT, _Traits> _Op; 370 _Ip __i(__sb); 371 _Ip __eof; 372 _Op __o(*this); 373 size_t __c = 0; 374 for (; __i != __eof; ++__i, ++__o, ++__c) 375 { 376 *__o = *__i; 377 if (__o.failed()) 378 break; 379 } 380 if (__c == 0) 381 this->setstate(ios_base::failbit); 382#ifndef _LIBCPP_NO_EXCEPTIONS 383 } 384 catch (...) 385 { 386 this->__set_failbit_and_consider_rethrow(); 387 } 388#endif // _LIBCPP_NO_EXCEPTIONS 389 } 390 else 391 this->setstate(ios_base::badbit); 392 } 393#ifndef _LIBCPP_NO_EXCEPTIONS 394 } 395 catch (...) 396 { 397 this->__set_badbit_and_consider_rethrow(); 398 } 399#endif // _LIBCPP_NO_EXCEPTIONS 400 return *this; 401} 402 403template <class _CharT, class _Traits> 404basic_ostream<_CharT, _Traits>& 405basic_ostream<_CharT, _Traits>::operator<<(bool __n) 406{ 407#ifndef _LIBCPP_NO_EXCEPTIONS 408 try 409 { 410#endif // _LIBCPP_NO_EXCEPTIONS 411 sentry __s(*this); 412 if (__s) 413 { 414 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; 415 const _Fp& __f = std::use_facet<_Fp>(this->getloc()); 416 if (__f.put(*this, *this, this->fill(), __n).failed()) 417 this->setstate(ios_base::badbit | ios_base::failbit); 418 } 419#ifndef _LIBCPP_NO_EXCEPTIONS 420 } 421 catch (...) 422 { 423 this->__set_badbit_and_consider_rethrow(); 424 } 425#endif // _LIBCPP_NO_EXCEPTIONS 426 return *this; 427} 428 429template <class _CharT, class _Traits> 430basic_ostream<_CharT, _Traits>& 431basic_ostream<_CharT, _Traits>::operator<<(short __n) 432{ 433#ifndef _LIBCPP_NO_EXCEPTIONS 434 try 435 { 436#endif // _LIBCPP_NO_EXCEPTIONS 437 sentry __s(*this); 438 if (__s) 439 { 440 ios_base::fmtflags __flags = ios_base::flags() & ios_base::basefield; 441 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; 442 const _Fp& __f = std::use_facet<_Fp>(this->getloc()); 443 if (__f.put(*this, *this, this->fill(), 444 __flags == ios_base::oct || __flags == ios_base::hex ? 445 static_cast<long>(static_cast<unsigned short>(__n)) : 446 static_cast<long>(__n)).failed()) 447 this->setstate(ios_base::badbit | ios_base::failbit); 448 } 449#ifndef _LIBCPP_NO_EXCEPTIONS 450 } 451 catch (...) 452 { 453 this->__set_badbit_and_consider_rethrow(); 454 } 455#endif // _LIBCPP_NO_EXCEPTIONS 456 return *this; 457} 458 459template <class _CharT, class _Traits> 460basic_ostream<_CharT, _Traits>& 461basic_ostream<_CharT, _Traits>::operator<<(unsigned short __n) 462{ 463#ifndef _LIBCPP_NO_EXCEPTIONS 464 try 465 { 466#endif // _LIBCPP_NO_EXCEPTIONS 467 sentry __s(*this); 468 if (__s) 469 { 470 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; 471 const _Fp& __f = std::use_facet<_Fp>(this->getloc()); 472 if (__f.put(*this, *this, this->fill(), static_cast<unsigned long>(__n)).failed()) 473 this->setstate(ios_base::badbit | ios_base::failbit); 474 } 475#ifndef _LIBCPP_NO_EXCEPTIONS 476 } 477 catch (...) 478 { 479 this->__set_badbit_and_consider_rethrow(); 480 } 481#endif // _LIBCPP_NO_EXCEPTIONS 482 return *this; 483} 484 485template <class _CharT, class _Traits> 486basic_ostream<_CharT, _Traits>& 487basic_ostream<_CharT, _Traits>::operator<<(int __n) 488{ 489#ifndef _LIBCPP_NO_EXCEPTIONS 490 try 491 { 492#endif // _LIBCPP_NO_EXCEPTIONS 493 sentry __s(*this); 494 if (__s) 495 { 496 ios_base::fmtflags __flags = ios_base::flags() & ios_base::basefield; 497 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; 498 const _Fp& __f = std::use_facet<_Fp>(this->getloc()); 499 if (__f.put(*this, *this, this->fill(), 500 __flags == ios_base::oct || __flags == ios_base::hex ? 501 static_cast<long>(static_cast<unsigned int>(__n)) : 502 static_cast<long>(__n)).failed()) 503 this->setstate(ios_base::badbit | ios_base::failbit); 504 } 505#ifndef _LIBCPP_NO_EXCEPTIONS 506 } 507 catch (...) 508 { 509 this->__set_badbit_and_consider_rethrow(); 510 } 511#endif // _LIBCPP_NO_EXCEPTIONS 512 return *this; 513} 514 515template <class _CharT, class _Traits> 516basic_ostream<_CharT, _Traits>& 517basic_ostream<_CharT, _Traits>::operator<<(unsigned int __n) 518{ 519#ifndef _LIBCPP_NO_EXCEPTIONS 520 try 521 { 522#endif // _LIBCPP_NO_EXCEPTIONS 523 sentry __s(*this); 524 if (__s) 525 { 526 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; 527 const _Fp& __f = std::use_facet<_Fp>(this->getloc()); 528 if (__f.put(*this, *this, this->fill(), static_cast<unsigned long>(__n)).failed()) 529 this->setstate(ios_base::badbit | ios_base::failbit); 530 } 531#ifndef _LIBCPP_NO_EXCEPTIONS 532 } 533 catch (...) 534 { 535 this->__set_badbit_and_consider_rethrow(); 536 } 537#endif // _LIBCPP_NO_EXCEPTIONS 538 return *this; 539} 540 541template <class _CharT, class _Traits> 542basic_ostream<_CharT, _Traits>& 543basic_ostream<_CharT, _Traits>::operator<<(long __n) 544{ 545#ifndef _LIBCPP_NO_EXCEPTIONS 546 try 547 { 548#endif // _LIBCPP_NO_EXCEPTIONS 549 sentry __s(*this); 550 if (__s) 551 { 552 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; 553 const _Fp& __f = std::use_facet<_Fp>(this->getloc()); 554 if (__f.put(*this, *this, this->fill(), __n).failed()) 555 this->setstate(ios_base::badbit | ios_base::failbit); 556 } 557#ifndef _LIBCPP_NO_EXCEPTIONS 558 } 559 catch (...) 560 { 561 this->__set_badbit_and_consider_rethrow(); 562 } 563#endif // _LIBCPP_NO_EXCEPTIONS 564 return *this; 565} 566 567template <class _CharT, class _Traits> 568basic_ostream<_CharT, _Traits>& 569basic_ostream<_CharT, _Traits>::operator<<(unsigned long __n) 570{ 571#ifndef _LIBCPP_NO_EXCEPTIONS 572 try 573 { 574#endif // _LIBCPP_NO_EXCEPTIONS 575 sentry __s(*this); 576 if (__s) 577 { 578 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; 579 const _Fp& __f = std::use_facet<_Fp>(this->getloc()); 580 if (__f.put(*this, *this, this->fill(), __n).failed()) 581 this->setstate(ios_base::badbit | ios_base::failbit); 582 } 583#ifndef _LIBCPP_NO_EXCEPTIONS 584 } 585 catch (...) 586 { 587 this->__set_badbit_and_consider_rethrow(); 588 } 589#endif // _LIBCPP_NO_EXCEPTIONS 590 return *this; 591} 592 593template <class _CharT, class _Traits> 594basic_ostream<_CharT, _Traits>& 595basic_ostream<_CharT, _Traits>::operator<<(long long __n) 596{ 597#ifndef _LIBCPP_NO_EXCEPTIONS 598 try 599 { 600#endif // _LIBCPP_NO_EXCEPTIONS 601 sentry __s(*this); 602 if (__s) 603 { 604 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; 605 const _Fp& __f = std::use_facet<_Fp>(this->getloc()); 606 if (__f.put(*this, *this, this->fill(), __n).failed()) 607 this->setstate(ios_base::badbit | ios_base::failbit); 608 } 609#ifndef _LIBCPP_NO_EXCEPTIONS 610 } 611 catch (...) 612 { 613 this->__set_badbit_and_consider_rethrow(); 614 } 615#endif // _LIBCPP_NO_EXCEPTIONS 616 return *this; 617} 618 619template <class _CharT, class _Traits> 620basic_ostream<_CharT, _Traits>& 621basic_ostream<_CharT, _Traits>::operator<<(unsigned long long __n) 622{ 623#ifndef _LIBCPP_NO_EXCEPTIONS 624 try 625 { 626#endif // _LIBCPP_NO_EXCEPTIONS 627 sentry __s(*this); 628 if (__s) 629 { 630 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; 631 const _Fp& __f = std::use_facet<_Fp>(this->getloc()); 632 if (__f.put(*this, *this, this->fill(), __n).failed()) 633 this->setstate(ios_base::badbit | ios_base::failbit); 634 } 635#ifndef _LIBCPP_NO_EXCEPTIONS 636 } 637 catch (...) 638 { 639 this->__set_badbit_and_consider_rethrow(); 640 } 641#endif // _LIBCPP_NO_EXCEPTIONS 642 return *this; 643} 644 645template <class _CharT, class _Traits> 646basic_ostream<_CharT, _Traits>& 647basic_ostream<_CharT, _Traits>::operator<<(float __n) 648{ 649#ifndef _LIBCPP_NO_EXCEPTIONS 650 try 651 { 652#endif // _LIBCPP_NO_EXCEPTIONS 653 sentry __s(*this); 654 if (__s) 655 { 656 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; 657 const _Fp& __f = std::use_facet<_Fp>(this->getloc()); 658 if (__f.put(*this, *this, this->fill(), static_cast<double>(__n)).failed()) 659 this->setstate(ios_base::badbit | ios_base::failbit); 660 } 661#ifndef _LIBCPP_NO_EXCEPTIONS 662 } 663 catch (...) 664 { 665 this->__set_badbit_and_consider_rethrow(); 666 } 667#endif // _LIBCPP_NO_EXCEPTIONS 668 return *this; 669} 670 671template <class _CharT, class _Traits> 672basic_ostream<_CharT, _Traits>& 673basic_ostream<_CharT, _Traits>::operator<<(double __n) 674{ 675#ifndef _LIBCPP_NO_EXCEPTIONS 676 try 677 { 678#endif // _LIBCPP_NO_EXCEPTIONS 679 sentry __s(*this); 680 if (__s) 681 { 682 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; 683 const _Fp& __f = std::use_facet<_Fp>(this->getloc()); 684 if (__f.put(*this, *this, this->fill(), __n).failed()) 685 this->setstate(ios_base::badbit | ios_base::failbit); 686 } 687#ifndef _LIBCPP_NO_EXCEPTIONS 688 } 689 catch (...) 690 { 691 this->__set_badbit_and_consider_rethrow(); 692 } 693#endif // _LIBCPP_NO_EXCEPTIONS 694 return *this; 695} 696 697template <class _CharT, class _Traits> 698basic_ostream<_CharT, _Traits>& 699basic_ostream<_CharT, _Traits>::operator<<(long double __n) 700{ 701#ifndef _LIBCPP_NO_EXCEPTIONS 702 try 703 { 704#endif // _LIBCPP_NO_EXCEPTIONS 705 sentry __s(*this); 706 if (__s) 707 { 708 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; 709 const _Fp& __f = std::use_facet<_Fp>(this->getloc()); 710 if (__f.put(*this, *this, this->fill(), __n).failed()) 711 this->setstate(ios_base::badbit | ios_base::failbit); 712 } 713#ifndef _LIBCPP_NO_EXCEPTIONS 714 } 715 catch (...) 716 { 717 this->__set_badbit_and_consider_rethrow(); 718 } 719#endif // _LIBCPP_NO_EXCEPTIONS 720 return *this; 721} 722 723template <class _CharT, class _Traits> 724basic_ostream<_CharT, _Traits>& 725basic_ostream<_CharT, _Traits>::operator<<(const void* __n) 726{ 727#ifndef _LIBCPP_NO_EXCEPTIONS 728 try 729 { 730#endif // _LIBCPP_NO_EXCEPTIONS 731 sentry __s(*this); 732 if (__s) 733 { 734 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; 735 const _Fp& __f = std::use_facet<_Fp>(this->getloc()); 736 if (__f.put(*this, *this, this->fill(), __n).failed()) 737 this->setstate(ios_base::badbit | ios_base::failbit); 738 } 739#ifndef _LIBCPP_NO_EXCEPTIONS 740 } 741 catch (...) 742 { 743 this->__set_badbit_and_consider_rethrow(); 744 } 745#endif // _LIBCPP_NO_EXCEPTIONS 746 return *this; 747} 748 749template<class _CharT, class _Traits> 750_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>& 751__put_character_sequence(basic_ostream<_CharT, _Traits>& __os, 752 const _CharT* __str, size_t __len) 753{ 754#ifndef _LIBCPP_NO_EXCEPTIONS 755 try 756 { 757#endif // _LIBCPP_NO_EXCEPTIONS 758 typename basic_ostream<_CharT, _Traits>::sentry __s(__os); 759 if (__s) 760 { 761 typedef ostreambuf_iterator<_CharT, _Traits> _Ip; 762 if (std::__pad_and_output(_Ip(__os), 763 __str, 764 (__os.flags() & ios_base::adjustfield) == ios_base::left ? 765 __str + __len : 766 __str, 767 __str + __len, 768 __os, 769 __os.fill()).failed()) 770 __os.setstate(ios_base::badbit | ios_base::failbit); 771 } 772#ifndef _LIBCPP_NO_EXCEPTIONS 773 } 774 catch (...) 775 { 776 __os.__set_badbit_and_consider_rethrow(); 777 } 778#endif // _LIBCPP_NO_EXCEPTIONS 779 return __os; 780} 781 782 783template<class _CharT, class _Traits> 784_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>& 785operator<<(basic_ostream<_CharT, _Traits>& __os, _CharT __c) 786{ 787 return _VSTD::__put_character_sequence(__os, &__c, 1); 788} 789 790template<class _CharT, class _Traits> 791_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>& 792operator<<(basic_ostream<_CharT, _Traits>& __os, char __cn) 793{ 794#ifndef _LIBCPP_NO_EXCEPTIONS 795 try 796 { 797#endif // _LIBCPP_NO_EXCEPTIONS 798 typename basic_ostream<_CharT, _Traits>::sentry __s(__os); 799 if (__s) 800 { 801 _CharT __c = __os.widen(__cn); 802 typedef ostreambuf_iterator<_CharT, _Traits> _Ip; 803 if (std::__pad_and_output(_Ip(__os), 804 &__c, 805 (__os.flags() & ios_base::adjustfield) == ios_base::left ? 806 &__c + 1 : 807 &__c, 808 &__c + 1, 809 __os, 810 __os.fill()).failed()) 811 __os.setstate(ios_base::badbit | ios_base::failbit); 812 } 813#ifndef _LIBCPP_NO_EXCEPTIONS 814 } 815 catch (...) 816 { 817 __os.__set_badbit_and_consider_rethrow(); 818 } 819#endif // _LIBCPP_NO_EXCEPTIONS 820 return __os; 821} 822 823template<class _Traits> 824_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>& 825operator<<(basic_ostream<char, _Traits>& __os, char __c) 826{ 827 return _VSTD::__put_character_sequence(__os, &__c, 1); 828} 829 830template<class _Traits> 831_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>& 832operator<<(basic_ostream<char, _Traits>& __os, signed char __c) 833{ 834 return _VSTD::__put_character_sequence(__os, (char *) &__c, 1); 835} 836 837template<class _Traits> 838_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>& 839operator<<(basic_ostream<char, _Traits>& __os, unsigned char __c) 840{ 841 return _VSTD::__put_character_sequence(__os, (char *) &__c, 1); 842} 843 844template<class _CharT, class _Traits> 845_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>& 846operator<<(basic_ostream<_CharT, _Traits>& __os, const _CharT* __str) 847{ 848 return _VSTD::__put_character_sequence(__os, __str, _Traits::length(__str)); 849} 850 851template<class _CharT, class _Traits> 852_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>& 853operator<<(basic_ostream<_CharT, _Traits>& __os, const char* __strn) 854{ 855#ifndef _LIBCPP_NO_EXCEPTIONS 856 try 857 { 858#endif // _LIBCPP_NO_EXCEPTIONS 859 typename basic_ostream<_CharT, _Traits>::sentry __s(__os); 860 if (__s) 861 { 862 typedef ostreambuf_iterator<_CharT, _Traits> _Ip; 863 size_t __len = char_traits<char>::length(__strn); 864 const int __bs = 100; 865 _CharT __wbb[__bs]; 866 _CharT* __wb = __wbb; 867 unique_ptr<_CharT, void(*)(void*)> __h(0, free); 868 if (__len > __bs) 869 { 870 __wb = (_CharT*)malloc(__len*sizeof(_CharT)); 871 if (__wb == 0) 872 __throw_bad_alloc(); 873 __h.reset(__wb); 874 } 875 for (_CharT* __p = __wb; *__strn != '\0'; ++__strn, ++__p) 876 *__p = __os.widen(*__strn); 877 if (std::__pad_and_output(_Ip(__os), 878 __wb, 879 (__os.flags() & ios_base::adjustfield) == ios_base::left ? 880 __wb + __len : 881 __wb, 882 __wb + __len, 883 __os, 884 __os.fill()).failed()) 885 __os.setstate(ios_base::badbit | ios_base::failbit); 886 } 887#ifndef _LIBCPP_NO_EXCEPTIONS 888 } 889 catch (...) 890 { 891 __os.__set_badbit_and_consider_rethrow(); 892 } 893#endif // _LIBCPP_NO_EXCEPTIONS 894 return __os; 895} 896 897template<class _Traits> 898_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>& 899operator<<(basic_ostream<char, _Traits>& __os, const char* __str) 900{ 901 return _VSTD::__put_character_sequence(__os, __str, _Traits::length(__str)); 902} 903 904template<class _Traits> 905_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>& 906operator<<(basic_ostream<char, _Traits>& __os, const signed char* __str) 907{ 908 const char *__s = (const char *) __str; 909 return _VSTD::__put_character_sequence(__os, __s, _Traits::length(__s)); 910} 911 912template<class _Traits> 913_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>& 914operator<<(basic_ostream<char, _Traits>& __os, const unsigned char* __str) 915{ 916 const char *__s = (const char *) __str; 917 return _VSTD::__put_character_sequence(__os, __s, _Traits::length(__s)); 918} 919 920template <class _CharT, class _Traits> 921basic_ostream<_CharT, _Traits>& 922basic_ostream<_CharT, _Traits>::put(char_type __c) 923{ 924#ifndef _LIBCPP_NO_EXCEPTIONS 925 try 926 { 927#endif // _LIBCPP_NO_EXCEPTIONS 928 sentry __s(*this); 929 if (__s) 930 { 931 typedef ostreambuf_iterator<_CharT, _Traits> _Op; 932 _Op __o(*this); 933 *__o = __c; 934 if (__o.failed()) 935 this->setstate(ios_base::badbit); 936 } 937#ifndef _LIBCPP_NO_EXCEPTIONS 938 } 939 catch (...) 940 { 941 this->__set_badbit_and_consider_rethrow(); 942 } 943#endif // _LIBCPP_NO_EXCEPTIONS 944 return *this; 945} 946 947template <class _CharT, class _Traits> 948basic_ostream<_CharT, _Traits>& 949basic_ostream<_CharT, _Traits>::write(const char_type* __s, streamsize __n) 950{ 951#ifndef _LIBCPP_NO_EXCEPTIONS 952 try 953 { 954#endif // _LIBCPP_NO_EXCEPTIONS 955 sentry __sen(*this); 956 if (__sen && __n) 957 { 958 if (this->rdbuf()->sputn(__s, __n) != __n) 959 this->setstate(ios_base::badbit); 960 } 961#ifndef _LIBCPP_NO_EXCEPTIONS 962 } 963 catch (...) 964 { 965 this->__set_badbit_and_consider_rethrow(); 966 } 967#endif // _LIBCPP_NO_EXCEPTIONS 968 return *this; 969} 970 971template <class _CharT, class _Traits> 972basic_ostream<_CharT, _Traits>& 973basic_ostream<_CharT, _Traits>::flush() 974{ 975#ifndef _LIBCPP_NO_EXCEPTIONS 976 try 977 { 978#endif // _LIBCPP_NO_EXCEPTIONS 979 if (this->rdbuf()) 980 { 981 sentry __s(*this); 982 if (__s) 983 { 984 if (this->rdbuf()->pubsync() == -1) 985 this->setstate(ios_base::badbit); 986 } 987 } 988#ifndef _LIBCPP_NO_EXCEPTIONS 989 } 990 catch (...) 991 { 992 this->__set_badbit_and_consider_rethrow(); 993 } 994#endif // _LIBCPP_NO_EXCEPTIONS 995 return *this; 996} 997 998template <class _CharT, class _Traits> 999typename basic_ostream<_CharT, _Traits>::pos_type 1000basic_ostream<_CharT, _Traits>::tellp() 1001{ 1002 if (this->fail()) 1003 return pos_type(-1); 1004 return this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out); 1005} 1006 1007template <class _CharT, class _Traits> 1008basic_ostream<_CharT, _Traits>& 1009basic_ostream<_CharT, _Traits>::seekp(pos_type __pos) 1010{ 1011 sentry __s(*this); 1012 if (!this->fail()) 1013 { 1014 if (this->rdbuf()->pubseekpos(__pos, ios_base::out) == pos_type(-1)) 1015 this->setstate(ios_base::failbit); 1016 } 1017 return *this; 1018} 1019 1020template <class _CharT, class _Traits> 1021basic_ostream<_CharT, _Traits>& 1022basic_ostream<_CharT, _Traits>::seekp(off_type __off, ios_base::seekdir __dir) 1023{ 1024 sentry __s(*this); 1025 if (!this->fail()) 1026 { 1027 if (this->rdbuf()->pubseekoff(__off, __dir, ios_base::out) == pos_type(-1)) 1028 this->setstate(ios_base::failbit); 1029 } 1030 return *this; 1031} 1032 1033template <class _CharT, class _Traits> 1034_LIBCPP_HIDE_FROM_ABI inline 1035basic_ostream<_CharT, _Traits>& 1036endl(basic_ostream<_CharT, _Traits>& __os) 1037{ 1038 __os.put(__os.widen('\n')); 1039 __os.flush(); 1040 return __os; 1041} 1042 1043template <class _CharT, class _Traits> 1044_LIBCPP_HIDE_FROM_ABI inline 1045basic_ostream<_CharT, _Traits>& 1046ends(basic_ostream<_CharT, _Traits>& __os) 1047{ 1048 __os.put(_CharT()); 1049 return __os; 1050} 1051 1052template <class _CharT, class _Traits> 1053_LIBCPP_HIDE_FROM_ABI inline 1054basic_ostream<_CharT, _Traits>& 1055flush(basic_ostream<_CharT, _Traits>& __os) 1056{ 1057 __os.flush(); 1058 return __os; 1059} 1060 1061template <class _Stream, class _Tp, class = void> 1062struct __is_ostreamable : false_type { }; 1063 1064template <class _Stream, class _Tp> 1065struct __is_ostreamable<_Stream, _Tp, decltype( 1066 std::declval<_Stream>() << std::declval<_Tp>(), void() 1067)> : true_type { }; 1068 1069template <class _Stream, class _Tp, class = typename enable_if< 1070 _And<is_base_of<ios_base, _Stream>, 1071 __is_ostreamable<_Stream&, const _Tp&> >::value 1072>::type> 1073_LIBCPP_INLINE_VISIBILITY 1074_Stream&& operator<<(_Stream&& __os, const _Tp& __x) 1075{ 1076 __os << __x; 1077 return _VSTD::move(__os); 1078} 1079 1080template<class _CharT, class _Traits, class _Allocator> 1081basic_ostream<_CharT, _Traits>& 1082operator<<(basic_ostream<_CharT, _Traits>& __os, 1083 const basic_string<_CharT, _Traits, _Allocator>& __str) 1084{ 1085 return _VSTD::__put_character_sequence(__os, __str.data(), __str.size()); 1086} 1087 1088template<class _CharT, class _Traits> 1089_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>& 1090operator<<(basic_ostream<_CharT, _Traits>& __os, 1091 basic_string_view<_CharT, _Traits> __sv) 1092{ 1093 return _VSTD::__put_character_sequence(__os, __sv.data(), __sv.size()); 1094} 1095 1096template <class _CharT, class _Traits> 1097inline _LIBCPP_INLINE_VISIBILITY 1098basic_ostream<_CharT, _Traits>& 1099operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __ec) 1100{ 1101 return __os << __ec.category().name() << ':' << __ec.value(); 1102} 1103 1104template<class _CharT, class _Traits, class _Yp> 1105inline _LIBCPP_INLINE_VISIBILITY 1106basic_ostream<_CharT, _Traits>& 1107operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Yp> const& __p) 1108{ 1109 return __os << __p.get(); 1110} 1111 1112template<class _CharT, class _Traits, class _Yp, class _Dp> 1113inline _LIBCPP_INLINE_VISIBILITY 1114typename enable_if 1115< 1116 is_same<void, __void_t<decltype((std::declval<basic_ostream<_CharT, _Traits>&>() << std::declval<typename unique_ptr<_Yp, _Dp>::pointer>()))> >::value, 1117 basic_ostream<_CharT, _Traits>& 1118>::type 1119operator<<(basic_ostream<_CharT, _Traits>& __os, unique_ptr<_Yp, _Dp> const& __p) 1120{ 1121 return __os << __p.get(); 1122} 1123 1124template <class _CharT, class _Traits, size_t _Size> 1125_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>& 1126operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Size>& __x) 1127{ 1128 return __os << __x.template to_string<_CharT, _Traits> 1129 (std::use_facet<ctype<_CharT> >(__os.getloc()).widen('0'), 1130 std::use_facet<ctype<_CharT> >(__os.getloc()).widen('1')); 1131} 1132 1133#if _LIBCPP_STD_VER > 17 1134 1135#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 1136template <class _Traits> 1137basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, wchar_t) = delete; 1138 1139template <class _Traits> 1140basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const wchar_t*) = delete; 1141 1142template <class _Traits> 1143basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, char16_t) = delete; 1144 1145template <class _Traits> 1146basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, char32_t) = delete; 1147 1148template <class _Traits> 1149basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, const char16_t*) = delete; 1150 1151template <class _Traits> 1152basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, const char32_t*) = delete; 1153 1154#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS 1155 1156#ifndef _LIBCPP_HAS_NO_CHAR8_T 1157template <class _Traits> 1158basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, char8_t) = delete; 1159 1160template <class _Traits> 1161basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, char8_t) = delete; 1162 1163template <class _Traits> 1164basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const char8_t*) = delete; 1165 1166template <class _Traits> 1167basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, const char8_t*) = delete; 1168#endif 1169 1170template <class _Traits> 1171basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, char16_t) = delete; 1172 1173template <class _Traits> 1174basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, char32_t) = delete; 1175 1176template <class _Traits> 1177basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const char16_t*) = delete; 1178 1179template <class _Traits> 1180basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const char32_t*) = delete; 1181 1182#endif // _LIBCPP_STD_VER > 17 1183 1184extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ostream<char>; 1185#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 1186extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ostream<wchar_t>; 1187#endif 1188 1189_LIBCPP_END_NAMESPACE_STD 1190 1191#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 1192# include <concepts> 1193# include <iterator> 1194# include <type_traits> 1195#endif 1196 1197#endif // _LIBCPP_OSTREAM 1198