1    	// Output streams -*- C++ -*-
2    	
3    	// Copyright (C) 1997-2017 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 <ios>
39   	#include <bits/ostream_insert.h>
40   	
41   	namespace std _GLIBCXX_VISIBILITY(default)
42   	{
43   	_GLIBCXX_BEGIN_NAMESPACE_VERSION
44   	
45   	  /**
46   	   *  @brief  Template class basic_ostream.
47   	   *  @ingroup io
48   	   *
49   	   *  @tparam _CharT  Type of character stream.
50   	   *  @tparam _Traits  Traits for character type, defaults to
51   	   *                   char_traits<_CharT>.
52   	   *
53   	   *  This is the base class for all output streams.  It provides text
54   	   *  formatting of all builtin types, and communicates with any class
55   	   *  derived from basic_streambuf to do the actual output.
56   	  */
57   	  template<typename _CharT, typename _Traits>
58   	    class basic_ostream : virtual public basic_ios<_CharT, _Traits>
59   	    {
60   	    public:
61   	      // Types (inherited from basic_ios):
62   	      typedef _CharT			 		char_type;
63   	      typedef typename _Traits::int_type 		int_type;
64   	      typedef typename _Traits::pos_type 		pos_type;
65   	      typedef typename _Traits::off_type 		off_type;
66   	      typedef _Traits			 		traits_type;
67   	
68   	      // Non-standard Types:
69   	      typedef basic_streambuf<_CharT, _Traits> 		__streambuf_type;
70   	      typedef basic_ios<_CharT, _Traits>		__ios_type;
71   	      typedef basic_ostream<_CharT, _Traits>		__ostream_type;
72   	      typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
73   	      							__num_put_type;
74   	      typedef ctype<_CharT>	      			__ctype_type;
75   	
76   	      /**
77   	       *  @brief  Base constructor.
78   	       *
79   	       *  This ctor is almost never called by the user directly, rather from
80   	       *  derived classes' initialization lists, which pass a pointer to
81   	       *  their own stream buffer.
82   	      */
83   	      explicit
84   	      basic_ostream(__streambuf_type* __sb)
85   	      { this->init(__sb); }
86   	
87   	      /**
88   	       *  @brief  Base destructor.
89   	       *
90   	       *  This does very little apart from providing a virtual base dtor.
91   	      */
92   	      virtual
93   	      ~basic_ostream() { }
94   	
95   	      /// Safe prefix/suffix operations.
96   	      class sentry;
97   	      friend class sentry;
98   	
99   	      //@{
100  	      /**
101  	       *  @brief  Interface for manipulators.
102  	       *
103  	       *  Manipulators such as @c std::endl and @c std::hex use these
104  	       *  functions in constructs like "std::cout << std::endl".  For more
105  	       *  information, see the iomanip header.
106  	      */
107  	      __ostream_type&
108  	      operator<<(__ostream_type& (*__pf)(__ostream_type&))
109  	      {
110  		// _GLIBCXX_RESOLVE_LIB_DEFECTS
111  		// DR 60. What is a formatted input function?
112  		// The inserters for manipulators are *not* formatted output functions.
113  		return __pf(*this);
114  	      }
115  	
116  	      __ostream_type&
117  	      operator<<(__ios_type& (*__pf)(__ios_type&))
118  	      {
119  		// _GLIBCXX_RESOLVE_LIB_DEFECTS
120  		// DR 60. What is a formatted input function?
121  		// The inserters for manipulators are *not* formatted output functions.
122  		__pf(*this);
123  		return *this;
124  	      }
125  	
126  	      __ostream_type&
127  	      operator<<(ios_base& (*__pf) (ios_base&))
128  	      {
129  		// _GLIBCXX_RESOLVE_LIB_DEFECTS
130  		// DR 60. What is a formatted input function?
131  		// The inserters for manipulators are *not* formatted output functions.
132  		__pf(*this);
133  		return *this;
134  	      }
135  	      //@}
136  	
137  	      //@{
138  	      /**
139  	       *  @name Inserters
140  	       *
141  	       *  All the @c operator<< functions (aka <em>formatted output
142  	       *  functions</em>) have some common behavior.  Each starts by
143  	       *  constructing a temporary object of type std::basic_ostream::sentry.
144  	       *  This can have several effects, concluding with the setting of a
145  	       *  status flag; see the sentry documentation for more.
146  	       *
147  	       *  If the sentry status is good, the function tries to generate
148  	       *  whatever data is appropriate for the type of the argument.
149  	       *
150  	       *  If an exception is thrown during insertion, ios_base::badbit
151  	       *  will be turned on in the stream's error state without causing an
152  	       *  ios_base::failure to be thrown.  The original exception will then
153  	       *  be rethrown.
154  	      */
155  	
156  	      //@{
157  	      /**
158  	       *  @brief Integer arithmetic inserters
159  	       *  @param  __n A variable of builtin integral type.
160  	       *  @return  @c *this if successful
161  	       *
162  	       *  These functions use the stream's current locale (specifically, the
163  	       *  @c num_get facet) to perform numeric formatting.
164  	      */
165  	      __ostream_type&
166  	      operator<<(long __n)
167  	      { return _M_insert(__n); }
168  	
169  	      __ostream_type&
170  	      operator<<(unsigned long __n)
171  	      { return _M_insert(__n); }
172  	
173  	      __ostream_type&
174  	      operator<<(bool __n)
175  	      { return _M_insert(__n); }
176  	
177  	      __ostream_type&
178  	      operator<<(short __n);
179  	
180  	      __ostream_type&
181  	      operator<<(unsigned short __n)
182  	      {
183  		// _GLIBCXX_RESOLVE_LIB_DEFECTS
184  		// 117. basic_ostream uses nonexistent num_put member functions.
185  		return _M_insert(static_cast<unsigned long>(__n));
186  	      }
187  	
188  	      __ostream_type&
189  	      operator<<(int __n);
190  	
191  	      __ostream_type&
192  	      operator<<(unsigned int __n)
193  	      {
194  		// _GLIBCXX_RESOLVE_LIB_DEFECTS
195  		// 117. basic_ostream uses nonexistent num_put member functions.
196  		return _M_insert(static_cast<unsigned long>(__n));
197  	      }
198  	
199  	#ifdef _GLIBCXX_USE_LONG_LONG
200  	      __ostream_type&
201  	      operator<<(long long __n)
202  	      { return _M_insert(__n); }
203  	
204  	      __ostream_type&
205  	      operator<<(unsigned long long __n)
206  	      { return _M_insert(__n); }
207  	#endif
208  	      //@}
209  	
210  	      //@{
211  	      /**
212  	       *  @brief  Floating point arithmetic inserters
213  	       *  @param  __f A variable of builtin floating point type.
214  	       *  @return  @c *this if successful
215  	       *
216  	       *  These functions use the stream's current locale (specifically, the
217  	       *  @c num_get facet) to perform numeric formatting.
218  	      */
219  	      __ostream_type&
220  	      operator<<(double __f)
221  	      { return _M_insert(__f); }
222  	
223  	      __ostream_type&
224  	      operator<<(float __f)
225  	      {
226  		// _GLIBCXX_RESOLVE_LIB_DEFECTS
227  		// 117. basic_ostream uses nonexistent num_put member functions.
228  		return _M_insert(static_cast<double>(__f));
229  	      }
230  	
231  	      __ostream_type&
232  	      operator<<(long double __f)
233  	      { return _M_insert(__f); }
234  	      //@}
235  	
236  	      /**
237  	       *  @brief  Pointer arithmetic inserters
238  	       *  @param  __p A variable of pointer type.
239  	       *  @return  @c *this if successful
240  	       *
241  	       *  These functions use the stream's current locale (specifically, the
242  	       *  @c num_get facet) to perform numeric formatting.
243  	      */
244  	      __ostream_type&
245  	      operator<<(const void* __p)
246  	      { return _M_insert(__p); }
247  	
248  	      /**
249  	       *  @brief  Extracting from another streambuf.
250  	       *  @param  __sb  A pointer to a streambuf
251  	       *
252  	       *  This function behaves like one of the basic arithmetic extractors,
253  	       *  in that it also constructs a sentry object and has the same error
254  	       *  handling behavior.
255  	       *
256  	       *  If @p __sb is NULL, the stream will set failbit in its error state.
257  	       *
258  	       *  Characters are extracted from @p __sb and inserted into @c *this
259  	       *  until one of the following occurs:
260  	       *
261  	       *  - the input stream reaches end-of-file,
262  	       *  - insertion into the output sequence fails (in this case, the
263  	       *    character that would have been inserted is not extracted), or
264  	       *  - an exception occurs while getting a character from @p __sb, which
265  	       *    sets failbit in the error state
266  	       *
267  	       *  If the function inserts no characters, failbit is set.
268  	      */
269  	      __ostream_type&
270  	      operator<<(__streambuf_type* __sb);
271  	      //@}
272  	
273  	      //@{
274  	      /**
275  	       *  @name Unformatted Output Functions
276  	       *
277  	       *  All the unformatted output functions have some common behavior.
278  	       *  Each starts by constructing a temporary object of type
279  	       *  std::basic_ostream::sentry.  This has several effects, concluding
280  	       *  with the setting of a status flag; see the sentry documentation
281  	       *  for more.
282  	       *
283  	       *  If the sentry status is good, the function tries to generate
284  	       *  whatever data is appropriate for the type of the argument.
285  	       *
286  	       *  If an exception is thrown during insertion, ios_base::badbit
287  	       *  will be turned on in the stream's error state.  If badbit is on in
288  	       *  the stream's exceptions mask, the exception will be rethrown
289  	       *  without completing its actions.
290  	      */
291  	
292  	      /**
293  	       *  @brief  Simple insertion.
294  	       *  @param  __c  The character to insert.
295  	       *  @return  *this
296  	       *
297  	       *  Tries to insert @p __c.
298  	       *
299  	       *  @note  This function is not overloaded on signed char and
300  	       *         unsigned char.
301  	      */
302  	      __ostream_type&
303  	      put(char_type __c);
304  	
305  	      /**
306  	       *  @brief  Core write functionality, without sentry.
307  	       *  @param  __s  The array to insert.
308  	       *  @param  __n  Maximum number of characters to insert.
309  	      */
310  	      void
311  	      _M_write(const char_type* __s, streamsize __n)
312  	      {
313  		const streamsize __put = this->rdbuf()->sputn(__s, __n);
314  		if (__put != __n)
315  		  this->setstate(ios_base::badbit);
316  	      }
317  	
318  	      /**
319  	       *  @brief  Character string insertion.
320  	       *  @param  __s  The array to insert.
321  	       *  @param  __n  Maximum number of characters to insert.
322  	       *  @return  *this
323  	       *
324  	       *  Characters are copied from @p __s and inserted into the stream until
325  	       *  one of the following happens:
326  	       *
327  	       *  - @p __n characters are inserted
328  	       *  - inserting into the output sequence fails (in this case, badbit
329  	       *    will be set in the stream's error state)
330  	       *
331  	       *  @note  This function is not overloaded on signed char and
332  	       *         unsigned char.
333  	      */
334  	      __ostream_type&
335  	      write(const char_type* __s, streamsize __n);
336  	      //@}
337  	
338  	      /**
339  	       *  @brief  Synchronizing the stream buffer.
340  	       *  @return  *this
341  	       *
342  	       *  If @c rdbuf() is a null pointer, changes nothing.
343  	       *
344  	       *  Otherwise, calls @c rdbuf()->pubsync(), and if that returns -1,
345  	       *  sets badbit.
346  	      */
347  	      __ostream_type&
348  	      flush();
349  	
350  	      /**
351  	       *  @brief  Getting the current write position.
352  	       *  @return  A file position object.
353  	       *
354  	       *  If @c fail() is not false, returns @c pos_type(-1) to indicate
355  	       *  failure.  Otherwise returns @c rdbuf()->pubseekoff(0,cur,out).
356  	      */
357  	      pos_type
358  	      tellp();
359  	
360  	      /**
361  	       *  @brief  Changing the current write position.
362  	       *  @param  __pos  A file position object.
363  	       *  @return  *this
364  	       *
365  	       *  If @c fail() is not true, calls @c rdbuf()->pubseekpos(pos).  If
366  	       *  that function fails, sets failbit.
367  	      */
368  	      __ostream_type&
369  	      seekp(pos_type);
370  	
371  	      /**
372  	       *  @brief  Changing the current write position.
373  	       *  @param  __off  A file offset object.
374  	       *  @param  __dir  The direction in which to seek.
375  	       *  @return  *this
376  	       *
377  	       *  If @c fail() is not true, calls @c rdbuf()->pubseekoff(off,dir).
378  	       *  If that function fails, sets failbit.
379  	      */
380  	       __ostream_type&
381  	      seekp(off_type, ios_base::seekdir);
382  	
383  	    protected:
384  	      basic_ostream()
385  	      { this->init(0); }
386  	
387  	#if __cplusplus >= 201103L
388  	      // Non-standard constructor that does not call init()
389  	      basic_ostream(basic_iostream<_CharT, _Traits>&) { }
390  	
391  	      basic_ostream(const basic_ostream&) = delete;
392  	
393  	      basic_ostream(basic_ostream&& __rhs)
394  	      : __ios_type()
395  	      { __ios_type::move(__rhs); }
396  	
397  	      // 27.7.3.3 Assign/swap
398  	
399  	      basic_ostream& operator=(const basic_ostream&) = delete;
400  	
401  	      basic_ostream&
402  	      operator=(basic_ostream&& __rhs)
403  	      {
404  		swap(__rhs);
405  		return *this;
406  	      }
407  	
408  	      void
409  	      swap(basic_ostream& __rhs)
410  	      { __ios_type::swap(__rhs); }
411  	#endif
412  	
413  	      template<typename _ValueT>
414  		__ostream_type&
415  		_M_insert(_ValueT __v);
416  	    };
417  	
418  	  /**
419  	   *  @brief  Performs setup work for output streams.
420  	   *
421  	   *  Objects of this class are created before all of the standard
422  	   *  inserters are run.  It is responsible for <em>exception-safe prefix and
423  	   *  suffix operations</em>.
424  	  */
425  	  template <typename _CharT, typename _Traits>
426  	    class basic_ostream<_CharT, _Traits>::sentry
427  	    {
428  	      // Data Members.
429  	      bool 				_M_ok;
430  	      basic_ostream<_CharT, _Traits>& 	_M_os;
431  	
432  	    public:
433  	      /**
434  	       *  @brief  The constructor performs preparatory work.
435  	       *  @param  __os  The output stream to guard.
436  	       *
437  	       *  If the stream state is good (@a __os.good() is true), then if the
438  	       *  stream is tied to another output stream, @c is.tie()->flush()
439  	       *  is called to synchronize the output sequences.
440  	       *
441  	       *  If the stream state is still good, then the sentry state becomes
442  	       *  true (@a okay).
443  	      */
444  	      explicit
445  	      sentry(basic_ostream<_CharT, _Traits>& __os);
446  	
447  	      /**
448  	       *  @brief  Possibly flushes the stream.
449  	       *
450  	       *  If @c ios_base::unitbuf is set in @c os.flags(), and
451  	       *  @c std::uncaught_exception() is true, the sentry destructor calls
452  	       *  @c flush() on the output stream.
453  	      */
454  	      ~sentry()
455  	      {
456  		// XXX MT
457  		if (bool(_M_os.flags() & ios_base::unitbuf) && !uncaught_exception())
458  		  {
459  		    // Can't call flush directly or else will get into recursive lock.
460  		    if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1)
461  		      _M_os.setstate(ios_base::badbit);
462  		  }
463  	      }
464  	
465  	      /**
466  	       *  @brief  Quick status checking.
467  	       *  @return  The sentry state.
468  	       *
469  	       *  For ease of use, sentries may be converted to booleans.  The
470  	       *  return value is that of the sentry state (true == okay).
471  	      */
472  	#if __cplusplus >= 201103L
473  	      explicit
474  	#endif
475  	      operator bool() const
476  	      { return _M_ok; }
477  	    };
478  	
479  	  //@{
480  	  /**
481  	   *  @brief  Character inserters
482  	   *  @param  __out  An output stream.
483  	   *  @param  __c  A character.
484  	   *  @return  out
485  	   *
486  	   *  Behaves like one of the formatted arithmetic inserters described in
487  	   *  std::basic_ostream.  After constructing a sentry object with good
488  	   *  status, this function inserts a single character and any required
489  	   *  padding (as determined by [22.2.2.2.2]).  @c __out.width(0) is then
490  	   *  called.
491  	   *
492  	   *  If @p __c is of type @c char and the character type of the stream is not
493  	   *  @c char, the character is widened before insertion.
494  	  */
495  	  template<typename _CharT, typename _Traits>
496  	    inline basic_ostream<_CharT, _Traits>&
497  	    operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
498  	    { return __ostream_insert(__out, &__c, 1); }
499  	
500  	  template<typename _CharT, typename _Traits>
501  	    inline basic_ostream<_CharT, _Traits>&
502  	    operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
503  	    { return (__out << __out.widen(__c)); }
504  	
505  	  // Specialization
506  	  template <class _Traits>
507  	    inline basic_ostream<char, _Traits>&
508  	    operator<<(basic_ostream<char, _Traits>& __out, char __c)
509  	    { return __ostream_insert(__out, &__c, 1); }
510  	
511  	  // Signed and unsigned
512  	  template<class _Traits>
513  	    inline basic_ostream<char, _Traits>&
514  	    operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
515  	    { return (__out << static_cast<char>(__c)); }
516  	
517  	  template<class _Traits>
518  	    inline basic_ostream<char, _Traits>&
519  	    operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
520  	    { return (__out << static_cast<char>(__c)); }
521  	  //@}
522  	
523  	  //@{
524  	  /**
525  	   *  @brief  String inserters
526  	   *  @param  __out  An output stream.
527  	   *  @param  __s  A character string.
528  	   *  @return  out
529  	   *  @pre  @p __s must be a non-NULL pointer
530  	   *
531  	   *  Behaves like one of the formatted arithmetic inserters described in
532  	   *  std::basic_ostream.  After constructing a sentry object with good
533  	   *  status, this function inserts @c traits::length(__s) characters starting
534  	   *  at @p __s, widened if necessary, followed by any required padding (as
535  	   *  determined by [22.2.2.2.2]).  @c __out.width(0) is then called.
536  	  */
537  	  template<typename _CharT, typename _Traits>
538  	    inline basic_ostream<_CharT, _Traits>&
539  	    operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
540  	    {
541  	      if (!__s)
542  		__out.setstate(ios_base::badbit);
543  	      else
544  		__ostream_insert(__out, __s,
545  				 static_cast<streamsize>(_Traits::length(__s)));
546  	      return __out;
547  	    }
548  	
549  	  template<typename _CharT, typename _Traits>
550  	    basic_ostream<_CharT, _Traits> &
551  	    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);
552  	
553  	  // Partial specializations
554  	  template<class _Traits>
555  	    inline basic_ostream<char, _Traits>&
556  	    operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
557  	    {
558  	      if (!__s)
559  		__out.setstate(ios_base::badbit);
560  	      else
561  		__ostream_insert(__out, __s,
562  				 static_cast<streamsize>(_Traits::length(__s)));
563  	      return __out;
564  	    }
565  	
566  	  // Signed and unsigned
567  	  template<class _Traits>
568  	    inline basic_ostream<char, _Traits>&
569  	    operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
570  	    { return (__out << reinterpret_cast<const char*>(__s)); }
571  	
572  	  template<class _Traits>
573  	    inline basic_ostream<char, _Traits> &
574  	    operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
575  	    { return (__out << reinterpret_cast<const char*>(__s)); }
576  	  //@}
577  	
578  	  // Standard basic_ostream manipulators
579  	
580  	  /**
581  	   *  @brief  Write a newline and flush the stream.
582  	   *
583  	   *  This manipulator is often mistakenly used when a simple newline is
584  	   *  desired, leading to poor buffering performance.  See
585  	   *  https://gcc.gnu.org/onlinedocs/libstdc++/manual/streambufs.html#io.streambuf.buffering
586  	   *  for more on this subject.
587  	  */
588  	  template<typename _CharT, typename _Traits>
589  	    inline basic_ostream<_CharT, _Traits>&
590  	    endl(basic_ostream<_CharT, _Traits>& __os)
591  	    { return flush(__os.put(__os.widen('\n'))); }
592  	
593  	  /**
594  	   *  @brief  Write a null character into the output sequence.
595  	   *
596  	   *  <em>Null character</em> is @c CharT() by definition.  For CharT
597  	   *  of @c char, this correctly writes the ASCII @c NUL character
598  	   *  string terminator.
599  	  */
600  	  template<typename _CharT, typename _Traits>
601  	    inline basic_ostream<_CharT, _Traits>&
602  	    ends(basic_ostream<_CharT, _Traits>& __os)
603  	    { return __os.put(_CharT()); }
604  	
605  	  /**
606  	   *  @brief  Flushes the output stream.
607  	   *
608  	   *  This manipulator simply calls the stream's @c flush() member function.
609  	  */
610  	  template<typename _CharT, typename _Traits>
611  	    inline basic_ostream<_CharT, _Traits>&
612  	    flush(basic_ostream<_CharT, _Traits>& __os)
613  	    { return __os.flush(); }
614  	
615  	#if __cplusplus >= 201103L
616  	  template<typename _Ch, typename _Up>
617  	    basic_ostream<_Ch, _Up>&
618  	    __is_convertible_to_basic_ostream_test(basic_ostream<_Ch, _Up>*);
619  	
620  	  template<typename _Tp, typename = void>
621  	    struct __is_convertible_to_basic_ostream_impl
622  	    {
623  	      using __ostream_type = void;
624  	    };
625  	
626  	  template<typename _Tp>
627  	    using __do_is_convertible_to_basic_ostream_impl =
628  	    decltype(__is_convertible_to_basic_ostream_test
629  		     (declval<typename remove_reference<_Tp>::type*>()));
630  	
631  	  template<typename _Tp>
632  	    struct __is_convertible_to_basic_ostream_impl
633  	    <_Tp,
634  	     __void_t<__do_is_convertible_to_basic_ostream_impl<_Tp>>>
635  	    {
636  	      using __ostream_type =
637  		__do_is_convertible_to_basic_ostream_impl<_Tp>;
638  	    };
639  	
640  	  template<typename _Tp>
641  	    struct __is_convertible_to_basic_ostream
642  	    : __is_convertible_to_basic_ostream_impl<_Tp>
643  	    {
644  	    public:
645  	      using type = __not_<is_void<
646  	        typename __is_convertible_to_basic_ostream_impl<_Tp>::__ostream_type>>;
647  	      constexpr static bool value = type::value;
648  	    };
649  	
650  	  template<typename _Ostream, typename _Tp, typename = void>
651  	    struct __is_insertable : false_type {};
652  	
653  	  template<typename _Ostream, typename _Tp>
654  	    struct __is_insertable<_Ostream, _Tp,
655  				   __void_t<decltype(declval<_Ostream&>()
656  						     << declval<const _Tp&>())>>
657  					    : true_type {};
658  	
659  	  template<typename _Ostream>
660  	    using __rvalue_ostream_type =
661  	      typename __is_convertible_to_basic_ostream<
662  		_Ostream>::__ostream_type;
663  	
664  	  /**
665  	   *  @brief  Generic inserter for rvalue stream
666  	   *  @param  __os  An input stream.
667  	   *  @param  __x  A reference to the object being inserted.
668  	   *  @return  os
669  	   *
670  	   *  This is just a forwarding function to allow insertion to
671  	   *  rvalue streams since they won't bind to the inserter functions
672  	   *  that take an lvalue reference.
673  	  */
674  	  template<typename _Ostream, typename _Tp>
675  	    inline
676  	    typename enable_if<__and_<__not_<is_lvalue_reference<_Ostream>>,
677  				      __is_convertible_to_basic_ostream<_Ostream>,
678  				      __is_insertable<
679  					__rvalue_ostream_type<_Ostream>,
680  					const _Tp&>>::value,
681  			       __rvalue_ostream_type<_Ostream>>::type
682  	    operator<<(_Ostream&& __os, const _Tp& __x)
683  	    {
684  	      __rvalue_ostream_type<_Ostream> __ret_os = __os;
685  	      __ret_os << __x;
686  	      return __ret_os;
687  	    }
688  	#endif // C++11
689  	
690  	_GLIBCXX_END_NAMESPACE_VERSION
691  	} // namespace std
692  	
693  	#include <bits/ostream.tcc>
694  	
695  	#endif	/* _GLIBCXX_OSTREAM */
696