Branch data Line data Source code
1 : : // String based streams -*- C++ -*-
2 : :
3 : : // Copyright (C) 1997-2013 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 : :
45 : : // [27.7.1] template class basic_stringbuf
46 : : /**
47 : : * @brief The actual work of input and output (for std::string).
48 : : * @ingroup io
49 : : *
50 : : * @tparam _CharT Type of character stream.
51 : : * @tparam _Traits Traits for character type, defaults to
52 : : * char_traits<_CharT>.
53 : : * @tparam _Alloc Allocator type, defaults to allocator<_CharT>.
54 : : *
55 : : * This class associates either or both of its input and output sequences
56 : : * with a sequence of characters, which can be initialized from, or made
57 : : * available as, a @c std::basic_string. (Paraphrased from [27.7.1]/1.)
58 : : *
59 : : * For this class, open modes (of type @c ios_base::openmode) have
60 : : * @c in set if the input sequence can be read, and @c out set if the
61 : : * output sequence can be written.
62 : : */
63 : : template<typename _CharT, typename _Traits, typename _Alloc>
64 [ # # ][ # # ]: 0 : class basic_stringbuf : public basic_streambuf<_CharT, _Traits>
65 : : {
66 : : public:
67 : : // Types:
68 : : typedef _CharT char_type;
69 : : typedef _Traits traits_type;
70 : : // _GLIBCXX_RESOLVE_LIB_DEFECTS
71 : : // 251. basic_stringbuf missing allocator_type
72 : : typedef _Alloc allocator_type;
73 : : typedef typename traits_type::int_type int_type;
74 : : typedef typename traits_type::pos_type pos_type;
75 : : typedef typename traits_type::off_type off_type;
76 : :
77 : : typedef basic_streambuf<char_type, traits_type> __streambuf_type;
78 : : typedef basic_string<char_type, _Traits, _Alloc> __string_type;
79 : : typedef typename __string_type::size_type __size_type;
80 : :
81 : : protected:
82 : : /// Place to stash in || out || in | out settings for current stringbuf.
83 : : ios_base::openmode _M_mode;
84 : :
85 : : // Data Members:
86 : : __string_type _M_string;
87 : :
88 : : public:
89 : : // Constructors:
90 : : /**
91 : : * @brief Starts with an empty string buffer.
92 : : * @param __mode Whether the buffer can read, or write, or both.
93 : : *
94 : : * The default constructor initializes the parent class using its
95 : : * own default ctor.
96 : : */
97 : : explicit
98 : : basic_stringbuf(ios_base::openmode __mode = ios_base::in | ios_base::out)
99 : : : __streambuf_type(), _M_mode(__mode), _M_string()
100 : : { }
101 : :
102 : : /**
103 : : * @brief Starts with an existing string buffer.
104 : : * @param __str A string to copy as a starting buffer.
105 : : * @param __mode Whether the buffer can read, or write, or both.
106 : : *
107 : : * This constructor initializes the parent class using its
108 : : * own default ctor.
109 : : */
110 : : explicit
111 : : basic_stringbuf(const __string_type& __str,
112 : : ios_base::openmode __mode = ios_base::in | ios_base::out)
113 : : : __streambuf_type(), _M_mode(), _M_string(__str.data(), __str.size())
114 : : { _M_stringbuf_init(__mode); }
115 : :
116 : : // Get and set:
117 : : /**
118 : : * @brief Copying out the string buffer.
119 : : * @return A copy of one of the underlying sequences.
120 : : *
121 : : * <em>If the buffer is only created in input mode, the underlying
122 : : * character sequence is equal to the input sequence; otherwise, it
123 : : * is equal to the output sequence.</em> [27.7.1.2]/1
124 : : */
125 : : __string_type
126 : : str() const
127 : : {
128 : : __string_type __ret;
129 : : if (this->pptr())
130 : : {
131 : : // The current egptr() may not be the actual string end.
132 : : if (this->pptr() > this->egptr())
133 : : __ret = __string_type(this->pbase(), this->pptr());
134 : : else
135 : : __ret = __string_type(this->pbase(), this->egptr());
136 : : }
137 : : else
138 : : __ret = _M_string;
139 : : return __ret;
140 : : }
141 : :
142 : : /**
143 : : * @brief Setting a new buffer.
144 : : * @param __s The string to use as a new sequence.
145 : : *
146 : : * Deallocates any previous stored sequence, then copies @a s to
147 : : * use as a new one.
148 : : */
149 : : void
150 : : str(const __string_type& __s)
151 : : {
152 : : // Cannot use _M_string = __s, since v3 strings are COW.
153 : : _M_string.assign(__s.data(), __s.size());
154 : : _M_stringbuf_init(_M_mode);
155 : : }
156 : :
157 : : protected:
158 : : // Common initialization code goes here.
159 : : void
160 : : _M_stringbuf_init(ios_base::openmode __mode)
161 : : {
162 : : _M_mode = __mode;
163 : : __size_type __len = 0;
164 : : if (_M_mode & (ios_base::ate | ios_base::app))
165 : : __len = _M_string.size();
166 : : _M_sync(const_cast<char_type*>(_M_string.data()), 0, __len);
167 : : }
168 : :
169 : : virtual streamsize
170 : : showmanyc()
171 : : {
172 : : streamsize __ret = -1;
173 : : if (_M_mode & ios_base::in)
174 : : {
175 : : _M_update_egptr();
176 : : __ret = this->egptr() - this->gptr();
177 : : }
178 : : return __ret;
179 : : }
180 : :
181 : : virtual int_type
182 : : underflow();
183 : :
184 : : virtual int_type
185 : : pbackfail(int_type __c = traits_type::eof());
186 : :
187 : : virtual int_type
188 : : overflow(int_type __c = traits_type::eof());
189 : :
190 : : /**
191 : : * @brief Manipulates the buffer.
192 : : * @param __s Pointer to a buffer area.
193 : : * @param __n Size of @a __s.
194 : : * @return @c this
195 : : *
196 : : * If no buffer has already been created, and both @a __s and @a __n are
197 : : * non-zero, then @c __s is used as a buffer; see
198 : : * http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch25s02.html
199 : : * for more.
200 : : */
201 : : virtual __streambuf_type*
202 : : setbuf(char_type* __s, streamsize __n)
203 : : {
204 : : if (__s && __n >= 0)
205 : : {
206 : : // This is implementation-defined behavior, and assumes
207 : : // that an external char_type array of length __n exists
208 : : // and has been pre-allocated. If this is not the case,
209 : : // things will quickly blow up.
210 : :
211 : : // Step 1: Destroy the current internal array.
212 : : _M_string.clear();
213 : :
214 : : // Step 2: Use the external array.
215 : : _M_sync(__s, __n, 0);
216 : : }
217 : : return this;
218 : : }
219 : :
220 : : virtual pos_type
221 : : seekoff(off_type __off, ios_base::seekdir __way,
222 : : ios_base::openmode __mode = ios_base::in | ios_base::out);
223 : :
224 : : virtual pos_type
225 : : seekpos(pos_type __sp,
226 : : ios_base::openmode __mode = ios_base::in | ios_base::out);
227 : :
228 : : // Internal function for correctly updating the internal buffer
229 : : // for a particular _M_string, due to initialization or re-sizing
230 : : // of an existing _M_string.
231 : : void
232 : : _M_sync(char_type* __base, __size_type __i, __size_type __o);
233 : :
234 : : // Internal function for correctly updating egptr() to the actual
235 : : // string end.
236 : : void
237 : : _M_update_egptr()
238 : : {
239 : : const bool __testin = _M_mode & ios_base::in;
240 : : if (this->pptr() && this->pptr() > this->egptr())
241 : : {
242 : : if (__testin)
243 : : this->setg(this->eback(), this->gptr(), this->pptr());
244 : : else
245 : : this->setg(this->pptr(), this->pptr(), this->pptr());
246 : : }
247 : : }
248 : :
249 : : // Works around the issue with pbump, part of the protected
250 : : // interface of basic_streambuf, taking just an int.
251 : : void
252 : : _M_pbump(char_type* __pbeg, char_type* __pend, off_type __off);
253 : : };
254 : :
255 : :
256 : : // [27.7.2] Template class basic_istringstream
257 : : /**
258 : : * @brief Controlling input for std::string.
259 : : * @ingroup io
260 : : *
261 : : * @tparam _CharT Type of character stream.
262 : : * @tparam _Traits Traits for character type, defaults to
263 : : * char_traits<_CharT>.
264 : : * @tparam _Alloc Allocator type, defaults to allocator<_CharT>.
265 : : *
266 : : * This class supports reading from objects of type std::basic_string,
267 : : * using the inherited functions from std::basic_istream. To control
268 : : * the associated sequence, an instance of std::basic_stringbuf is used,
269 : : * which this page refers to as @c sb.
270 : : */
271 : : template<typename _CharT, typename _Traits, typename _Alloc>
272 : : class basic_istringstream : public basic_istream<_CharT, _Traits>
273 : : {
274 : : public:
275 : : // Types:
276 : : typedef _CharT char_type;
277 : : typedef _Traits traits_type;
278 : : // _GLIBCXX_RESOLVE_LIB_DEFECTS
279 : : // 251. basic_stringbuf missing allocator_type
280 : : typedef _Alloc allocator_type;
281 : : typedef typename traits_type::int_type int_type;
282 : : typedef typename traits_type::pos_type pos_type;
283 : : typedef typename traits_type::off_type off_type;
284 : :
285 : : // Non-standard types:
286 : : typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
287 : : typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
288 : : typedef basic_istream<char_type, traits_type> __istream_type;
289 : :
290 : : private:
291 : : __stringbuf_type _M_stringbuf;
292 : :
293 : : public:
294 : : // Constructors:
295 : : /**
296 : : * @brief Default constructor starts with an empty string buffer.
297 : : * @param __mode Whether the buffer can read, or write, or both.
298 : : *
299 : : * @c ios_base::in is automatically included in @a __mode.
300 : : *
301 : : * Initializes @c sb using @c __mode|in, and passes @c &sb to the base
302 : : * class initializer. Does not allocate any buffer.
303 : : *
304 : : * That's a lie. We initialize the base class with NULL, because the
305 : : * string class does its own memory management.
306 : : */
307 : : explicit
308 : : basic_istringstream(ios_base::openmode __mode = ios_base::in)
309 : : : __istream_type(), _M_stringbuf(__mode | ios_base::in)
310 : : { this->init(&_M_stringbuf); }
311 : :
312 : : /**
313 : : * @brief Starts with an existing string buffer.
314 : : * @param __str A string to copy as a starting buffer.
315 : : * @param __mode Whether the buffer can read, or write, or both.
316 : : *
317 : : * @c ios_base::in is automatically included in @a mode.
318 : : *
319 : : * Initializes @c sb using @a str and @c mode|in, and passes @c &sb
320 : : * to the base class initializer.
321 : : *
322 : : * That's a lie. We initialize the base class with NULL, because the
323 : : * string class does its own memory management.
324 : : */
325 : : explicit
326 : : basic_istringstream(const __string_type& __str,
327 : : ios_base::openmode __mode = ios_base::in)
328 : : : __istream_type(), _M_stringbuf(__str, __mode | ios_base::in)
329 : : { this->init(&_M_stringbuf); }
330 : :
331 : : /**
332 : : * @brief The destructor does nothing.
333 : : *
334 : : * The buffer is deallocated by the stringbuf object, not the
335 : : * formatting stream.
336 : : */
337 : : ~basic_istringstream()
338 : : { }
339 : :
340 : : // Members:
341 : : /**
342 : : * @brief Accessing the underlying buffer.
343 : : * @return The current basic_stringbuf buffer.
344 : : *
345 : : * This hides both signatures of std::basic_ios::rdbuf().
346 : : */
347 : : __stringbuf_type*
348 : : rdbuf() const
349 : : { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
350 : :
351 : : /**
352 : : * @brief Copying out the string buffer.
353 : : * @return @c rdbuf()->str()
354 : : */
355 : : __string_type
356 : : str() const
357 : : { return _M_stringbuf.str(); }
358 : :
359 : : /**
360 : : * @brief Setting a new buffer.
361 : : * @param __s The string to use as a new sequence.
362 : : *
363 : : * Calls @c rdbuf()->str(s).
364 : : */
365 : : void
366 : : str(const __string_type& __s)
367 : : { _M_stringbuf.str(__s); }
368 : : };
369 : :
370 : :
371 : : // [27.7.3] Template class basic_ostringstream
372 : : /**
373 : : * @brief Controlling output for std::string.
374 : : * @ingroup io
375 : : *
376 : : * @tparam _CharT Type of character stream.
377 : : * @tparam _Traits Traits for character type, defaults to
378 : : * char_traits<_CharT>.
379 : : * @tparam _Alloc Allocator type, defaults to allocator<_CharT>.
380 : : *
381 : : * This class supports writing to objects of type std::basic_string,
382 : : * using the inherited functions from std::basic_ostream. To control
383 : : * the associated sequence, an instance of std::basic_stringbuf is used,
384 : : * which this page refers to as @c sb.
385 : : */
386 : : template <typename _CharT, typename _Traits, typename _Alloc>
387 : : class basic_ostringstream : public basic_ostream<_CharT, _Traits>
388 : : {
389 : : public:
390 : : // Types:
391 : : typedef _CharT char_type;
392 : : typedef _Traits traits_type;
393 : : // _GLIBCXX_RESOLVE_LIB_DEFECTS
394 : : // 251. basic_stringbuf missing allocator_type
395 : : typedef _Alloc allocator_type;
396 : : typedef typename traits_type::int_type int_type;
397 : : typedef typename traits_type::pos_type pos_type;
398 : : typedef typename traits_type::off_type off_type;
399 : :
400 : : // Non-standard types:
401 : : typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
402 : : typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
403 : : typedef basic_ostream<char_type, traits_type> __ostream_type;
404 : :
405 : : private:
406 : : __stringbuf_type _M_stringbuf;
407 : :
408 : : public:
409 : : // Constructors/destructor:
410 : : /**
411 : : * @brief Default constructor starts with an empty string buffer.
412 : : * @param __mode Whether the buffer can read, or write, or both.
413 : : *
414 : : * @c ios_base::out is automatically included in @a mode.
415 : : *
416 : : * Initializes @c sb using @c mode|out, and passes @c &sb to the base
417 : : * class initializer. Does not allocate any buffer.
418 : : *
419 : : * That's a lie. We initialize the base class with NULL, because the
420 : : * string class does its own memory management.
421 : : */
422 : : explicit
423 : : basic_ostringstream(ios_base::openmode __mode = ios_base::out)
424 : : : __ostream_type(), _M_stringbuf(__mode | ios_base::out)
425 : : { this->init(&_M_stringbuf); }
426 : :
427 : : /**
428 : : * @brief Starts with an existing string buffer.
429 : : * @param __str A string to copy as a starting buffer.
430 : : * @param __mode Whether the buffer can read, or write, or both.
431 : : *
432 : : * @c ios_base::out is automatically included in @a mode.
433 : : *
434 : : * Initializes @c sb using @a str and @c mode|out, and passes @c &sb
435 : : * to the base class initializer.
436 : : *
437 : : * That's a lie. We initialize the base class with NULL, because the
438 : : * string class does its own memory management.
439 : : */
440 : : explicit
441 : : basic_ostringstream(const __string_type& __str,
442 : : ios_base::openmode __mode = ios_base::out)
443 : : : __ostream_type(), _M_stringbuf(__str, __mode | ios_base::out)
444 : : { this->init(&_M_stringbuf); }
445 : :
446 : : /**
447 : : * @brief The destructor does nothing.
448 : : *
449 : : * The buffer is deallocated by the stringbuf object, not the
450 : : * formatting stream.
451 : : */
452 : : ~basic_ostringstream()
453 : : { }
454 : :
455 : : // Members:
456 : : /**
457 : : * @brief Accessing the underlying buffer.
458 : : * @return The current basic_stringbuf buffer.
459 : : *
460 : : * This hides both signatures of std::basic_ios::rdbuf().
461 : : */
462 : : __stringbuf_type*
463 : : rdbuf() const
464 : : { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
465 : :
466 : : /**
467 : : * @brief Copying out the string buffer.
468 : : * @return @c rdbuf()->str()
469 : : */
470 : : __string_type
471 : : str() const
472 : : { return _M_stringbuf.str(); }
473 : :
474 : : /**
475 : : * @brief Setting a new buffer.
476 : : * @param __s The string to use as a new sequence.
477 : : *
478 : : * Calls @c rdbuf()->str(s).
479 : : */
480 : : void
481 : : str(const __string_type& __s)
482 : : { _M_stringbuf.str(__s); }
483 : : };
484 : :
485 : :
486 : : // [27.7.4] Template class basic_stringstream
487 : : /**
488 : : * @brief Controlling input and output for std::string.
489 : : * @ingroup io
490 : : *
491 : : * @tparam _CharT Type of character stream.
492 : : * @tparam _Traits Traits for character type, defaults to
493 : : * char_traits<_CharT>.
494 : : * @tparam _Alloc Allocator type, defaults to allocator<_CharT>.
495 : : *
496 : : * This class supports reading from and writing to objects of type
497 : : * std::basic_string, using the inherited functions from
498 : : * std::basic_iostream. To control the associated sequence, an instance
499 : : * of std::basic_stringbuf is used, which this page refers to as @c sb.
500 : : */
501 : : template <typename _CharT, typename _Traits, typename _Alloc>
502 : : class basic_stringstream : public basic_iostream<_CharT, _Traits>
503 : : {
504 : : public:
505 : : // Types:
506 : : typedef _CharT char_type;
507 : : typedef _Traits traits_type;
508 : : // _GLIBCXX_RESOLVE_LIB_DEFECTS
509 : : // 251. basic_stringbuf missing allocator_type
510 : : typedef _Alloc allocator_type;
511 : : typedef typename traits_type::int_type int_type;
512 : : typedef typename traits_type::pos_type pos_type;
513 : : typedef typename traits_type::off_type off_type;
514 : :
515 : : // Non-standard Types:
516 : : typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
517 : : typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
518 : : typedef basic_iostream<char_type, traits_type> __iostream_type;
519 : :
520 : : private:
521 : : __stringbuf_type _M_stringbuf;
522 : :
523 : : public:
524 : : // Constructors/destructors
525 : : /**
526 : : * @brief Default constructor starts with an empty string buffer.
527 : : * @param __m Whether the buffer can read, or write, or both.
528 : : *
529 : : * Initializes @c sb using the mode from @c __m, and passes @c
530 : : * &sb to the base class initializer. Does not allocate any
531 : : * buffer.
532 : : *
533 : : * That's a lie. We initialize the base class with NULL, because the
534 : : * string class does its own memory management.
535 : : */
536 : : explicit
537 : : basic_stringstream(ios_base::openmode __m = ios_base::out | ios_base::in)
538 : : : __iostream_type(), _M_stringbuf(__m)
539 : : { this->init(&_M_stringbuf); }
540 : :
541 : : /**
542 : : * @brief Starts with an existing string buffer.
543 : : * @param __str A string to copy as a starting buffer.
544 : : * @param __m Whether the buffer can read, or write, or both.
545 : : *
546 : : * Initializes @c sb using @a __str and @c __m, and passes @c &sb
547 : : * to the base class initializer.
548 : : *
549 : : * That's a lie. We initialize the base class with NULL, because the
550 : : * string class does its own memory management.
551 : : */
552 : : explicit
553 : : basic_stringstream(const __string_type& __str,
554 : : ios_base::openmode __m = ios_base::out | ios_base::in)
555 : : : __iostream_type(), _M_stringbuf(__str, __m)
556 : : { this->init(&_M_stringbuf); }
557 : :
558 : : /**
559 : : * @brief The destructor does nothing.
560 : : *
561 : : * The buffer is deallocated by the stringbuf object, not the
562 : : * formatting stream.
563 : : */
564 : : ~basic_stringstream()
565 : : { }
566 : :
567 : : // Members:
568 : : /**
569 : : * @brief Accessing the underlying buffer.
570 : : * @return The current basic_stringbuf buffer.
571 : : *
572 : : * This hides both signatures of std::basic_ios::rdbuf().
573 : : */
574 : : __stringbuf_type*
575 : : rdbuf() const
576 : : { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
577 : :
578 : : /**
579 : : * @brief Copying out the string buffer.
580 : : * @return @c rdbuf()->str()
581 : : */
582 : : __string_type
583 : : str() const
584 : : { return _M_stringbuf.str(); }
585 : :
586 : : /**
587 : : * @brief Setting a new buffer.
588 : : * @param __s The string to use as a new sequence.
589 : : *
590 : : * Calls @c rdbuf()->str(s).
591 : : */
592 : : void
593 : : str(const __string_type& __s)
594 : : { _M_stringbuf.str(__s); }
595 : : };
596 : :
597 : : _GLIBCXX_END_NAMESPACE_VERSION
598 : : } // namespace
599 : :
600 : : #include <bits/sstream.tcc>
601 : :
602 : : #endif /* _GLIBCXX_SSTREAM */
|