API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jul 17th, 2023
70
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 27.42 KB | None | 0 0
raw download clone embed print report
  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.  
  43. namespace 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:
  71.       typedef basic_streambuf<_CharT, _Traits>      __streambuf_type;
  72.       typedef basic_ios<_CharT, _Traits>        __ios_type;
  73.       typedef basic_ostream<_CharT, _Traits>        __ostream_type;
  74.       typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
  75.                                 __num_put_type;
  76.       typedef ctype<_CharT>                 __ctype_type;
  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
  86.       basic_ostream(__streambuf_type* __sb)
  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
  95.       ~basic_ostream() { }
  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.       */
  109.       __ostream_type&
  110.       operator<<(__ostream_type& (*__pf)(__ostream_type&))
  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.  
  118.       __ostream_type&
  119.       operator<<(__ios_type& (*__pf)(__ios_type&))
  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.  
  128.       __ostream_type&
  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.       */
  167.       __ostream_type&
  168.       operator<<(long __n)
  169.       { return _M_insert(__n); }
  170.  
  171.       __ostream_type&
  172.       operator<<(unsigned long __n)
  173.       { return _M_insert(__n); }
  174.  
  175.       __ostream_type&
  176.       operator<<(bool __n)
  177.       { return _M_insert(__n); }
  178.  
  179.       __ostream_type&
  180.       operator<<(short __n);
  181.  
  182.       __ostream_type&
  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.  
  193.       __ostream_type&
  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
  202.       __ostream_type&
  203.       operator<<(long long __n)
  204.       { return _M_insert(__n); }
  205.  
  206.       __ostream_type&
  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.       */
  221.       __ostream_type&
  222.       operator<<(double __f)
  223.       { return _M_insert(__f); }
  224.  
  225.       __ostream_type&
  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.  
  233.       __ostream_type&
  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.       */
  291.       __ostream_type&
  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:
  431.       basic_ostream()
  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.  
  448.       basic_ostream&
  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;
  484.       basic_ostream<_CharT, _Traits>&   _M_os;
  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
  499.       sentry(basic_ostream<_CharT, _Traits>& __os);
  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.       */
  510.       ~sentry()
  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)
  517.           _M_os.setstate(ios_base::badbit);
  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>
  553.     inline basic_ostream<_CharT, _Traits>&
  554.     operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
  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>&
  735.     endl(basic_ostream<_CharT, _Traits>& __os)
  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>&
  747.     ends(basic_ostream<_CharT, _Traits>& __os)
  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>&
  757.     flush(basic_ostream<_CharT, _Traits>& __os)
  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 */
  883.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!