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