1    	// String based 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/sstream
26   	 *  This is a Standard C++ Library header.
27   	 */
28   	
29   	//
30   	// ISO C++ 14882: 27.7  String-based streams
31   	//
32   	
33   	#ifndef _GLIBCXX_SSTREAM
34   	#define _GLIBCXX_SSTREAM 1
35   	
36   	#pragma GCC system_header
37   	
38   	#include <istream>
39   	#include <ostream>
40   	
41   	namespace std _GLIBCXX_VISIBILITY(default)
42   	{
43   	_GLIBCXX_BEGIN_NAMESPACE_VERSION
44   	_GLIBCXX_BEGIN_NAMESPACE_CXX11
45   	
46   	  // [27.7.1] template class basic_stringbuf
47   	  /**
48   	   *  @brief  The actual work of input and output (for std::string).
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   	   *  @tparam _Alloc  Allocator type, defaults to allocator<_CharT>.
55   	   *
56   	   *  This class associates either or both of its input and output sequences
57   	   *  with a sequence of characters, which can be initialized from, or made
58   	   *  available as, a @c std::basic_string.  (Paraphrased from [27.7.1]/1.)
59   	   *
60   	   *  For this class, open modes (of type @c ios_base::openmode) have
61   	   *  @c in set if the input sequence can be read, and @c out set if the
62   	   *  output sequence can be written.
63   	  */
64   	  template<typename _CharT, typename _Traits, typename _Alloc>
65   	    class basic_stringbuf : public basic_streambuf<_CharT, _Traits>
66   	    {
67   	      struct __xfer_bufptrs;
68   	    public:
69   	      // Types:
70   	      typedef _CharT 					char_type;
71   	      typedef _Traits 					traits_type;
72   	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
73   	      // 251. basic_stringbuf missing allocator_type
74   	      typedef _Alloc				       	allocator_type;
75   	      typedef typename traits_type::int_type 		int_type;
76   	      typedef typename traits_type::pos_type 		pos_type;
77   	      typedef typename traits_type::off_type 		off_type;
78   	
79   	      typedef basic_streambuf<char_type, traits_type>  	__streambuf_type;
80   	      typedef basic_string<char_type, _Traits, _Alloc> 	__string_type;
81   	      typedef typename __string_type::size_type		__size_type;
82   	
83   	    protected:
84   	      /// Place to stash in || out || in | out settings for current stringbuf.
85   	      ios_base::openmode 	_M_mode;
86   	
87   	      // Data Members:
88   	      __string_type 		_M_string;
89   	
90   	    public:
91   	      // Constructors:
92   	      /**
93   	       *  @brief  Starts with an empty string buffer.
94   	       *  @param  __mode  Whether the buffer can read, or write, or both.
95   	       *
96   	       *  The default constructor initializes the parent class using its
97   	       *  own default ctor.
98   	      */
99   	      explicit
100  	      basic_stringbuf(ios_base::openmode __mode = ios_base::in | ios_base::out)
101  	      : __streambuf_type(), _M_mode(__mode), _M_string()
102  	      { }
103  	
104  	      /**
105  	       *  @brief  Starts with an existing string buffer.
106  	       *  @param  __str  A string to copy as a starting buffer.
107  	       *  @param  __mode  Whether the buffer can read, or write, or both.
108  	       *
109  	       *  This constructor initializes the parent class using its
110  	       *  own default ctor.
111  	      */
112  	      explicit
113  	      basic_stringbuf(const __string_type& __str,
114  			      ios_base::openmode __mode = ios_base::in | ios_base::out)
115  	      : __streambuf_type(), _M_mode(), _M_string(__str.data(), __str.size())
116  	      { _M_stringbuf_init(__mode); }
117  	
118  	#if __cplusplus >= 201103L
119  	      basic_stringbuf(const basic_stringbuf&) = delete;
120  	
121  	      basic_stringbuf(basic_stringbuf&& __rhs)
122  	      : basic_stringbuf(std::move(__rhs), __xfer_bufptrs(__rhs, this))
123  	      { __rhs._M_sync(const_cast<char_type*>(__rhs._M_string.data()), 0, 0); }
124  	
125  	      // 27.8.2.2 Assign and swap:
126  	
127  	      basic_stringbuf&
128  	      operator=(const basic_stringbuf&) = delete;
129  	
130  	      basic_stringbuf&
131  	      operator=(basic_stringbuf&& __rhs)
132  	      {
133  		__xfer_bufptrs __st{__rhs, this};
134  		const __streambuf_type& __base = __rhs;
135  		__streambuf_type::operator=(__base);
136  		this->pubimbue(__rhs.getloc());
137  		_M_mode = __rhs._M_mode;
138  		_M_string = std::move(__rhs._M_string);
139  		__rhs._M_sync(const_cast<char_type*>(__rhs._M_string.data()), 0, 0);
140  		return *this;
141  	      }
142  	
143  	      void
144  	      swap(basic_stringbuf& __rhs)
145  	      {
146  		__xfer_bufptrs __l_st{*this, std::__addressof(__rhs)};
147  		__xfer_bufptrs __r_st{__rhs, this};
148  		__streambuf_type& __base = __rhs;
149  		__streambuf_type::swap(__base);
150  		__rhs.pubimbue(this->pubimbue(__rhs.getloc()));
151  		std::swap(_M_mode, __rhs._M_mode);
152  		std::swap(_M_string, __rhs._M_string);
153  	      }
154  	#endif
155  	
156  	      // Get and set:
157  	      /**
158  	       *  @brief  Copying out the string buffer.
159  	       *  @return  A copy of one of the underlying sequences.
160  	       *
161  	       *  <em>If the buffer is only created in input mode, the underlying
162  	       *  character sequence is equal to the input sequence; otherwise, it
163  	       *  is equal to the output sequence.</em> [27.7.1.2]/1
164  	      */
165  	      __string_type
166  	      str() const
167  	      {
168  		__string_type __ret;
169  		if (this->pptr())
170  		  {
171  		    // The current egptr() may not be the actual string end.
172  		    if (this->pptr() > this->egptr())
173  		      __ret = __string_type(this->pbase(), this->pptr());
174  		    else
175  	 	      __ret = __string_type(this->pbase(), this->egptr());
176  		  }
177  		else
178  		  __ret = _M_string;
179  		return __ret;
180  	      }
181  	
182  	      /**
183  	       *  @brief  Setting a new buffer.
184  	       *  @param  __s  The string to use as a new sequence.
185  	       *
186  	       *  Deallocates any previous stored sequence, then copies @a s to
187  	       *  use as a new one.
188  	      */
189  	      void
190  	      str(const __string_type& __s)
191  	      {
192  		// Cannot use _M_string = __s, since v3 strings are COW
193  		// (not always true now but assign() always works).
194  		_M_string.assign(__s.data(), __s.size());
195  		_M_stringbuf_init(_M_mode);
196  	      }
197  	
198  	    protected:
199  	      // Common initialization code goes here.
200  	      void
201  	      _M_stringbuf_init(ios_base::openmode __mode)
202  	      {
203  		_M_mode = __mode;
204  		__size_type __len = 0;
205  		if (_M_mode & (ios_base::ate | ios_base::app))
206  		  __len = _M_string.size();
207  		_M_sync(const_cast<char_type*>(_M_string.data()), 0, __len);
208  	      }
209  	
210  	      virtual streamsize
211  	      showmanyc()
212  	      {
213  		streamsize __ret = -1;
214  		if (_M_mode & ios_base::in)
215  		  {
216  		    _M_update_egptr();
217  		    __ret = this->egptr() - this->gptr();
218  		  }
219  		return __ret;
220  	      }
221  	
222  	      virtual int_type
223  	      underflow();
224  	
225  	      virtual int_type
226  	      pbackfail(int_type __c = traits_type::eof());
227  	
228  	      virtual int_type
229  	      overflow(int_type __c = traits_type::eof());
230  	
231  	      /**
232  	       *  @brief  Manipulates the buffer.
233  	       *  @param  __s  Pointer to a buffer area.
234  	       *  @param  __n  Size of @a __s.
235  	       *  @return  @c this
236  	       *
237  	       *  If no buffer has already been created, and both @a __s and @a __n are
238  	       *  non-zero, then @c __s is used as a buffer; see
239  	       *  https://gcc.gnu.org/onlinedocs/libstdc++/manual/streambufs.html#io.streambuf.buffering
240  	       *  for more.
241  	      */
242  	      virtual __streambuf_type*
243  	      setbuf(char_type* __s, streamsize __n)
244  	      {
245  		if (__s && __n >= 0)
246  		  {
247  		    // This is implementation-defined behavior, and assumes
248  		    // that an external char_type array of length __n exists
249  		    // and has been pre-allocated. If this is not the case,
250  		    // things will quickly blow up.
251  	
252  		    // Step 1: Destroy the current internal array.
253  		    _M_string.clear();
254  	
255  		    // Step 2: Use the external array.
256  		    _M_sync(__s, __n, 0);
257  		  }
258  		return this;
259  	      }
260  	
261  	      virtual pos_type
262  	      seekoff(off_type __off, ios_base::seekdir __way,
263  		      ios_base::openmode __mode = ios_base::in | ios_base::out);
264  	
265  	      virtual pos_type
266  	      seekpos(pos_type __sp,
267  		      ios_base::openmode __mode = ios_base::in | ios_base::out);
268  	
269  	      // Internal function for correctly updating the internal buffer
270  	      // for a particular _M_string, due to initialization or re-sizing
271  	      // of an existing _M_string.
272  	      void
273  	      _M_sync(char_type* __base, __size_type __i, __size_type __o);
274  	
275  	      // Internal function for correctly updating egptr() to the actual
276  	      // string end.
277  	      void
278  	      _M_update_egptr()
279  	      {
280  		const bool __testin = _M_mode & ios_base::in;
281  		if (this->pptr() && this->pptr() > this->egptr())
282  		  {
283  		    if (__testin)
284  		      this->setg(this->eback(), this->gptr(), this->pptr());
285  		    else
286  		      this->setg(this->pptr(), this->pptr(), this->pptr());
287  		  }
288  	      }
289  	
290  	      // Works around the issue with pbump, part of the protected
291  	      // interface of basic_streambuf, taking just an int.
292  	      void
293  	      _M_pbump(char_type* __pbeg, char_type* __pend, off_type __off);
294  	
295  	    private:
296  	#if __cplusplus >= 201103L
297  	#if _GLIBCXX_USE_CXX11_ABI
298  	      // This type captures the state of the gptr / pptr pointers as offsets
299  	      // so they can be restored in another object after moving the string.
300  	      struct __xfer_bufptrs
301  	      {
302  		__xfer_bufptrs(const basic_stringbuf& __from, basic_stringbuf* __to)
303  		: _M_to{__to}, _M_goff{-1, -1, -1}, _M_poff{-1, -1, -1}
304  		{
305  		  const _CharT* const __str = __from._M_string.data();
306  		  const _CharT* __end = nullptr;
307  		  if (__from.eback())
308  		    {
309  		      _M_goff[0] = __from.eback() - __str;
310  		      _M_goff[1] = __from.gptr() - __str;
311  		      _M_goff[2] = __from.egptr() - __str;
312  		      __end = __from.egptr();
313  		    }
314  		  if (__from.pbase())
315  		    {
316  		      _M_poff[0] = __from.pbase() - __str;
317  		      _M_poff[1] = __from.pptr() - __from.pbase();
318  		      _M_poff[2] = __from.epptr() - __str;
319  		      if (__from.pptr() > __end)
320  			__end = __from.pptr();
321  		    }
322  	
323  		  // Set _M_string length to the greater of the get and put areas.
324  		  if (__end)
325  		    {
326  		      // The const_cast avoids changing this constructor's signature,
327  		      // because it is exported from the dynamic library.
328  		      auto& __mut_from = const_cast<basic_stringbuf&>(__from);
329  		      __mut_from._M_string._M_length(__end - __str);
330  		    }
331  		}
332  	
333  		~__xfer_bufptrs()
334  		{
335  		  char_type* __str = const_cast<char_type*>(_M_to->_M_string.data());
336  		  if (_M_goff[0] != -1)
337  		    _M_to->setg(__str+_M_goff[0], __str+_M_goff[1], __str+_M_goff[2]);
338  		  if (_M_poff[0] != -1)
339  		    _M_to->_M_pbump(__str+_M_poff[0], __str+_M_poff[2], _M_poff[1]);
340  		}
341  	
342  		basic_stringbuf* _M_to;
343  		off_type _M_goff[3];
344  		off_type _M_poff[3];
345  	      };
346  	#else
347  	      // This type does nothing when using Copy-On-Write strings.
348  	      struct __xfer_bufptrs
349  	      {
350  		__xfer_bufptrs(const basic_stringbuf&, basic_stringbuf*) { }
351  	      };
352  	#endif
353  	
354  	      // The move constructor initializes an __xfer_bufptrs temporary then
355  	      // delegates to this constructor to performs moves during its lifetime.
356  	      basic_stringbuf(basic_stringbuf&& __rhs, __xfer_bufptrs&&)
357  	      : __streambuf_type(static_cast<const __streambuf_type&>(__rhs)),
358  	      _M_mode(__rhs._M_mode), _M_string(std::move(__rhs._M_string))
359  	      { }
360  	#endif
361  	    };
362  	
363  	
364  	  // [27.7.2] Template class basic_istringstream
365  	  /**
366  	   *  @brief  Controlling input for std::string.
367  	   *  @ingroup io
368  	   *
369  	   *  @tparam _CharT  Type of character stream.
370  	   *  @tparam _Traits  Traits for character type, defaults to
371  	   *                   char_traits<_CharT>.
372  	   *  @tparam _Alloc  Allocator type, defaults to allocator<_CharT>.
373  	   *
374  	   *  This class supports reading from objects of type std::basic_string,
375  	   *  using the inherited functions from std::basic_istream.  To control
376  	   *  the associated sequence, an instance of std::basic_stringbuf is used,
377  	   *  which this page refers to as @c sb.
378  	  */
379  	  template<typename _CharT, typename _Traits, typename _Alloc>
380  	    class basic_istringstream : public basic_istream<_CharT, _Traits>
381  	    {
382  	    public:
383  	      // Types:
384  	      typedef _CharT 					char_type;
385  	      typedef _Traits 					traits_type;
386  	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
387  	      // 251. basic_stringbuf missing allocator_type
388  	      typedef _Alloc				       	allocator_type;
389  	      typedef typename traits_type::int_type 		int_type;
390  	      typedef typename traits_type::pos_type 		pos_type;
391  	      typedef typename traits_type::off_type 		off_type;
392  	
393  	      // Non-standard types:
394  	      typedef basic_string<_CharT, _Traits, _Alloc> 	__string_type;
395  	      typedef basic_stringbuf<_CharT, _Traits, _Alloc> 	__stringbuf_type;
396  	      typedef basic_istream<char_type, traits_type>	__istream_type;
397  	
398  	    private:
399  	      __stringbuf_type	_M_stringbuf;
400  	
401  	    public:
402  	      // Constructors:
403  	      /**
404  	       *  @brief  Default constructor starts with an empty string buffer.
405  	       *  @param  __mode  Whether the buffer can read, or write, or both.
406  	       *
407  	       *  @c ios_base::in is automatically included in @a __mode.
408  	       *
409  	       *  Initializes @c sb using @c __mode|in, and passes @c &sb to the base
410  	       *  class initializer.  Does not allocate any buffer.
411  	       *
412  	       *  That's a lie.  We initialize the base class with NULL, because the
413  	       *  string class does its own memory management.
414  	      */
415  	      explicit
416  	      basic_istringstream(ios_base::openmode __mode = ios_base::in)
417  	      : __istream_type(), _M_stringbuf(__mode | ios_base::in)
418  	      { this->init(&_M_stringbuf); }
419  	
420  	      /**
421  	       *  @brief  Starts with an existing string buffer.
422  	       *  @param  __str  A string to copy as a starting buffer.
423  	       *  @param  __mode  Whether the buffer can read, or write, or both.
424  	       *
425  	       *  @c ios_base::in is automatically included in @a mode.
426  	       *
427  	       *  Initializes @c sb using @a str and @c mode|in, and passes @c &sb
428  	       *  to the base class initializer.
429  	       *
430  	       *  That's a lie.  We initialize the base class with NULL, because the
431  	       *  string class does its own memory management.
432  	      */
433  	      explicit
434  	      basic_istringstream(const __string_type& __str,
435  				  ios_base::openmode __mode = ios_base::in)
436  	      : __istream_type(), _M_stringbuf(__str, __mode | ios_base::in)
437  	      { this->init(&_M_stringbuf); }
438  	
439  	      /**
440  	       *  @brief  The destructor does nothing.
441  	       *
442  	       *  The buffer is deallocated by the stringbuf object, not the
443  	       *  formatting stream.
444  	      */
445  	      ~basic_istringstream()
446  	      { }
447  	
448  	#if __cplusplus >= 201103L
449  	      basic_istringstream(const basic_istringstream&) = delete;
450  	
451  	      basic_istringstream(basic_istringstream&& __rhs)
452  	      : __istream_type(std::move(__rhs)),
453  	      _M_stringbuf(std::move(__rhs._M_stringbuf))
454  	      { __istream_type::set_rdbuf(&_M_stringbuf); }
455  	
456  	      // 27.8.3.2 Assign and swap:
457  	
458  	      basic_istringstream&
459  	      operator=(const basic_istringstream&) = delete;
460  	
461  	      basic_istringstream&
462  	      operator=(basic_istringstream&& __rhs)
463  	      {
464  		__istream_type::operator=(std::move(__rhs));
465  		_M_stringbuf = std::move(__rhs._M_stringbuf);
466  		return *this;
467  	      }
468  	
469  	      void
470  	      swap(basic_istringstream& __rhs)
471  	      {
472  		__istream_type::swap(__rhs);
473  		_M_stringbuf.swap(__rhs._M_stringbuf);
474  	      }
475  	#endif
476  	
477  	      // Members:
478  	      /**
479  	       *  @brief  Accessing the underlying buffer.
480  	       *  @return  The current basic_stringbuf buffer.
481  	       *
482  	       *  This hides both signatures of std::basic_ios::rdbuf().
483  	      */
484  	      __stringbuf_type*
485  	      rdbuf() const
486  	      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
487  	
488  	      /**
489  	       *  @brief  Copying out the string buffer.
490  	       *  @return  @c rdbuf()->str()
491  	      */
492  	      __string_type
493  	      str() const
494  	      { return _M_stringbuf.str(); }
495  	
496  	      /**
497  	       *  @brief  Setting a new buffer.
498  	       *  @param  __s  The string to use as a new sequence.
499  	       *
500  	       *  Calls @c rdbuf()->str(s).
501  	      */
502  	      void
503  	      str(const __string_type& __s)
504  	      { _M_stringbuf.str(__s); }
505  	    };
506  	
507  	
508  	  // [27.7.3] Template class basic_ostringstream
509  	  /**
510  	   *  @brief  Controlling output for std::string.
511  	   *  @ingroup io
512  	   *
513  	   *  @tparam _CharT  Type of character stream.
514  	   *  @tparam _Traits  Traits for character type, defaults to
515  	   *                   char_traits<_CharT>.
516  	   *  @tparam _Alloc  Allocator type, defaults to allocator<_CharT>.
517  	   *
518  	   *  This class supports writing to objects of type std::basic_string,
519  	   *  using the inherited functions from std::basic_ostream.  To control
520  	   *  the associated sequence, an instance of std::basic_stringbuf is used,
521  	   *  which this page refers to as @c sb.
522  	  */
523  	  template <typename _CharT, typename _Traits, typename _Alloc>
524  	    class basic_ostringstream : public basic_ostream<_CharT, _Traits>
525  	    {
526  	    public:
527  	      // Types:
528  	      typedef _CharT 					char_type;
529  	      typedef _Traits 					traits_type;
530  	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
531  	      // 251. basic_stringbuf missing allocator_type
532  	      typedef _Alloc				       	allocator_type;
533  	      typedef typename traits_type::int_type 		int_type;
534  	      typedef typename traits_type::pos_type 		pos_type;
535  	      typedef typename traits_type::off_type 		off_type;
536  	
537  	      // Non-standard types:
538  	      typedef basic_string<_CharT, _Traits, _Alloc> 	__string_type;
539  	      typedef basic_stringbuf<_CharT, _Traits, _Alloc> 	__stringbuf_type;
540  	      typedef basic_ostream<char_type, traits_type>	__ostream_type;
541  	
542  	    private:
543  	      __stringbuf_type	_M_stringbuf;
544  	
545  	    public:
546  	      // Constructors/destructor:
547  	      /**
548  	       *  @brief  Default constructor starts with an empty string buffer.
549  	       *  @param  __mode  Whether the buffer can read, or write, or both.
550  	       *
551  	       *  @c ios_base::out is automatically included in @a mode.
552  	       *
553  	       *  Initializes @c sb using @c mode|out, and passes @c &sb to the base
554  	       *  class initializer.  Does not allocate any buffer.
555  	       *
556  	       *  That's a lie.  We initialize the base class with NULL, because the
557  	       *  string class does its own memory management.
558  	      */
559  	      explicit
560  	      basic_ostringstream(ios_base::openmode __mode = ios_base::out)
561  	      : __ostream_type(), _M_stringbuf(__mode | ios_base::out)
562  	      { this->init(&_M_stringbuf); }
563  	
564  	      /**
565  	       *  @brief  Starts with an existing string buffer.
566  	       *  @param  __str  A string to copy as a starting buffer.
567  	       *  @param  __mode  Whether the buffer can read, or write, or both.
568  	       *
569  	       *  @c ios_base::out is automatically included in @a mode.
570  	       *
571  	       *  Initializes @c sb using @a str and @c mode|out, and passes @c &sb
572  	       *  to the base class initializer.
573  	       *
574  	       *  That's a lie.  We initialize the base class with NULL, because the
575  	       *  string class does its own memory management.
576  	      */
577  	      explicit
578  	      basic_ostringstream(const __string_type& __str,
579  				  ios_base::openmode __mode = ios_base::out)
580  	      : __ostream_type(), _M_stringbuf(__str, __mode | ios_base::out)
581  	      { this->init(&_M_stringbuf); }
582  	
583  	      /**
584  	       *  @brief  The destructor does nothing.
585  	       *
586  	       *  The buffer is deallocated by the stringbuf object, not the
587  	       *  formatting stream.
588  	      */
589  	      ~basic_ostringstream()
590  	      { }
591  	
592  	#if __cplusplus >= 201103L
593  	      basic_ostringstream(const basic_ostringstream&) = delete;
594  	
595  	      basic_ostringstream(basic_ostringstream&& __rhs)
596  	      : __ostream_type(std::move(__rhs)),
597  	      _M_stringbuf(std::move(__rhs._M_stringbuf))
598  	      { __ostream_type::set_rdbuf(&_M_stringbuf); }
599  	
600  	      // 27.8.3.2 Assign and swap:
601  	
602  	      basic_ostringstream&
603  	      operator=(const basic_ostringstream&) = delete;
604  	
605  	      basic_ostringstream&
606  	      operator=(basic_ostringstream&& __rhs)
607  	      {
608  		__ostream_type::operator=(std::move(__rhs));
609  		_M_stringbuf = std::move(__rhs._M_stringbuf);
610  		return *this;
611  	      }
612  	
613  	      void
614  	      swap(basic_ostringstream& __rhs)
615  	      {
616  		__ostream_type::swap(__rhs);
617  		_M_stringbuf.swap(__rhs._M_stringbuf);
618  	      }
619  	#endif
620  	
621  	      // Members:
622  	      /**
623  	       *  @brief  Accessing the underlying buffer.
624  	       *  @return  The current basic_stringbuf buffer.
625  	       *
626  	       *  This hides both signatures of std::basic_ios::rdbuf().
627  	      */
628  	      __stringbuf_type*
629  	      rdbuf() const
630  	      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
631  	
632  	      /**
633  	       *  @brief  Copying out the string buffer.
634  	       *  @return  @c rdbuf()->str()
635  	      */
636  	      __string_type
637  	      str() const
638  	      { return _M_stringbuf.str(); }
639  	
640  	      /**
641  	       *  @brief  Setting a new buffer.
642  	       *  @param  __s  The string to use as a new sequence.
643  	       *
644  	       *  Calls @c rdbuf()->str(s).
645  	      */
646  	      void
647  	      str(const __string_type& __s)
648  	      { _M_stringbuf.str(__s); }
649  	    };
650  	
651  	
652  	  // [27.7.4] Template class basic_stringstream
653  	  /**
654  	   *  @brief  Controlling input and output for std::string.
655  	   *  @ingroup io
656  	   *
657  	   *  @tparam _CharT  Type of character stream.
658  	   *  @tparam _Traits  Traits for character type, defaults to
659  	   *                   char_traits<_CharT>.
660  	   *  @tparam _Alloc  Allocator type, defaults to allocator<_CharT>.
661  	   *
662  	   *  This class supports reading from and writing to objects of type
663  	   *  std::basic_string, using the inherited functions from
664  	   *  std::basic_iostream.  To control the associated sequence, an instance
665  	   *  of std::basic_stringbuf is used, which this page refers to as @c sb.
666  	  */
667  	  template <typename _CharT, typename _Traits, typename _Alloc>
668  	    class basic_stringstream : public basic_iostream<_CharT, _Traits>
669  	    {
670  	    public:
671  	      // Types:
672  	      typedef _CharT 					char_type;
673  	      typedef _Traits 					traits_type;
674  	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
675  	      // 251. basic_stringbuf missing allocator_type
676  	      typedef _Alloc				       	allocator_type;
677  	      typedef typename traits_type::int_type 		int_type;
678  	      typedef typename traits_type::pos_type 		pos_type;
679  	      typedef typename traits_type::off_type 		off_type;
680  	
681  	      // Non-standard Types:
682  	      typedef basic_string<_CharT, _Traits, _Alloc> 	__string_type;
683  	      typedef basic_stringbuf<_CharT, _Traits, _Alloc> 	__stringbuf_type;
684  	      typedef basic_iostream<char_type, traits_type>	__iostream_type;
685  	
686  	    private:
687  	      __stringbuf_type	_M_stringbuf;
688  	
689  	    public:
690  	      // Constructors/destructors
691  	      /**
692  	       *  @brief  Default constructor starts with an empty string buffer.
693  	       *  @param  __m  Whether the buffer can read, or write, or both.
694  	       *
695  	       *  Initializes @c sb using the mode from @c __m, and passes @c
696  	       *  &sb to the base class initializer.  Does not allocate any
697  	       *  buffer.
698  	       *
699  	       *  That's a lie.  We initialize the base class with NULL, because the
700  	       *  string class does its own memory management.
701  	      */
702  	      explicit
703  	      basic_stringstream(ios_base::openmode __m = ios_base::out | ios_base::in)
704  	      : __iostream_type(), _M_stringbuf(__m)
705  	      { this->init(&_M_stringbuf); }
706  	
707  	      /**
708  	       *  @brief  Starts with an existing string buffer.
709  	       *  @param  __str  A string to copy as a starting buffer.
710  	       *  @param  __m  Whether the buffer can read, or write, or both.
711  	       *
712  	       *  Initializes @c sb using @a __str and @c __m, and passes @c &sb
713  	       *  to the base class initializer.
714  	       *
715  	       *  That's a lie.  We initialize the base class with NULL, because the
716  	       *  string class does its own memory management.
717  	      */
718  	      explicit
719  	      basic_stringstream(const __string_type& __str,
720  				 ios_base::openmode __m = ios_base::out | ios_base::in)
721  	      : __iostream_type(), _M_stringbuf(__str, __m)
722  	      { this->init(&_M_stringbuf); }
723  	
724  	      /**
725  	       *  @brief  The destructor does nothing.
726  	       *
727  	       *  The buffer is deallocated by the stringbuf object, not the
728  	       *  formatting stream.
729  	      */
730  	      ~basic_stringstream()
731  	      { }
732  	
733  	#if __cplusplus >= 201103L
734  	      basic_stringstream(const basic_stringstream&) = delete;
735  	
736  	      basic_stringstream(basic_stringstream&& __rhs)
737  	      : __iostream_type(std::move(__rhs)),
738  	      _M_stringbuf(std::move(__rhs._M_stringbuf))
739  	      { __iostream_type::set_rdbuf(&_M_stringbuf); }
740  	
741  	      // 27.8.3.2 Assign and swap:
742  	
743  	      basic_stringstream&
744  	      operator=(const basic_stringstream&) = delete;
745  	
746  	      basic_stringstream&
747  	      operator=(basic_stringstream&& __rhs)
748  	      {
749  		__iostream_type::operator=(std::move(__rhs));
750  		_M_stringbuf = std::move(__rhs._M_stringbuf);
751  		return *this;
752  	      }
753  	
754  	      void
755  	      swap(basic_stringstream& __rhs)
756  	      {
757  		__iostream_type::swap(__rhs);
758  		_M_stringbuf.swap(__rhs._M_stringbuf);
759  	      }
760  	#endif
761  	
762  	      // Members:
763  	      /**
764  	       *  @brief  Accessing the underlying buffer.
765  	       *  @return  The current basic_stringbuf buffer.
766  	       *
767  	       *  This hides both signatures of std::basic_ios::rdbuf().
768  	      */
769  	      __stringbuf_type*
770  	      rdbuf() const
771  	      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
772  	
773  	      /**
774  	       *  @brief  Copying out the string buffer.
775  	       *  @return  @c rdbuf()->str()
776  	      */
777  	      __string_type
778  	      str() const
779  	      { return _M_stringbuf.str(); }
780  	
781  	      /**
782  	       *  @brief  Setting a new buffer.
783  	       *  @param  __s  The string to use as a new sequence.
784  	       *
785  	       *  Calls @c rdbuf()->str(s).
786  	      */
787  	      void
788  	      str(const __string_type& __s)
789  	      { _M_stringbuf.str(__s); }
790  	    };
791  	
792  	#if __cplusplus >= 201103L
793  	  /// Swap specialization for stringbufs.
794  	  template <class _CharT, class _Traits, class _Allocator>
795  	    inline void
796  	    swap(basic_stringbuf<_CharT, _Traits, _Allocator>& __x,
797  		 basic_stringbuf<_CharT, _Traits, _Allocator>& __y)
798  	    { __x.swap(__y); }
799  	
800  	  /// Swap specialization for istringstreams.
801  	  template <class _CharT, class _Traits, class _Allocator>
802  	    inline void
803  	    swap(basic_istringstream<_CharT, _Traits, _Allocator>& __x,
804  		 basic_istringstream<_CharT, _Traits, _Allocator>& __y)
805  	    { __x.swap(__y); }
806  	
807  	  /// Swap specialization for ostringstreams.
808  	  template <class _CharT, class _Traits, class _Allocator>
809  	    inline void
810  	    swap(basic_ostringstream<_CharT, _Traits, _Allocator>& __x,
811  		 basic_ostringstream<_CharT, _Traits, _Allocator>& __y)
812  	    { __x.swap(__y); }
813  	
814  	  /// Swap specialization for stringstreams.
815  	  template <class _CharT, class _Traits, class _Allocator>
816  	    inline void
817  	    swap(basic_stringstream<_CharT, _Traits, _Allocator>& __x,
818  		 basic_stringstream<_CharT, _Traits, _Allocator>& __y)
819  	    { __x.swap(__y); }
820  	#endif
821  	
822  	_GLIBCXX_END_NAMESPACE_CXX11
823  	_GLIBCXX_END_NAMESPACE_VERSION
824  	} // namespace
825  	
826  	#include <bits/sstream.tcc>
827  	
828  	#endif /* _GLIBCXX_SSTREAM */
829