libstdc++
ostream
1// Output streams -*- C++ -*-
2
3// Copyright (C) 1997-2023 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library. This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.
10
11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14// GNU General Public License for more details.
15
16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.
19
20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23// <http://www.gnu.org/licenses/>.
24
25/** @file include/ostream
26 * This is a Standard C++ Library header.
27 */
28
29//
30// ISO C++ 14882: 27.6.2 Output streams
31//
32
33#ifndef _GLIBCXX_OSTREAM
34#define _GLIBCXX_OSTREAM 1
35
36#pragma GCC system_header
37
38#include <bits/requires_hosted.h> // iostreams
39
40#include <ios>
41#include <bits/ostream_insert.h>
42
43namespace std _GLIBCXX_VISIBILITY(default)
44{
45_GLIBCXX_BEGIN_NAMESPACE_VERSION
46
47 /**
48 * @brief Template class basic_ostream.
49 * @ingroup io
50 *
51 * @tparam _CharT Type of character stream.
52 * @tparam _Traits Traits for character type, defaults to
53 * char_traits<_CharT>.
54 *
55 * This is the base class for all output streams. It provides text
56 * formatting of all builtin types, and communicates with any class
57 * derived from basic_streambuf to do the actual output.
58 */
59 template<typename _CharT, typename _Traits>
60 class basic_ostream : virtual public basic_ios<_CharT, _Traits>
61 {
62 public:
63 // Types (inherited from basic_ios):
64 typedef _CharT char_type;
65 typedef typename _Traits::int_type int_type;
66 typedef typename _Traits::pos_type pos_type;
67 typedef typename _Traits::off_type off_type;
68 typedef _Traits traits_type;
69
70 // Non-standard Types:
77
78 /**
79 * @brief Base constructor.
80 *
81 * This ctor is almost never called by the user directly, rather from
82 * derived classes' initialization lists, which pass a pointer to
83 * their own stream buffer.
84 */
85 explicit
87 { this->init(__sb); }
88
89 /**
90 * @brief Base destructor.
91 *
92 * This does very little apart from providing a virtual base dtor.
93 */
94 virtual
96
97 /// Safe prefix/suffix operations.
98 class sentry;
99 friend class sentry;
100
101 ///@{
102 /**
103 * @brief Interface for manipulators.
104 *
105 * Manipulators such as @c std::endl and @c std::hex use these
106 * functions in constructs like "std::cout << std::endl". For more
107 * information, see the iomanip header.
108 */
111 {
112 // _GLIBCXX_RESOLVE_LIB_DEFECTS
113 // DR 60. What is a formatted input function?
114 // The inserters for manipulators are *not* formatted output functions.
115 return __pf(*this);
116 }
117
120 {
121 // _GLIBCXX_RESOLVE_LIB_DEFECTS
122 // DR 60. What is a formatted input function?
123 // The inserters for manipulators are *not* formatted output functions.
124 __pf(*this);
125 return *this;
126 }
127
129 operator<<(ios_base& (*__pf) (ios_base&))
130 {
131 // _GLIBCXX_RESOLVE_LIB_DEFECTS
132 // DR 60. What is a formatted input function?
133 // The inserters for manipulators are *not* formatted output functions.
134 __pf(*this);
135 return *this;
136 }
137 ///@}
138
139 ///@{
140 /**
141 * @name Inserters
142 *
143 * All the @c operator<< functions (aka <em>formatted output
144 * functions</em>) have some common behavior. Each starts by
145 * constructing a temporary object of type std::basic_ostream::sentry.
146 * This can have several effects, concluding with the setting of a
147 * status flag; see the sentry documentation for more.
148 *
149 * If the sentry status is good, the function tries to generate
150 * whatever data is appropriate for the type of the argument.
151 *
152 * If an exception is thrown during insertion, ios_base::badbit
153 * will be turned on in the stream's error state without causing an
154 * ios_base::failure to be thrown. The original exception will then
155 * be rethrown.
156 */
157
158 ///@{
159 /**
160 * @brief Integer arithmetic inserters
161 * @param __n A variable of builtin integral type.
162 * @return @c *this if successful
163 *
164 * These functions use the stream's current locale (specifically, the
165 * @c num_get facet) to perform numeric formatting.
166 */
168 operator<<(long __n)
169 { return _M_insert(__n); }
170
172 operator<<(unsigned long __n)
173 { return _M_insert(__n); }
174
176 operator<<(bool __n)
177 { return _M_insert(__n); }
178
179 __ostream_type&
180 operator<<(short __n);
181
183 operator<<(unsigned short __n)
184 {
185 // _GLIBCXX_RESOLVE_LIB_DEFECTS
186 // 117. basic_ostream uses nonexistent num_put member functions.
187 return _M_insert(static_cast<unsigned long>(__n));
188 }
189
190 __ostream_type&
191 operator<<(int __n);
192
194 operator<<(unsigned int __n)
195 {
196 // _GLIBCXX_RESOLVE_LIB_DEFECTS
197 // 117. basic_ostream uses nonexistent num_put member functions.
198 return _M_insert(static_cast<unsigned long>(__n));
199 }
200
201#ifdef _GLIBCXX_USE_LONG_LONG
203 operator<<(long long __n)
204 { return _M_insert(__n); }
205
207 operator<<(unsigned long long __n)
208 { return _M_insert(__n); }
209#endif
210 ///@}
211
212 ///@{
213 /**
214 * @brief Floating point arithmetic inserters
215 * @param __f A variable of builtin floating point type.
216 * @return @c *this if successful
217 *
218 * These functions use the stream's current locale (specifically, the
219 * @c num_get facet) to perform numeric formatting.
220 */
222 operator<<(double __f)
223 { return _M_insert(__f); }
224
226 operator<<(float __f)
227 {
228 // _GLIBCXX_RESOLVE_LIB_DEFECTS
229 // 117. basic_ostream uses nonexistent num_put member functions.
230 return _M_insert(static_cast<double>(__f));
231 }
232
234 operator<<(long double __f)
235 { return _M_insert(__f); }
236 ///@}
237
238#if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
239 __attribute__((__always_inline__))
240 __ostream_type&
241 operator<<(_Float16 __f)
242 {
243 return _M_insert(static_cast<double>(__f));
244 }
245#endif
246
247#if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
248 __attribute__((__always_inline__))
249 __ostream_type&
250 operator<<(_Float32 __f)
251 {
252 return _M_insert(static_cast<double>(__f));
253 }
254#endif
255
256#if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
257 __attribute__((__always_inline__))
258 __ostream_type&
259 operator<<(_Float64 __f)
260 {
261 return _M_insert(static_cast<double>(__f));
262 }
263#endif
264
265#if defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128)
266 __attribute__((__always_inline__))
267 __ostream_type&
268 operator<<(_Float128 __f)
269 {
270 return _M_insert(static_cast<long double>(__f));
271 }
272#endif
273
274#if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
275 __attribute__((__always_inline__))
276 __ostream_type&
277 operator<<(__gnu_cxx::__bfloat16_t __f)
278 {
279 return _M_insert(static_cast<double>(__f));
280 }
281#endif
282
283 /**
284 * @brief Pointer arithmetic inserters
285 * @param __p A variable of pointer type.
286 * @return @c *this if successful
287 *
288 * These functions use the stream's current locale (specifically, the
289 * @c num_get facet) to perform numeric formatting.
290 */
292 operator<<(const void* __p)
293 { return _M_insert(__p); }
294
295#if __cplusplus >= 201703L
296 __ostream_type&
297 operator<<(nullptr_t)
298 { return *this << "nullptr"; }
299#endif
300
301#if __cplusplus > 202002L
302 __attribute__((__always_inline__))
303 __ostream_type&
304 operator<<(const volatile void* __p)
305 { return _M_insert(const_cast<const void*>(__p)); }
306#endif
307
308 /**
309 * @brief Extracting from another streambuf.
310 * @param __sb A pointer to a streambuf
311 *
312 * This function behaves like one of the basic arithmetic extractors,
313 * in that it also constructs a sentry object and has the same error
314 * handling behavior.
315 *
316 * If @p __sb is NULL, the stream will set failbit in its error state.
317 *
318 * Characters are extracted from @p __sb and inserted into @c *this
319 * until one of the following occurs:
320 *
321 * - the input stream reaches end-of-file,
322 * - insertion into the output sequence fails (in this case, the
323 * character that would have been inserted is not extracted), or
324 * - an exception occurs while getting a character from @p __sb, which
325 * sets failbit in the error state
326 *
327 * If the function inserts no characters, failbit is set.
328 */
329 __ostream_type&
330 operator<<(__streambuf_type* __sb);
331 ///@}
332
333 ///@{
334 /**
335 * @name Unformatted Output Functions
336 *
337 * All the unformatted output functions have some common behavior.
338 * Each starts by constructing a temporary object of type
339 * std::basic_ostream::sentry. This has several effects, concluding
340 * with the setting of a status flag; see the sentry documentation
341 * for more.
342 *
343 * If the sentry status is good, the function tries to generate
344 * whatever data is appropriate for the type of the argument.
345 *
346 * If an exception is thrown during insertion, ios_base::badbit
347 * will be turned on in the stream's error state. If badbit is on in
348 * the stream's exceptions mask, the exception will be rethrown
349 * without completing its actions.
350 */
351
352 /**
353 * @brief Simple insertion.
354 * @param __c The character to insert.
355 * @return *this
356 *
357 * Tries to insert @p __c.
358 *
359 * @note This function is not overloaded on signed char and
360 * unsigned char.
361 */
362 __ostream_type&
363 put(char_type __c);
364
365 /**
366 * @brief Character string insertion.
367 * @param __s The array to insert.
368 * @param __n Maximum number of characters to insert.
369 * @return *this
370 *
371 * Characters are copied from @p __s and inserted into the stream until
372 * one of the following happens:
373 *
374 * - @p __n characters are inserted
375 * - inserting into the output sequence fails (in this case, badbit
376 * will be set in the stream's error state)
377 *
378 * @note This function is not overloaded on signed char and
379 * unsigned char.
380 */
381 __ostream_type&
382 write(const char_type* __s, streamsize __n);
383 ///@}
384
385 /**
386 * @brief Synchronizing the stream buffer.
387 * @return *this
388 *
389 * If @c rdbuf() is a null pointer, changes nothing.
390 *
391 * Otherwise, calls @c rdbuf()->pubsync(), and if that returns -1,
392 * sets badbit.
393 */
394 __ostream_type&
395 flush();
396
397 /**
398 * @brief Getting the current write position.
399 * @return A file position object.
400 *
401 * If @c fail() is not false, returns @c pos_type(-1) to indicate
402 * failure. Otherwise returns @c rdbuf()->pubseekoff(0,cur,out).
403 */
404 pos_type
405 tellp();
406
407 /**
408 * @brief Changing the current write position.
409 * @param __pos A file position object.
410 * @return *this
411 *
412 * If @c fail() is not true, calls @c rdbuf()->pubseekpos(pos). If
413 * that function fails, sets failbit.
414 */
415 __ostream_type&
416 seekp(pos_type);
417
418 /**
419 * @brief Changing the current write position.
420 * @param __off A file offset object.
421 * @param __dir The direction in which to seek.
422 * @return *this
423 *
424 * If @c fail() is not true, calls @c rdbuf()->pubseekoff(off,dir).
425 * If that function fails, sets failbit.
426 */
427 __ostream_type&
428 seekp(off_type, ios_base::seekdir);
429
430 protected:
432 { this->init(0); }
433
434#if __cplusplus >= 201103L
435 // Non-standard constructor that does not call init()
436 basic_ostream(basic_iostream<_CharT, _Traits>&) { }
437
438 basic_ostream(const basic_ostream&) = delete;
439
440 basic_ostream(basic_ostream&& __rhs)
441 : __ios_type()
442 { __ios_type::move(__rhs); }
443
444 // 27.7.3.3 Assign/swap
445
446 basic_ostream& operator=(const basic_ostream&) = delete;
447
449 operator=(basic_ostream&& __rhs)
450 {
451 swap(__rhs);
452 return *this;
453 }
454
455 void
456 swap(basic_ostream& __rhs)
457 { __ios_type::swap(__rhs); }
458#endif
459
460 template<typename _ValueT>
461 __ostream_type&
462 _M_insert(_ValueT __v);
463
464 private:
465#if !_GLIBCXX_INLINE_VERSION
466 void
467 _M_write(const char_type* __s, streamsize __n)
468 { std::__ostream_insert(*this, __s, __n); }
469#endif
470 };
471
472 /**
473 * @brief Performs setup work for output streams.
474 *
475 * Objects of this class are created before all of the standard
476 * inserters are run. It is responsible for <em>exception-safe prefix and
477 * suffix operations</em>.
478 */
479 template <typename _CharT, typename _Traits>
480 class basic_ostream<_CharT, _Traits>::sentry
481 {
482 // Data Members.
483 bool _M_ok;
485
486 public:
487 /**
488 * @brief The constructor performs preparatory work.
489 * @param __os The output stream to guard.
490 *
491 * If the stream state is good (@a __os.good() is true), then if the
492 * stream is tied to another output stream, @c is.tie()->flush()
493 * is called to synchronize the output sequences.
494 *
495 * If the stream state is still good, then the sentry state becomes
496 * true (@a okay).
497 */
498 explicit
500
501#pragma GCC diagnostic push
502#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
503 /**
504 * @brief Possibly flushes the stream.
505 *
506 * If @c ios_base::unitbuf is set in @c os.flags(), and
507 * @c std::uncaught_exception() is true, the sentry destructor calls
508 * @c flush() on the output stream.
509 */
511 {
512 // XXX MT
513 if (bool(_M_os.flags() & ios_base::unitbuf) && !uncaught_exception())
514 {
515 // Can't call flush directly or else will get into recursive lock.
516 if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1)
518 }
519 }
520#pragma GCC diagnostic pop
521
522 /**
523 * @brief Quick status checking.
524 * @return The sentry state.
525 *
526 * For ease of use, sentries may be converted to booleans. The
527 * return value is that of the sentry state (true == okay).
528 */
529#if __cplusplus >= 201103L
530 explicit
531#endif
532 operator bool() const
533 { return _M_ok; }
534 };
535
536 ///@{
537 /**
538 * @brief Character inserters
539 * @param __out An output stream.
540 * @param __c A character.
541 * @return out
542 *
543 * Behaves like one of the formatted arithmetic inserters described in
544 * std::basic_ostream. After constructing a sentry object with good
545 * status, this function inserts a single character and any required
546 * padding (as determined by [22.2.2.2.2]). @c __out.width(0) is then
547 * called.
548 *
549 * If @p __c is of type @c char and the character type of the stream is not
550 * @c char, the character is widened before insertion.
551 */
552 template<typename _CharT, typename _Traits>
555 {
556 if (__out.width() != 0)
557 return __ostream_insert(__out, &__c, 1);
558 __out.put(__c);
559 return __out;
560 }
561
562 template<typename _CharT, typename _Traits>
563 inline basic_ostream<_CharT, _Traits>&
564 operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
565 { return (__out << __out.widen(__c)); }
566
567 // Specialization
568 template<typename _Traits>
569 inline basic_ostream<char, _Traits>&
570 operator<<(basic_ostream<char, _Traits>& __out, char __c)
571 {
572 if (__out.width() != 0)
573 return __ostream_insert(__out, &__c, 1);
574 __out.put(__c);
575 return __out;
576 }
577
578 // Signed and unsigned
579 template<typename _Traits>
580 inline basic_ostream<char, _Traits>&
581 operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
582 { return (__out << static_cast<char>(__c)); }
583
584 template<typename _Traits>
585 inline basic_ostream<char, _Traits>&
586 operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
587 { return (__out << static_cast<char>(__c)); }
588
589#if __cplusplus > 201703L
590 // The following deleted overloads prevent formatting character values as
591 // numeric values.
592
593 template<typename _Traits>
594 basic_ostream<char, _Traits>&
595 operator<<(basic_ostream<char, _Traits>&, wchar_t) = delete;
596
597#ifdef _GLIBCXX_USE_CHAR8_T
598 template<typename _Traits>
599 basic_ostream<char, _Traits>&
600 operator<<(basic_ostream<char, _Traits>&, char8_t) = delete;
601#endif
602
603 template<typename _Traits>
604 basic_ostream<char, _Traits>&
605 operator<<(basic_ostream<char, _Traits>&, char16_t) = delete;
606
607 template<typename _Traits>
608 basic_ostream<char, _Traits>&
609 operator<<(basic_ostream<char, _Traits>&, char32_t) = delete;
610
611#ifdef _GLIBCXX_USE_WCHAR_T
612#ifdef _GLIBCXX_USE_CHAR8_T
613 template<typename _Traits>
614 basic_ostream<wchar_t, _Traits>&
615 operator<<(basic_ostream<wchar_t, _Traits>&, char8_t) = delete;
616#endif // _GLIBCXX_USE_CHAR8_T
617
618 template<typename _Traits>
619 basic_ostream<wchar_t, _Traits>&
620 operator<<(basic_ostream<wchar_t, _Traits>&, char16_t) = delete;
621
622 template<typename _Traits>
623 basic_ostream<wchar_t, _Traits>&
624 operator<<(basic_ostream<wchar_t, _Traits>&, char32_t) = delete;
625#endif // _GLIBCXX_USE_WCHAR_T
626#endif // C++20
627 ///@}
628
629 ///@{
630 /**
631 * @brief String inserters
632 * @param __out An output stream.
633 * @param __s A character string.
634 * @return out
635 * @pre @p __s must be a non-NULL pointer
636 *
637 * Behaves like one of the formatted arithmetic inserters described in
638 * std::basic_ostream. After constructing a sentry object with good
639 * status, this function inserts @c traits::length(__s) characters starting
640 * at @p __s, widened if necessary, followed by any required padding (as
641 * determined by [22.2.2.2.2]). @c __out.width(0) is then called.
642 */
643 template<typename _CharT, typename _Traits>
644 inline basic_ostream<_CharT, _Traits>&
645 operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
646 {
647 if (!__s)
648 __out.setstate(ios_base::badbit);
649 else
650 __ostream_insert(__out, __s,
651 static_cast<streamsize>(_Traits::length(__s)));
652 return __out;
653 }
654
655 template<typename _CharT, typename _Traits>
656 basic_ostream<_CharT, _Traits> &
657 operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);
658
659 // Partial specializations
660 template<typename _Traits>
661 inline basic_ostream<char, _Traits>&
662 operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
663 {
664 if (!__s)
665 __out.setstate(ios_base::badbit);
666 else
667 __ostream_insert(__out, __s,
668 static_cast<streamsize>(_Traits::length(__s)));
669 return __out;
670 }
671
672 // Signed and unsigned
673 template<typename _Traits>
674 inline basic_ostream<char, _Traits>&
675 operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
676 { return (__out << reinterpret_cast<const char*>(__s)); }
677
678 template<typename _Traits>
679 inline basic_ostream<char, _Traits> &
680 operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
681 { return (__out << reinterpret_cast<const char*>(__s)); }
682
683#if __cplusplus > 201703L
684 // The following deleted overloads prevent formatting strings as
685 // pointer values.
686
687 template<typename _Traits>
688 basic_ostream<char, _Traits>&
689 operator<<(basic_ostream<char, _Traits>&, const wchar_t*) = delete;
690
691#ifdef _GLIBCXX_USE_CHAR8_T
692 template<typename _Traits>
693 basic_ostream<char, _Traits>&
694 operator<<(basic_ostream<char, _Traits>&, const char8_t*) = delete;
695#endif // _GLIBCXX_USE_CHAR8_T
696
697 template<typename _Traits>
698 basic_ostream<char, _Traits>&
699 operator<<(basic_ostream<char, _Traits>&, const char16_t*) = delete;
700
701 template<typename _Traits>
702 basic_ostream<char, _Traits>&
703 operator<<(basic_ostream<char, _Traits>&, const char32_t*) = delete;
704
705#ifdef _GLIBCXX_USE_WCHAR_T
706#ifdef _GLIBCXX_USE_CHAR8_T
707 template<typename _Traits>
708 basic_ostream<wchar_t, _Traits>&
709 operator<<(basic_ostream<wchar_t, _Traits>&, const char8_t*) = delete;
710#endif
711
712 template<typename _Traits>
713 basic_ostream<wchar_t, _Traits>&
714 operator<<(basic_ostream<wchar_t, _Traits>&, const char16_t*) = delete;
715
716 template<typename _Traits>
717 basic_ostream<wchar_t, _Traits>&
718 operator<<(basic_ostream<wchar_t, _Traits>&, const char32_t*) = delete;
719#endif // _GLIBCXX_USE_WCHAR_T
720#endif // C++20
721 ///@}
722
723 // Standard basic_ostream manipulators
724
725 /**
726 * @brief Write a newline and flush the stream.
727 *
728 * This manipulator is often mistakenly used when a simple newline is
729 * desired, leading to poor buffering performance. See
730 * https://gcc.gnu.org/onlinedocs/libstdc++/manual/streambufs.html#io.streambuf.buffering
731 * for more on this subject.
732 */
733 template<typename _CharT, typename _Traits>
734 inline basic_ostream<_CharT, _Traits>&
736 { return flush(__os.put(__os.widen('\n'))); }
737
738 /**
739 * @brief Write a null character into the output sequence.
740 *
741 * <em>Null character</em> is @c CharT() by definition. For CharT
742 * of @c char, this correctly writes the ASCII @c NUL character
743 * string terminator.
744 */
745 template<typename _CharT, typename _Traits>
746 inline basic_ostream<_CharT, _Traits>&
748 { return __os.put(_CharT()); }
749
750 /**
751 * @brief Flushes the output stream.
752 *
753 * This manipulator simply calls the stream's @c flush() member function.
754 */
755 template<typename _CharT, typename _Traits>
756 inline basic_ostream<_CharT, _Traits>&
758 { return __os.flush(); }
759
760#if __cplusplus >= 201103L
761 // C++11 27.7.3.9 Rvalue stream insertion [ostream.rvalue]
762 // _GLIBCXX_RESOLVE_LIB_DEFECTS
763 // 1203. More useful rvalue stream insertion
764
765#if __cpp_lib_concepts
766 // Use concepts if possible because they're cheaper to evaluate.
767 template<typename _Tp>
768 concept __derived_from_ios_base = is_class_v<_Tp>
769 && (!is_same_v<_Tp, ios_base>)
770 && requires (_Tp* __t, ios_base* __b) { __b = __t; };
771
772 template<typename _Os, typename _Tp>
773 requires __derived_from_ios_base<_Os>
774 && requires (_Os& __os, const _Tp& __t) { __os << __t; }
775 using __rvalue_stream_insertion_t = _Os&&;
776#else
777 template<typename _Tp>
778 using _Require_derived_from_ios_base
779 = _Require<is_class<_Tp>, __not_<is_same<_Tp, ios_base>>,
780 is_convertible<typename add_pointer<_Tp>::type, ios_base*>>;
781
782 template<typename _Os, typename _Tp,
783 typename = _Require_derived_from_ios_base<_Os>,
784 typename
785 = decltype(std::declval<_Os&>() << std::declval<const _Tp&>())>
786 using __rvalue_stream_insertion_t = _Os&&;
787#endif
788
789 /**
790 * @brief Generic inserter for rvalue stream
791 * @param __os An input stream.
792 * @param __x A reference to the object being inserted.
793 * @return __os
794 *
795 * This is just a forwarding function to allow insertion to
796 * rvalue streams since they won't bind to the inserter functions
797 * that take an lvalue reference.
798 */
799 template<typename _Ostream, typename _Tp>
800 inline __rvalue_stream_insertion_t<_Ostream, _Tp>
801 operator<<(_Ostream&& __os, const _Tp& __x)
802 {
803 __os << __x;
804 return std::move(__os);
805 }
806
807#if __cplusplus > 201703L && _GLIBCXX_USE_CXX11_ABI
808 template<typename _CharT, typename _Traits>
809 class __syncbuf_base : public basic_streambuf<_CharT, _Traits>
810 {
811 public:
812 static bool*
813 _S_get(basic_streambuf<_CharT, _Traits>* __buf [[maybe_unused]]) noexcept
814 {
815#if __cpp_rtti
816 if (auto __p = dynamic_cast<__syncbuf_base*>(__buf))
817 return &__p->_M_emit_on_sync;
818#endif
819 return nullptr;
820 }
821
822 protected:
823 __syncbuf_base(basic_streambuf<_CharT, _Traits>* __w = nullptr)
824 : _M_wrapped(__w)
825 { }
826
827 basic_streambuf<_CharT, _Traits>* _M_wrapped = nullptr;
828 bool _M_emit_on_sync = false;
829 bool _M_needs_sync = false;
830 };
831
832 template<typename _CharT, typename _Traits>
833 inline basic_ostream<_CharT, _Traits>&
834 emit_on_flush(basic_ostream<_CharT, _Traits>& __os)
835 {
836 if (bool* __flag = __syncbuf_base<_CharT, _Traits>::_S_get(__os.rdbuf()))
837 *__flag = true;
838 return __os;
839 }
840
841 template<typename _CharT, typename _Traits>
842 inline basic_ostream<_CharT, _Traits>&
843 noemit_on_flush(basic_ostream<_CharT, _Traits>& __os)
844 {
845 if (bool* __flag = __syncbuf_base<_CharT, _Traits>::_S_get(__os.rdbuf()))
846 *__flag = false;
847 return __os;
848 }
849
850 template<typename _CharT, typename _Traits>
851 inline basic_ostream<_CharT, _Traits>&
852 flush_emit(basic_ostream<_CharT, _Traits>& __os)
853 {
854 struct _Restore
855 {
856 ~_Restore() { *_M_flag = _M_prev; }
857
858 bool _M_prev = false;
859 bool* _M_flag = &_M_prev;
860 } __restore;
861
862 if (bool* __flag = __syncbuf_base<_CharT, _Traits>::_S_get(__os.rdbuf()))
863 {
864 __restore._M_prev = *__flag;
865 __restore._M_flag = __flag;
866 *__flag = true;
867 }
868
869 __os.flush();
870 return __os;
871 }
872
873#endif // C++20
874
875#endif // C++11
876
877_GLIBCXX_END_NAMESPACE_VERSION
878} // namespace std
879
880#include <bits/ostream.tcc>
881
882#endif /* _GLIBCXX_OSTREAM */
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
Definition: move.h:97
void swap(any &__x, any &__y) noexcept
Exchange the states of two any objects.
Definition: std/any:429
bool uncaught_exception() noexcept
ISO C++ entities toplevel namespace is std.
ptrdiff_t streamsize
Integral type for I/O operation counts and buffer sizes.
Definition: postypes.h:68
basic_ostream< _CharT, _Traits > & ends(basic_ostream< _CharT, _Traits > &__os)
Write a null character into the output sequence.
Definition: ostream:747
basic_ostream< _CharT, _Traits > & endl(basic_ostream< _CharT, _Traits > &__os)
Write a newline and flush the stream.
Definition: ostream:735
basic_ostream< _CharT, _Traits > & flush(basic_ostream< _CharT, _Traits > &__os)
Flushes the output stream.
Definition: ostream:757
std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const bitset< _Nb > &__x)
Global I/O operators for bitsets.
Definition: std/bitset:1683
Template class basic_ios, virtual base class for all stream classes.
Definition: basic_ios.h:68
void setstate(iostate __state)
Sets additional flags in the error state.
Definition: basic_ios.h:157
void init(basic_streambuf< _CharT, _Traits > *__sb)
All setup is performed here.
Definition: basic_ios.tcc:126
char_type widen(char __c) const
Widens characters.
Definition: basic_ios.h:449
basic_streambuf< _CharT, _Traits > * rdbuf() const
Accessing the underlying buffer.
Definition: basic_ios.h:321
The actual work of input and output (interface).
Definition: streambuf:125
Template class basic_ostream.
Definition: ostream:61
__ostream_type & write(const char_type *__s, streamsize __n)
Character string insertion.
Definition: ostream.tcc:188
pos_type tellp()
Getting the current write position.
Definition: ostream.tcc:257
__ostream_type & put(char_type __c)
Simple insertion.
Definition: ostream.tcc:154
basic_ostream(__streambuf_type *__sb)
Base constructor.
Definition: ostream:86
__ostream_type & flush()
Synchronizing the stream buffer.
Definition: ostream.tcc:222
__ostream_type & seekp(pos_type)
Changing the current write position.
Definition: ostream.tcc:269
virtual ~basic_ostream()
Base destructor.
Definition: ostream:95
__ostream_type & operator<<(__ostream_type &(*__pf)(__ostream_type &))
Interface for manipulators.
Definition: ostream:110
Performs setup work for output streams.
Definition: ostream:481
~sentry()
Possibly flushes the stream.
Definition: ostream:510
The base of the I/O class hierarchy.
Definition: ios_base.h:234
fmtflags flags() const
Access to format flags.
Definition: ios_base.h:662
static const fmtflags unitbuf
Flushes output after each output operation.
Definition: ios_base.h:394
static const iostate badbit
Indicates a loss of integrity in an input or output sequence (such as an irrecoverable read error fro...
Definition: ios_base.h:425
streamsize width() const
Flags access.
Definition: ios_base.h:755
_Ios_Seekdir seekdir
This is an enumerated type.
Definition: ios_base.h:492
Primary class template ctype facet.
Primary class template num_put.