1//===---------------------------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===---------------------------------------------------------------------===//
8
9#ifndef _LIBCPP___OSTREAM_BASIC_OSTREAM_H
10#define _LIBCPP___OSTREAM_BASIC_OSTREAM_H
11
12#include <__config>
13#include <__exception/operations.h>
14#include <__memory/shared_ptr.h>
15#include <__memory/unique_ptr.h>
16#include <__system_error/error_code.h>
17#include <__type_traits/conjunction.h>
18#include <__type_traits/enable_if.h>
19#include <__type_traits/is_base_of.h>
20#include <__type_traits/void_t.h>
21#include <__utility/declval.h>
22#include <bitset>
23#include <cstddef>
24#include <ios>
25#include <locale>
26#include <new> // for __throw_bad_alloc
27#include <streambuf>
28#include <string_view>
29
30#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
31# pragma GCC system_header
32#endif
33
34_LIBCPP_PUSH_MACROS
35#include <__undef_macros>
36
37_LIBCPP_BEGIN_NAMESPACE_STD
38
39template <class _CharT, class _Traits>
40class _LIBCPP_TEMPLATE_VIS basic_ostream : virtual public basic_ios<_CharT, _Traits> {
41public:
42 // types (inherited from basic_ios (27.5.4)):
43 typedef _CharT char_type;
44 typedef _Traits traits_type;
45 typedef typename traits_type::int_type int_type;
46 typedef typename traits_type::pos_type pos_type;
47 typedef typename traits_type::off_type off_type;
48
49 // 27.7.2.2 Constructor/destructor:
50 inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 explicit basic_ostream(basic_streambuf<char_type, traits_type>* __sb) {
51 this->init(__sb);
52 }
53 ~basic_ostream() override;
54
55 basic_ostream(const basic_ostream& __rhs) = delete;
56 basic_ostream& operator=(const basic_ostream& __rhs) = delete;
57
58protected:
59 inline _LIBCPP_HIDE_FROM_ABI basic_ostream(basic_ostream&& __rhs);
60
61 // 27.7.2.3 Assign/swap
62 inline _LIBCPP_HIDE_FROM_ABI basic_ostream& operator=(basic_ostream&& __rhs);
63
64 inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 void swap(basic_ostream& __rhs) {
65 basic_ios<char_type, traits_type>::swap(__rhs);
66 }
67
68public:
69 // 27.7.2.4 Prefix/suffix:
70 class _LIBCPP_TEMPLATE_VIS sentry;
71
72 // 27.7.2.6 Formatted output:
73 inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_ostream& operator<<(basic_ostream& (*__pf)(basic_ostream&)) {
74 return __pf(*this);
75 }
76
77 inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_ostream&
78 operator<<(basic_ios<char_type, traits_type>& (*__pf)(basic_ios<char_type, traits_type>&)) {
79 __pf(*this);
80 return *this;
81 }
82
83 inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_ostream& operator<<(ios_base& (*__pf)(ios_base&)) {
84 __pf(*this);
85 return *this;
86 }
87
88 basic_ostream& operator<<(bool __n);
89 basic_ostream& operator<<(short __n);
90 basic_ostream& operator<<(unsigned short __n);
91 basic_ostream& operator<<(int __n);
92 basic_ostream& operator<<(unsigned int __n);
93 basic_ostream& operator<<(long __n);
94 basic_ostream& operator<<(unsigned long __n);
95 basic_ostream& operator<<(long long __n);
96 basic_ostream& operator<<(unsigned long long __n);
97 basic_ostream& operator<<(float __f);
98 basic_ostream& operator<<(double __f);
99 basic_ostream& operator<<(long double __f);
100 basic_ostream& operator<<(const void* __p);
101
102#if _LIBCPP_STD_VER >= 23
103 _LIBCPP_HIDE_FROM_ABI basic_ostream& operator<<(const volatile void* __p) {
104 return operator<<(const_cast<const void*>(__p));
105 }
106#endif
107
108 basic_ostream& operator<<(basic_streambuf<char_type, traits_type>* __sb);
109
110#if _LIBCPP_STD_VER >= 17
111 // LWG 2221 - nullptr. This is not backported to older standards modes.
112 // See https://reviews.llvm.org/D127033 for more info on the rationale.
113 _LIBCPP_HIDE_FROM_ABI basic_ostream& operator<<(nullptr_t) { return *this << "nullptr"; }
114#endif
115
116 // 27.7.2.7 Unformatted output:
117 basic_ostream& put(char_type __c);
118 basic_ostream& write(const char_type* __s, streamsize __n);
119 basic_ostream& flush();
120
121 // 27.7.2.5 seeks:
122 inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 pos_type tellp();
123 inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_ostream& seekp(pos_type __pos);
124 inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_ostream& seekp(off_type __off, ios_base::seekdir __dir);
125
126protected:
127 _LIBCPP_HIDE_FROM_ABI basic_ostream() {} // extension, intentially does not initialize
128};
129
130template <class _CharT, class _Traits>
131class _LIBCPP_TEMPLATE_VIS basic_ostream<_CharT, _Traits>::sentry {
132 bool __ok_;
133 basic_ostream<_CharT, _Traits>& __os_;
134
135public:
136 explicit sentry(basic_ostream<_CharT, _Traits>& __os);
137 ~sentry();
138 sentry(const sentry&) = delete;
139 sentry& operator=(const sentry&) = delete;
140
141 _LIBCPP_HIDE_FROM_ABI explicit operator bool() const { return __ok_; }
142};
143
144template <class _CharT, class _Traits>
145basic_ostream<_CharT, _Traits>::sentry::sentry(basic_ostream<_CharT, _Traits>& __os) : __ok_(false), __os_(__os) {
146 if (__os.good()) {
147 if (__os.tie())
148 __os.tie()->flush();
149 __ok_ = true;
150 }
151}
152
153template <class _CharT, class _Traits>
154basic_ostream<_CharT, _Traits>::sentry::~sentry() {
155 if (__os_.rdbuf() && __os_.good() && (__os_.flags() & ios_base::unitbuf) && !uncaught_exception()) {
156#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
157 try {
158#endif // _LIBCPP_HAS_NO_EXCEPTIONS
159 if (__os_.rdbuf()->pubsync() == -1)
160 __os_.setstate(ios_base::badbit);
161#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
162 } catch (...) {
163 }
164#endif // _LIBCPP_HAS_NO_EXCEPTIONS
165 }
166}
167
168template <class _CharT, class _Traits>
169basic_ostream<_CharT, _Traits>::basic_ostream(basic_ostream&& __rhs) {
170 this->move(__rhs);
171}
172
173template <class _CharT, class _Traits>
174basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator=(basic_ostream&& __rhs) {
175 swap(__rhs);
176 return *this;
177}
178
179template <class _CharT, class _Traits>
180basic_ostream<_CharT, _Traits>::~basic_ostream() {}
181
182template <class _CharT, class _Traits>
183basic_ostream<_CharT, _Traits>&
184basic_ostream<_CharT, _Traits>::operator<<(basic_streambuf<char_type, traits_type>* __sb) {
185#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
186 try {
187#endif // _LIBCPP_HAS_NO_EXCEPTIONS
188 sentry __s(*this);
189 if (__s) {
190 if (__sb) {
191#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
192 try {
193#endif // _LIBCPP_HAS_NO_EXCEPTIONS
194 typedef istreambuf_iterator<_CharT, _Traits> _Ip;
195 typedef ostreambuf_iterator<_CharT, _Traits> _Op;
196 _Ip __i(__sb);
197 _Ip __eof;
198 _Op __o(*this);
199 size_t __c = 0;
200 for (; __i != __eof; ++__i, ++__o, ++__c) {
201 *__o = *__i;
202 if (__o.failed())
203 break;
204 }
205 if (__c == 0)
206 this->setstate(ios_base::failbit);
207#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
208 } catch (...) {
209 this->__set_failbit_and_consider_rethrow();
210 }
211#endif // _LIBCPP_HAS_NO_EXCEPTIONS
212 } else
213 this->setstate(ios_base::badbit);
214 }
215#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
216 } catch (...) {
217 this->__set_badbit_and_consider_rethrow();
218 }
219#endif // _LIBCPP_HAS_NO_EXCEPTIONS
220 return *this;
221}
222
223template <class _CharT, class _Traits>
224basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(bool __n) {
225#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
226 try {
227#endif // _LIBCPP_HAS_NO_EXCEPTIONS
228 sentry __s(*this);
229 if (__s) {
230 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
231 const _Fp& __f = std::use_facet<_Fp>(this->getloc());
232 if (__f.put(*this, *this, this->fill(), __n).failed())
233 this->setstate(ios_base::badbit | ios_base::failbit);
234 }
235#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
236 } catch (...) {
237 this->__set_badbit_and_consider_rethrow();
238 }
239#endif // _LIBCPP_HAS_NO_EXCEPTIONS
240 return *this;
241}
242
243template <class _CharT, class _Traits>
244basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(short __n) {
245#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
246 try {
247#endif // _LIBCPP_HAS_NO_EXCEPTIONS
248 sentry __s(*this);
249 if (__s) {
250 ios_base::fmtflags __flags = ios_base::flags() & ios_base::basefield;
251 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
252 const _Fp& __f = std::use_facet<_Fp>(this->getloc());
253 if (__f.put(*this,
254 *this,
255 this->fill(),
256 __flags == ios_base::oct || __flags == ios_base::hex
257 ? static_cast<long>(static_cast<unsigned short>(__n))
258 : static_cast<long>(__n))
259 .failed())
260 this->setstate(ios_base::badbit | ios_base::failbit);
261 }
262#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
263 } catch (...) {
264 this->__set_badbit_and_consider_rethrow();
265 }
266#endif // _LIBCPP_HAS_NO_EXCEPTIONS
267 return *this;
268}
269
270template <class _CharT, class _Traits>
271basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(unsigned short __n) {
272#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
273 try {
274#endif // _LIBCPP_HAS_NO_EXCEPTIONS
275 sentry __s(*this);
276 if (__s) {
277 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
278 const _Fp& __f = std::use_facet<_Fp>(this->getloc());
279 if (__f.put(*this, *this, this->fill(), static_cast<unsigned long>(__n)).failed())
280 this->setstate(ios_base::badbit | ios_base::failbit);
281 }
282#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
283 } catch (...) {
284 this->__set_badbit_and_consider_rethrow();
285 }
286#endif // _LIBCPP_HAS_NO_EXCEPTIONS
287 return *this;
288}
289
290template <class _CharT, class _Traits>
291basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(int __n) {
292#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
293 try {
294#endif // _LIBCPP_HAS_NO_EXCEPTIONS
295 sentry __s(*this);
296 if (__s) {
297 ios_base::fmtflags __flags = ios_base::flags() & ios_base::basefield;
298 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
299 const _Fp& __f = std::use_facet<_Fp>(this->getloc());
300 if (__f.put(*this,
301 *this,
302 this->fill(),
303 __flags == ios_base::oct || __flags == ios_base::hex
304 ? static_cast<long>(static_cast<unsigned int>(__n))
305 : static_cast<long>(__n))
306 .failed())
307 this->setstate(ios_base::badbit | ios_base::failbit);
308 }
309#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
310 } catch (...) {
311 this->__set_badbit_and_consider_rethrow();
312 }
313#endif // _LIBCPP_HAS_NO_EXCEPTIONS
314 return *this;
315}
316
317template <class _CharT, class _Traits>
318basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(unsigned int __n) {
319#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
320 try {
321#endif // _LIBCPP_HAS_NO_EXCEPTIONS
322 sentry __s(*this);
323 if (__s) {
324 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
325 const _Fp& __f = std::use_facet<_Fp>(this->getloc());
326 if (__f.put(*this, *this, this->fill(), static_cast<unsigned long>(__n)).failed())
327 this->setstate(ios_base::badbit | ios_base::failbit);
328 }
329#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
330 } catch (...) {
331 this->__set_badbit_and_consider_rethrow();
332 }
333#endif // _LIBCPP_HAS_NO_EXCEPTIONS
334 return *this;
335}
336
337template <class _CharT, class _Traits>
338basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(long __n) {
339#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
340 try {
341#endif // _LIBCPP_HAS_NO_EXCEPTIONS
342 sentry __s(*this);
343 if (__s) {
344 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
345 const _Fp& __f = std::use_facet<_Fp>(this->getloc());
346 if (__f.put(*this, *this, this->fill(), __n).failed())
347 this->setstate(ios_base::badbit | ios_base::failbit);
348 }
349#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
350 } catch (...) {
351 this->__set_badbit_and_consider_rethrow();
352 }
353#endif // _LIBCPP_HAS_NO_EXCEPTIONS
354 return *this;
355}
356
357template <class _CharT, class _Traits>
358basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(unsigned long __n) {
359#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
360 try {
361#endif // _LIBCPP_HAS_NO_EXCEPTIONS
362 sentry __s(*this);
363 if (__s) {
364 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
365 const _Fp& __f = std::use_facet<_Fp>(this->getloc());
366 if (__f.put(*this, *this, this->fill(), __n).failed())
367 this->setstate(ios_base::badbit | ios_base::failbit);
368 }
369#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
370 } catch (...) {
371 this->__set_badbit_and_consider_rethrow();
372 }
373#endif // _LIBCPP_HAS_NO_EXCEPTIONS
374 return *this;
375}
376
377template <class _CharT, class _Traits>
378basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(long long __n) {
379#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
380 try {
381#endif // _LIBCPP_HAS_NO_EXCEPTIONS
382 sentry __s(*this);
383 if (__s) {
384 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
385 const _Fp& __f = std::use_facet<_Fp>(this->getloc());
386 if (__f.put(*this, *this, this->fill(), __n).failed())
387 this->setstate(ios_base::badbit | ios_base::failbit);
388 }
389#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
390 } catch (...) {
391 this->__set_badbit_and_consider_rethrow();
392 }
393#endif // _LIBCPP_HAS_NO_EXCEPTIONS
394 return *this;
395}
396
397template <class _CharT, class _Traits>
398basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(unsigned long long __n) {
399#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
400 try {
401#endif // _LIBCPP_HAS_NO_EXCEPTIONS
402 sentry __s(*this);
403 if (__s) {
404 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
405 const _Fp& __f = std::use_facet<_Fp>(this->getloc());
406 if (__f.put(*this, *this, this->fill(), __n).failed())
407 this->setstate(ios_base::badbit | ios_base::failbit);
408 }
409#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
410 } catch (...) {
411 this->__set_badbit_and_consider_rethrow();
412 }
413#endif // _LIBCPP_HAS_NO_EXCEPTIONS
414 return *this;
415}
416
417template <class _CharT, class _Traits>
418basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(float __n) {
419#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
420 try {
421#endif // _LIBCPP_HAS_NO_EXCEPTIONS
422 sentry __s(*this);
423 if (__s) {
424 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
425 const _Fp& __f = std::use_facet<_Fp>(this->getloc());
426 if (__f.put(*this, *this, this->fill(), static_cast<double>(__n)).failed())
427 this->setstate(ios_base::badbit | ios_base::failbit);
428 }
429#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
430 } catch (...) {
431 this->__set_badbit_and_consider_rethrow();
432 }
433#endif // _LIBCPP_HAS_NO_EXCEPTIONS
434 return *this;
435}
436
437template <class _CharT, class _Traits>
438basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(double __n) {
439#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
440 try {
441#endif // _LIBCPP_HAS_NO_EXCEPTIONS
442 sentry __s(*this);
443 if (__s) {
444 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
445 const _Fp& __f = std::use_facet<_Fp>(this->getloc());
446 if (__f.put(*this, *this, this->fill(), __n).failed())
447 this->setstate(ios_base::badbit | ios_base::failbit);
448 }
449#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
450 } catch (...) {
451 this->__set_badbit_and_consider_rethrow();
452 }
453#endif // _LIBCPP_HAS_NO_EXCEPTIONS
454 return *this;
455}
456
457template <class _CharT, class _Traits>
458basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(long double __n) {
459#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
460 try {
461#endif // _LIBCPP_HAS_NO_EXCEPTIONS
462 sentry __s(*this);
463 if (__s) {
464 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
465 const _Fp& __f = std::use_facet<_Fp>(this->getloc());
466 if (__f.put(*this, *this, this->fill(), __n).failed())
467 this->setstate(ios_base::badbit | ios_base::failbit);
468 }
469#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
470 } catch (...) {
471 this->__set_badbit_and_consider_rethrow();
472 }
473#endif // _LIBCPP_HAS_NO_EXCEPTIONS
474 return *this;
475}
476
477template <class _CharT, class _Traits>
478basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(const void* __n) {
479#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
480 try {
481#endif // _LIBCPP_HAS_NO_EXCEPTIONS
482 sentry __s(*this);
483 if (__s) {
484 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
485 const _Fp& __f = std::use_facet<_Fp>(this->getloc());
486 if (__f.put(*this, *this, this->fill(), __n).failed())
487 this->setstate(ios_base::badbit | ios_base::failbit);
488 }
489#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
490 } catch (...) {
491 this->__set_badbit_and_consider_rethrow();
492 }
493#endif // _LIBCPP_HAS_NO_EXCEPTIONS
494 return *this;
495}
496
497template <class _CharT, class _Traits>
498_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
499__put_character_sequence(basic_ostream<_CharT, _Traits>& __os, const _CharT* __str, size_t __len) {
500#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
501 try {
502#endif // _LIBCPP_HAS_NO_EXCEPTIONS
503 typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
504 if (__s) {
505 typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
506 if (std::__pad_and_output(
507 _Ip(__os),
508 __str,
509 (__os.flags() & ios_base::adjustfield) == ios_base::left ? __str + __len : __str,
510 __str + __len,
511 __os,
512 __os.fill())
513 .failed())
514 __os.setstate(ios_base::badbit | ios_base::failbit);
515 }
516#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
517 } catch (...) {
518 __os.__set_badbit_and_consider_rethrow();
519 }
520#endif // _LIBCPP_HAS_NO_EXCEPTIONS
521 return __os;
522}
523
524template <class _CharT, class _Traits>
525_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, _CharT __c) {
526 return std::__put_character_sequence(__os, &__c, 1);
527}
528
529template <class _CharT, class _Traits>
530_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, char __cn) {
531#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
532 try {
533#endif // _LIBCPP_HAS_NO_EXCEPTIONS
534 typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
535 if (__s) {
536 _CharT __c = __os.widen(__cn);
537 typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
538 if (std::__pad_and_output(
539 _Ip(__os),
540 &__c,
541 (__os.flags() & ios_base::adjustfield) == ios_base::left ? &__c + 1 : &__c,
542 &__c + 1,
543 __os,
544 __os.fill())
545 .failed())
546 __os.setstate(ios_base::badbit | ios_base::failbit);
547 }
548#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
549 } catch (...) {
550 __os.__set_badbit_and_consider_rethrow();
551 }
552#endif // _LIBCPP_HAS_NO_EXCEPTIONS
553 return __os;
554}
555
556template <class _Traits>
557_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& __os, char __c) {
558 return std::__put_character_sequence(__os, &__c, 1);
559}
560
561template <class _Traits>
562_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& __os, signed char __c) {
563 return std::__put_character_sequence(__os, (char*)&__c, 1);
564}
565
566template <class _Traits>
567_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& __os, unsigned char __c) {
568 return std::__put_character_sequence(__os, (char*)&__c, 1);
569}
570
571template <class _CharT, class _Traits>
572_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
573operator<<(basic_ostream<_CharT, _Traits>& __os, const _CharT* __str) {
574 return std::__put_character_sequence(__os, __str, _Traits::length(__str));
575}
576
577template <class _CharT, class _Traits>
578_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
579operator<<(basic_ostream<_CharT, _Traits>& __os, const char* __strn) {
580#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
581 try {
582#endif // _LIBCPP_HAS_NO_EXCEPTIONS
583 typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
584 if (__s) {
585 typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
586 size_t __len = char_traits<char>::length(__strn);
587 const int __bs = 100;
588 _CharT __wbb[__bs];
589 _CharT* __wb = __wbb;
590 unique_ptr<_CharT, void (*)(void*)> __h(0, free);
591 if (__len > __bs) {
592 __wb = (_CharT*)malloc(__len * sizeof(_CharT));
593 if (__wb == 0)
594 __throw_bad_alloc();
595 __h.reset(__wb);
596 }
597 for (_CharT* __p = __wb; *__strn != '\0'; ++__strn, ++__p)
598 *__p = __os.widen(*__strn);
599 if (std::__pad_and_output(
600 _Ip(__os),
601 __wb,
602 (__os.flags() & ios_base::adjustfield) == ios_base::left ? __wb + __len : __wb,
603 __wb + __len,
604 __os,
605 __os.fill())
606 .failed())
607 __os.setstate(ios_base::badbit | ios_base::failbit);
608 }
609#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
610 } catch (...) {
611 __os.__set_badbit_and_consider_rethrow();
612 }
613#endif // _LIBCPP_HAS_NO_EXCEPTIONS
614 return __os;
615}
616
617template <class _Traits>
618_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& __os, const char* __str) {
619 return std::__put_character_sequence(__os, __str, _Traits::length(__str));
620}
621
622template <class _Traits>
623_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>&
624operator<<(basic_ostream<char, _Traits>& __os, const signed char* __str) {
625 const char* __s = (const char*)__str;
626 return std::__put_character_sequence(__os, __s, _Traits::length(__s));
627}
628
629template <class _Traits>
630_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>&
631operator<<(basic_ostream<char, _Traits>& __os, const unsigned char* __str) {
632 const char* __s = (const char*)__str;
633 return std::__put_character_sequence(__os, __s, _Traits::length(__s));
634}
635
636template <class _CharT, class _Traits>
637basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::put(char_type __c) {
638#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
639 try {
640#endif // _LIBCPP_HAS_NO_EXCEPTIONS
641 sentry __s(*this);
642 if (__s) {
643 typedef ostreambuf_iterator<_CharT, _Traits> _Op;
644 _Op __o(*this);
645 *__o = __c;
646 if (__o.failed())
647 this->setstate(ios_base::badbit);
648 }
649#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
650 } catch (...) {
651 this->__set_badbit_and_consider_rethrow();
652 }
653#endif // _LIBCPP_HAS_NO_EXCEPTIONS
654 return *this;
655}
656
657template <class _CharT, class _Traits>
658basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::write(const char_type* __s, streamsize __n) {
659#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
660 try {
661#endif // _LIBCPP_HAS_NO_EXCEPTIONS
662 sentry __sen(*this);
663 if (__sen && __n) {
664 if (this->rdbuf()->sputn(__s, __n) != __n)
665 this->setstate(ios_base::badbit);
666 }
667#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
668 } catch (...) {
669 this->__set_badbit_and_consider_rethrow();
670 }
671#endif // _LIBCPP_HAS_NO_EXCEPTIONS
672 return *this;
673}
674
675template <class _CharT, class _Traits>
676basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::flush() {
677#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
678 try {
679#endif // _LIBCPP_HAS_NO_EXCEPTIONS
680 if (this->rdbuf()) {
681 sentry __s(*this);
682 if (__s) {
683 if (this->rdbuf()->pubsync() == -1)
684 this->setstate(ios_base::badbit);
685 }
686 }
687#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
688 } catch (...) {
689 this->__set_badbit_and_consider_rethrow();
690 }
691#endif // _LIBCPP_HAS_NO_EXCEPTIONS
692 return *this;
693}
694
695template <class _CharT, class _Traits>
696typename basic_ostream<_CharT, _Traits>::pos_type basic_ostream<_CharT, _Traits>::tellp() {
697 if (this->fail())
698 return pos_type(-1);
699 return this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
700}
701
702template <class _CharT, class _Traits>
703basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::seekp(pos_type __pos) {
704 sentry __s(*this);
705 if (!this->fail()) {
706 if (this->rdbuf()->pubseekpos(__pos, ios_base::out) == pos_type(-1))
707 this->setstate(ios_base::failbit);
708 }
709 return *this;
710}
711
712template <class _CharT, class _Traits>
713basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::seekp(off_type __off, ios_base::seekdir __dir) {
714 sentry __s(*this);
715 if (!this->fail()) {
716 if (this->rdbuf()->pubseekoff(__off, __dir, ios_base::out) == pos_type(-1))
717 this->setstate(ios_base::failbit);
718 }
719 return *this;
720}
721
722template <class _CharT, class _Traits>
723_LIBCPP_HIDE_FROM_ABI inline basic_ostream<_CharT, _Traits>& endl(basic_ostream<_CharT, _Traits>& __os) {
724 __os.put(__os.widen('\n'));
725 __os.flush();
726 return __os;
727}
728
729template <class _CharT, class _Traits>
730_LIBCPP_HIDE_FROM_ABI inline basic_ostream<_CharT, _Traits>& ends(basic_ostream<_CharT, _Traits>& __os) {
731 __os.put(_CharT());
732 return __os;
733}
734
735template <class _CharT, class _Traits>
736_LIBCPP_HIDE_FROM_ABI inline basic_ostream<_CharT, _Traits>& flush(basic_ostream<_CharT, _Traits>& __os) {
737 __os.flush();
738 return __os;
739}
740
741template <class _Stream, class _Tp, class = void>
742struct __is_ostreamable : false_type {};
743
744template <class _Stream, class _Tp>
745struct __is_ostreamable<_Stream, _Tp, decltype(std::declval<_Stream>() << std::declval<_Tp>(), void())> : true_type {};
746
747template <class _Stream,
748 class _Tp,
749 __enable_if_t<_And<is_base_of<ios_base, _Stream>, __is_ostreamable<_Stream&, const _Tp&> >::value, int> = 0>
750_LIBCPP_HIDE_FROM_ABI _Stream&& operator<<(_Stream&& __os, const _Tp& __x) {
751 __os << __x;
752 return std::move(__os);
753}
754
755template <class _CharT, class _Traits, class _Allocator>
756basic_ostream<_CharT, _Traits>&
757operator<<(basic_ostream<_CharT, _Traits>& __os, const basic_string<_CharT, _Traits, _Allocator>& __str) {
758 return std::__put_character_sequence(__os, __str.data(), __str.size());
759}
760
761template <class _CharT, class _Traits>
762_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
763operator<<(basic_ostream<_CharT, _Traits>& __os, basic_string_view<_CharT, _Traits> __sv) {
764 return std::__put_character_sequence(__os, __sv.data(), __sv.size());
765}
766
767template <class _CharT, class _Traits>
768inline _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
769operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __ec) {
770 return __os << __ec.category().name() << ':' << __ec.value();
771}
772
773template <class _CharT, class _Traits, class _Yp>
774inline _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
775operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Yp> const& __p) {
776 return __os << __p.get();
777}
778
779template <
780 class _CharT,
781 class _Traits,
782 class _Yp,
783 class _Dp,
784 __enable_if_t<is_same<void,
785 __void_t<decltype((std::declval<basic_ostream<_CharT, _Traits>&>()
786 << std::declval<typename unique_ptr<_Yp, _Dp>::pointer>()))> >::value,
787 int> = 0>
788inline _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
789operator<<(basic_ostream<_CharT, _Traits>& __os, unique_ptr<_Yp, _Dp> const& __p) {
790 return __os << __p.get();
791}
792
793template <class _CharT, class _Traits, size_t _Size>
794_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
795operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Size>& __x) {
796 return __os << __x.template to_string<_CharT, _Traits>(std::use_facet<ctype<_CharT> >(__os.getloc()).widen('0'),
797 std::use_facet<ctype<_CharT> >(__os.getloc()).widen('1'));
798}
799
800#if _LIBCPP_STD_VER >= 20
801
802# ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
803template <class _Traits>
804basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, wchar_t) = delete;
805
806template <class _Traits>
807basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const wchar_t*) = delete;
808
809template <class _Traits>
810basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, char16_t) = delete;
811
812template <class _Traits>
813basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, char32_t) = delete;
814
815template <class _Traits>
816basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, const char16_t*) = delete;
817
818template <class _Traits>
819basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, const char32_t*) = delete;
820
821# endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
822
823# ifndef _LIBCPP_HAS_NO_CHAR8_T
824template <class _Traits>
825basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, char8_t) = delete;
826
827template <class _Traits>
828basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, char8_t) = delete;
829
830template <class _Traits>
831basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const char8_t*) = delete;
832
833template <class _Traits>
834basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, const char8_t*) = delete;
835# endif
836
837template <class _Traits>
838basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, char16_t) = delete;
839
840template <class _Traits>
841basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, char32_t) = delete;
842
843template <class _Traits>
844basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const char16_t*) = delete;
845
846template <class _Traits>
847basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const char32_t*) = delete;
848
849#endif // _LIBCPP_STD_VER >= 20
850
851extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ostream<char>;
852#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
853extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ostream<wchar_t>;
854#endif
855
856_LIBCPP_END_NAMESPACE_STD
857
858_LIBCPP_POP_MACROS
859
860#endif // _LIBCPP___OSTREAM_BASIC_OSTREAM_H
861