xref: /freebsd-12.1/contrib/libc++/include/sstream (revision c19c7afe) 
1// -*- C++ -*-
2//===--------------------------- sstream ----------------------------------===//
3//
4//                     The LLVM Compiler Infrastructure
5//
6// This file is dual licensed under the MIT and the University of Illinois Open
7// Source Licenses. See LICENSE.TXT for details.
8//
9//===----------------------------------------------------------------------===//
10
11#ifndef _LIBCPP_SSTREAM
12#define _LIBCPP_SSTREAM
13
14/*
15    sstream synopsis
16
17template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
18class basic_stringbuf
19    : public basic_streambuf<charT, traits>
20{
21public:
22    typedef charT                          char_type;
23    typedef traits                         traits_type;
24    typedef typename traits_type::int_type int_type;
25    typedef typename traits_type::pos_type pos_type;
26    typedef typename traits_type::off_type off_type;
27    typedef Allocator                      allocator_type;
28
29    // 27.8.1.1 Constructors:
30    explicit basic_stringbuf(ios_base::openmode which = ios_base::in | ios_base::out);
31    explicit basic_stringbuf(const basic_string<char_type, traits_type, allocator_type>& str,
32                             ios_base::openmode which = ios_base::in | ios_base::out);
33    basic_stringbuf(basic_stringbuf&& rhs);
34
35    // 27.8.1.2 Assign and swap:
36    basic_stringbuf& operator=(basic_stringbuf&& rhs);
37    void swap(basic_stringbuf& rhs);
38
39    // 27.8.1.3 Get and set:
40    basic_string<char_type, traits_type, allocator_type> str() const;
41    void str(const basic_string<char_type, traits_type, allocator_type>& s);
42
43protected:
44    // 27.8.1.4 Overridden virtual functions:
45    virtual int_type underflow();
46    virtual int_type pbackfail(int_type c = traits_type::eof());
47    virtual int_type overflow (int_type c = traits_type::eof());
48    virtual basic_streambuf<char_type, traits_type>* setbuf(char_type*, streamsize);
49    virtual pos_type seekoff(off_type off, ios_base::seekdir way,
50                             ios_base::openmode which = ios_base::in | ios_base::out);
51    virtual pos_type seekpos(pos_type sp,
52                             ios_base::openmode which = ios_base::in | ios_base::out);
53};
54
55template <class charT, class traits, class Allocator>
56  void swap(basic_stringbuf<charT, traits, Allocator>& x,
57            basic_stringbuf<charT, traits, Allocator>& y);
58
59typedef basic_stringbuf<char>    stringbuf;
60typedef basic_stringbuf<wchar_t> wstringbuf;
61
62template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
63class basic_istringstream
64    : public basic_istream<charT, traits>
65{
66public:
67    typedef charT                          char_type;
68    typedef traits                         traits_type;
69    typedef typename traits_type::int_type int_type;
70    typedef typename traits_type::pos_type pos_type;
71    typedef typename traits_type::off_type off_type;
72    typedef Allocator                      allocator_type;
73
74    // 27.8.2.1 Constructors:
75    explicit basic_istringstream(ios_base::openmode which = ios_base::in);
76    explicit basic_istringstream(const basic_string<char_type, traits_type,allocator_type>& str,
77                                 ios_base::openmode which = ios_base::in);
78    basic_istringstream(basic_istringstream&& rhs);
79
80    // 27.8.2.2 Assign and swap:
81    basic_istringstream& operator=(basic_istringstream&& rhs);
82    void swap(basic_istringstream& rhs);
83
84    // 27.8.2.3 Members:
85    basic_stringbuf<char_type, traits_type, allocator_type>* rdbuf() const;
86    basic_string<char_type, traits_type, allocator_type> str() const;
87    void str(const basic_string<char_type, traits_type, allocator_type>& s);
88};
89
90template <class charT, class traits, class Allocator>
91  void swap(basic_istringstream<charT, traits, Allocator>& x,
92            basic_istringstream<charT, traits, Allocator>& y);
93
94typedef basic_istringstream<char>    istringstream;
95typedef basic_istringstream<wchar_t> wistringstream;
96
97template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
98class basic_ostringstream
99    : public basic_ostream<charT, traits>
100{
101public:
102    // types:
103    typedef charT                          char_type;
104    typedef traits                         traits_type;
105    typedef typename traits_type::int_type int_type;
106    typedef typename traits_type::pos_type pos_type;
107    typedef typename traits_type::off_type off_type;
108    typedef Allocator                      allocator_type;
109
110    // 27.8.3.1 Constructors/destructor:
111    explicit basic_ostringstream(ios_base::openmode which = ios_base::out);
112    explicit basic_ostringstream(const basic_string<char_type, traits_type, allocator_type>& str,
113                                 ios_base::openmode which = ios_base::out);
114    basic_ostringstream(basic_ostringstream&& rhs);
115
116    // 27.8.3.2 Assign/swap:
117    basic_ostringstream& operator=(basic_ostringstream&& rhs);
118    void swap(basic_ostringstream& rhs);
119
120    // 27.8.3.3 Members:
121    basic_stringbuf<char_type, traits_type, allocator_type>* rdbuf() const;
122    basic_string<char_type, traits_type, allocator_type> str() const;
123    void str(const basic_string<char_type, traits_type, allocator_type>& s);
124};
125
126template <class charT, class traits, class Allocator>
127  void swap(basic_ostringstream<charT, traits, Allocator>& x,
128            basic_ostringstream<charT, traits, Allocator>& y);
129
130typedef basic_ostringstream<char>    ostringstream;
131typedef basic_ostringstream<wchar_t> wostringstream;
132
133template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
134class basic_stringstream
135    : public basic_iostream<charT, traits>
136{
137public:
138    // types:
139    typedef charT                          char_type;
140    typedef traits                         traits_type;
141    typedef typename traits_type::int_type int_type;
142    typedef typename traits_type::pos_type pos_type;
143    typedef typename traits_type::off_type off_type;
144    typedef Allocator                      allocator_type;
145
146    // constructors/destructor
147    explicit basic_stringstream(ios_base::openmode which = ios_base::out|ios_base::in);
148    explicit basic_stringstream(const basic_string<char_type, traits_type, allocator_type>& str,
149                                ios_base::openmode which = ios_base::out|ios_base::in);
150    basic_stringstream(basic_stringstream&& rhs);
151
152    // 27.8.5.1 Assign/swap:
153    basic_stringstream& operator=(basic_stringstream&& rhs);
154    void swap(basic_stringstream& rhs);
155
156    // Members:
157    basic_stringbuf<char_type, traits_type, allocator_type>* rdbuf() const;
158    basic_string<char_type, traits_type, allocator_type> str() const;
159    void str(const basic_string<char_type, traits_type, allocator_type>& str);
160};
161
162template <class charT, class traits, class Allocator>
163  void swap(basic_stringstream<charT, traits, Allocator>& x,
164            basic_stringstream<charT, traits, Allocator>& y);
165
166typedef basic_stringstream<char>    stringstream;
167typedef basic_stringstream<wchar_t> wstringstream;
168
169}  // std
170
171*/
172
173#include <__config>
174#include <ostream>
175#include <istream>
176#include <string>
177
178#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
179#pragma GCC system_header
180#endif
181
182_LIBCPP_PUSH_MACROS
183#include <__undef_macros>
184
185
186_LIBCPP_BEGIN_NAMESPACE_STD
187
188// basic_stringbuf
189
190template <class _CharT, class _Traits, class _Allocator>
191class _LIBCPP_TEMPLATE_VIS basic_stringbuf
192    : public basic_streambuf<_CharT, _Traits>
193{
194public:
195    typedef _CharT                         char_type;
196    typedef _Traits                        traits_type;
197    typedef typename traits_type::int_type int_type;
198    typedef typename traits_type::pos_type pos_type;
199    typedef typename traits_type::off_type off_type;
200    typedef _Allocator                     allocator_type;
201
202    typedef basic_string<char_type, traits_type, allocator_type> string_type;
203
204private:
205
206    string_type __str_;
207    mutable char_type* __hm_;
208    ios_base::openmode __mode_;
209
210public:
211    // 27.8.1.1 Constructors:
212    inline _LIBCPP_INLINE_VISIBILITY
213    explicit basic_stringbuf(ios_base::openmode __wch = ios_base::in | ios_base::out);
214    inline _LIBCPP_INLINE_VISIBILITY
215    explicit basic_stringbuf(const string_type& __s,
216                             ios_base::openmode __wch = ios_base::in | ios_base::out);
217#ifndef _LIBCPP_CXX03_LANG
218    basic_stringbuf(basic_stringbuf&& __rhs);
219
220    // 27.8.1.2 Assign and swap:
221    basic_stringbuf& operator=(basic_stringbuf&& __rhs);
222#endif
223    void swap(basic_stringbuf& __rhs);
224
225    // 27.8.1.3 Get and set:
226    string_type str() const;
227    void str(const string_type& __s);
228
229protected:
230    // 27.8.1.4 Overridden virtual functions:
231    virtual int_type underflow();
232    virtual int_type pbackfail(int_type __c = traits_type::eof());
233    virtual int_type overflow (int_type __c = traits_type::eof());
234    virtual pos_type seekoff(off_type __off, ios_base::seekdir __way,
235                             ios_base::openmode __wch = ios_base::in | ios_base::out);
236    inline _LIBCPP_INLINE_VISIBILITY
237    virtual pos_type seekpos(pos_type __sp,
238                             ios_base::openmode __wch = ios_base::in | ios_base::out);
239};
240
241template <class _CharT, class _Traits, class _Allocator>
242basic_stringbuf<_CharT, _Traits, _Allocator>::basic_stringbuf(ios_base::openmode __wch)
243    : __hm_(0),
244      __mode_(__wch)
245{
246    str(string_type());
247}
248
249template <class _CharT, class _Traits, class _Allocator>
250basic_stringbuf<_CharT, _Traits, _Allocator>::basic_stringbuf(const string_type& __s,
251                             ios_base::openmode __wch)
252    : __str_(__s.get_allocator()),
253      __hm_(0),
254      __mode_(__wch)
255{
256    str(__s);
257}
258
259#ifndef _LIBCPP_CXX03_LANG
260
261template <class _CharT, class _Traits, class _Allocator>
262basic_stringbuf<_CharT, _Traits, _Allocator>::basic_stringbuf(basic_stringbuf&& __rhs)
263    : __mode_(__rhs.__mode_)
264{
265    char_type* __p = const_cast<char_type*>(__rhs.__str_.data());
266    ptrdiff_t __binp = -1;
267    ptrdiff_t __ninp = -1;
268    ptrdiff_t __einp = -1;
269    if (__rhs.eback() != nullptr)
270    {
271        __binp = __rhs.eback() - __p;
272        __ninp = __rhs.gptr() - __p;
273        __einp = __rhs.egptr() - __p;
274    }
275    ptrdiff_t __bout = -1;
276    ptrdiff_t __nout = -1;
277    ptrdiff_t __eout = -1;
278    if (__rhs.pbase() != nullptr)
279    {
280        __bout = __rhs.pbase() - __p;
281        __nout = __rhs.pptr() - __p;
282        __eout = __rhs.epptr() - __p;
283    }
284    ptrdiff_t __hm = __rhs.__hm_ == nullptr ? -1 : __rhs.__hm_ - __p;
285    __str_ = _VSTD::move(__rhs.__str_);
286    __p = const_cast<char_type*>(__str_.data());
287    if (__binp != -1)
288        this->setg(__p + __binp, __p + __ninp, __p + __einp);
289    if (__bout != -1)
290    {
291        this->setp(__p + __bout, __p + __eout);
292        this->pbump(__nout);
293    }
294    __hm_ = __hm == -1 ? nullptr : __p + __hm;
295    __p = const_cast<char_type*>(__rhs.__str_.data());
296    __rhs.setg(__p, __p, __p);
297    __rhs.setp(__p, __p);
298    __rhs.__hm_ = __p;
299    this->pubimbue(__rhs.getloc());
300}
301
302template <class _CharT, class _Traits, class _Allocator>
303basic_stringbuf<_CharT, _Traits, _Allocator>&
304basic_stringbuf<_CharT, _Traits, _Allocator>::operator=(basic_stringbuf&& __rhs)
305{
306    char_type* __p = const_cast<char_type*>(__rhs.__str_.data());
307    ptrdiff_t __binp = -1;
308    ptrdiff_t __ninp = -1;
309    ptrdiff_t __einp = -1;
310    if (__rhs.eback() != nullptr)
311    {
312        __binp = __rhs.eback() - __p;
313        __ninp = __rhs.gptr() - __p;
314        __einp = __rhs.egptr() - __p;
315    }
316    ptrdiff_t __bout = -1;
317    ptrdiff_t __nout = -1;
318    ptrdiff_t __eout = -1;
319    if (__rhs.pbase() != nullptr)
320    {
321        __bout = __rhs.pbase() - __p;
322        __nout = __rhs.pptr() - __p;
323        __eout = __rhs.epptr() - __p;
324    }
325    ptrdiff_t __hm = __rhs.__hm_ == nullptr ? -1 : __rhs.__hm_ - __p;
326    __str_ = _VSTD::move(__rhs.__str_);
327    __p = const_cast<char_type*>(__str_.data());
328    if (__binp != -1)
329        this->setg(__p + __binp, __p + __ninp, __p + __einp);
330    else
331        this->setg(nullptr, nullptr, nullptr);
332    if (__bout != -1)
333    {
334        this->setp(__p + __bout, __p + __eout);
335        this->pbump(__nout);
336    }
337    else
338        this->setp(nullptr, nullptr);
339
340    __hm_ = __hm == -1 ? nullptr : __p + __hm;
341    __mode_ = __rhs.__mode_;
342    __p = const_cast<char_type*>(__rhs.__str_.data());
343    __rhs.setg(__p, __p, __p);
344    __rhs.setp(__p, __p);
345    __rhs.__hm_ = __p;
346    this->pubimbue(__rhs.getloc());
347    return *this;
348}
349
350#endif  // _LIBCPP_CXX03_LANG
351
352template <class _CharT, class _Traits, class _Allocator>
353void
354basic_stringbuf<_CharT, _Traits, _Allocator>::swap(basic_stringbuf& __rhs)
355{
356    char_type* __p = const_cast<char_type*>(__rhs.__str_.data());
357    ptrdiff_t __rbinp = -1;
358    ptrdiff_t __rninp = -1;
359    ptrdiff_t __reinp = -1;
360    if (__rhs.eback() != nullptr)
361    {
362        __rbinp = __rhs.eback() - __p;
363        __rninp = __rhs.gptr() - __p;
364        __reinp = __rhs.egptr() - __p;
365    }
366    ptrdiff_t __rbout = -1;
367    ptrdiff_t __rnout = -1;
368    ptrdiff_t __reout = -1;
369    if (__rhs.pbase() != nullptr)
370    {
371        __rbout = __rhs.pbase() - __p;
372        __rnout = __rhs.pptr() - __p;
373        __reout = __rhs.epptr() - __p;
374    }
375    ptrdiff_t __rhm = __rhs.__hm_ == nullptr ? -1 : __rhs.__hm_ - __p;
376    __p = const_cast<char_type*>(__str_.data());
377    ptrdiff_t __lbinp = -1;
378    ptrdiff_t __lninp = -1;
379    ptrdiff_t __leinp = -1;
380    if (this->eback() != nullptr)
381    {
382        __lbinp = this->eback() - __p;
383        __lninp = this->gptr() - __p;
384        __leinp = this->egptr() - __p;
385    }
386    ptrdiff_t __lbout = -1;
387    ptrdiff_t __lnout = -1;
388    ptrdiff_t __leout = -1;
389    if (this->pbase() != nullptr)
390    {
391        __lbout = this->pbase() - __p;
392        __lnout = this->pptr() - __p;
393        __leout = this->epptr() - __p;
394    }
395    ptrdiff_t __lhm = __hm_ == nullptr ? -1 : __hm_ - __p;
396    _VSTD::swap(__mode_, __rhs.__mode_);
397    __str_.swap(__rhs.__str_);
398    __p = const_cast<char_type*>(__str_.data());
399    if (__rbinp != -1)
400        this->setg(__p + __rbinp, __p + __rninp, __p + __reinp);
401    else
402        this->setg(nullptr, nullptr, nullptr);
403    if (__rbout != -1)
404    {
405        this->setp(__p + __rbout, __p + __reout);
406        this->pbump(__rnout);
407    }
408    else
409        this->setp(nullptr, nullptr);
410    __hm_ = __rhm == -1 ? nullptr : __p + __rhm;
411    __p = const_cast<char_type*>(__rhs.__str_.data());
412    if (__lbinp != -1)
413        __rhs.setg(__p + __lbinp, __p + __lninp, __p + __leinp);
414    else
415        __rhs.setg(nullptr, nullptr, nullptr);
416    if (__lbout != -1)
417    {
418        __rhs.setp(__p + __lbout, __p + __leout);
419        __rhs.pbump(__lnout);
420    }
421    else
422        __rhs.setp(nullptr, nullptr);
423    __rhs.__hm_ = __lhm == -1 ? nullptr : __p + __lhm;
424    locale __tl = __rhs.getloc();
425    __rhs.pubimbue(this->getloc());
426    this->pubimbue(__tl);
427}
428
429template <class _CharT, class _Traits, class _Allocator>
430inline _LIBCPP_INLINE_VISIBILITY
431void
432swap(basic_stringbuf<_CharT, _Traits, _Allocator>& __x,
433     basic_stringbuf<_CharT, _Traits, _Allocator>& __y)
434{
435    __x.swap(__y);
436}
437
438template <class _CharT, class _Traits, class _Allocator>
439basic_string<_CharT, _Traits, _Allocator>
440basic_stringbuf<_CharT, _Traits, _Allocator>::str() const
441{
442    if (__mode_ & ios_base::out)
443    {
444        if (__hm_ < this->pptr())
445            __hm_ = this->pptr();
446        return string_type(this->pbase(), __hm_, __str_.get_allocator());
447    }
448    else if (__mode_ & ios_base::in)
449        return string_type(this->eback(), this->egptr(), __str_.get_allocator());
450    return string_type(__str_.get_allocator());
451}
452
453template <class _CharT, class _Traits, class _Allocator>
454void
455basic_stringbuf<_CharT, _Traits, _Allocator>::str(const string_type& __s)
456{
457    __str_ = __s;
458    __hm_ = 0;
459    if (__mode_ & ios_base::in)
460    {
461        __hm_ = const_cast<char_type*>(__str_.data()) + __str_.size();
462        this->setg(const_cast<char_type*>(__str_.data()),
463                   const_cast<char_type*>(__str_.data()),
464                   __hm_);
465    }
466    if (__mode_ & ios_base::out)
467    {
468        typename string_type::size_type __sz = __str_.size();
469        __hm_ = const_cast<char_type*>(__str_.data()) + __sz;
470        __str_.resize(__str_.capacity());
471        this->setp(const_cast<char_type*>(__str_.data()),
472                   const_cast<char_type*>(__str_.data()) + __str_.size());
473        if (__mode_ & (ios_base::app | ios_base::ate))
474            this->pbump(__sz);
475    }
476}
477
478template <class _CharT, class _Traits, class _Allocator>
479typename basic_stringbuf<_CharT, _Traits, _Allocator>::int_type
480basic_stringbuf<_CharT, _Traits, _Allocator>::underflow()
481{
482    if (__hm_ < this->pptr())
483        __hm_ = this->pptr();
484    if (__mode_ & ios_base::in)
485    {
486        if (this->egptr() < __hm_)
487            this->setg(this->eback(), this->gptr(), __hm_);
488        if (this->gptr() < this->egptr())
489            return traits_type::to_int_type(*this->gptr());
490    }
491    return traits_type::eof();
492}
493
494template <class _CharT, class _Traits, class _Allocator>
495typename basic_stringbuf<_CharT, _Traits, _Allocator>::int_type
496basic_stringbuf<_CharT, _Traits, _Allocator>::pbackfail(int_type __c)
497{
498    if (__hm_ < this->pptr())
499        __hm_ = this->pptr();
500    if (this->eback() < this->gptr())
501    {
502        if (traits_type::eq_int_type(__c, traits_type::eof()))
503        {
504            this->setg(this->eback(), this->gptr()-1, __hm_);
505            return traits_type::not_eof(__c);
506        }
507        if ((__mode_ & ios_base::out) ||
508            traits_type::eq(traits_type::to_char_type(__c), this->gptr()[-1]))
509        {
510            this->setg(this->eback(), this->gptr()-1, __hm_);
511            *this->gptr() = traits_type::to_char_type(__c);
512            return __c;
513        }
514    }
515    return traits_type::eof();
516}
517
518template <class _CharT, class _Traits, class _Allocator>
519typename basic_stringbuf<_CharT, _Traits, _Allocator>::int_type
520basic_stringbuf<_CharT, _Traits, _Allocator>::overflow(int_type __c)
521{
522    if (!traits_type::eq_int_type(__c, traits_type::eof()))
523    {
524        ptrdiff_t __ninp = this->gptr()  - this->eback();
525        if (this->pptr() == this->epptr())
526        {
527            if (!(__mode_ & ios_base::out))
528                return traits_type::eof();
529#ifndef _LIBCPP_NO_EXCEPTIONS
530            try
531            {
532#endif  // _LIBCPP_NO_EXCEPTIONS
533                ptrdiff_t __nout = this->pptr()  - this->pbase();
534                ptrdiff_t __hm = __hm_ - this->pbase();
535                __str_.push_back(char_type());
536                __str_.resize(__str_.capacity());
537                char_type* __p = const_cast<char_type*>(__str_.data());
538                this->setp(__p, __p + __str_.size());
539                this->pbump(__nout);
540                __hm_ = this->pbase() + __hm;
541#ifndef _LIBCPP_NO_EXCEPTIONS
542            }
543            catch (...)
544            {
545                return traits_type::eof();
546            }
547#endif  // _LIBCPP_NO_EXCEPTIONS
548        }
549        __hm_ = _VSTD::max(this->pptr() + 1, __hm_);
550        if (__mode_ & ios_base::in)
551        {
552            char_type* __p = const_cast<char_type*>(__str_.data());
553            this->setg(__p, __p + __ninp, __hm_);
554        }
555        return this->sputc(__c);
556    }
557    return traits_type::not_eof(__c);
558}
559
560template <class _CharT, class _Traits, class _Allocator>
561typename basic_stringbuf<_CharT, _Traits, _Allocator>::pos_type
562basic_stringbuf<_CharT, _Traits, _Allocator>::seekoff(off_type __off,
563                                                      ios_base::seekdir __way,
564                                                      ios_base::openmode __wch)
565{
566    if (__hm_ < this->pptr())
567        __hm_ = this->pptr();
568    if ((__wch & (ios_base::in | ios_base::out)) == 0)
569        return pos_type(-1);
570    if ((__wch & (ios_base::in | ios_base::out)) == (ios_base::in | ios_base::out)
571        && __way == ios_base::cur)
572        return pos_type(-1);
573    off_type __noff;
574    switch (__way)
575    {
576    case ios_base::beg:
577        __noff = 0;
578        break;
579    case ios_base::cur:
580        if (__wch & ios_base::in)
581            __noff = this->gptr() - this->eback();
582        else
583            __noff = this->pptr() - this->pbase();
584        break;
585    case ios_base::end:
586        __noff = __hm_ - __str_.data();
587        break;
588    default:
589        return pos_type(-1);
590    }
591    __noff += __off;
592    if (__noff < 0 || __hm_ - __str_.data() < __noff)
593        return pos_type(-1);
594    if (__noff != 0)
595    {
596        if ((__wch & ios_base::in) && this->gptr() == 0)
597            return pos_type(-1);
598        if ((__wch & ios_base::out) && this->pptr() == 0)
599            return pos_type(-1);
600    }
601    if (__wch & ios_base::in)
602        this->setg(this->eback(), this->eback() + __noff, __hm_);
603    if (__wch & ios_base::out)
604    {
605        this->setp(this->pbase(), this->epptr());
606        this->pbump(__noff);
607    }
608    return pos_type(__noff);
609}
610
611template <class _CharT, class _Traits, class _Allocator>
612typename basic_stringbuf<_CharT, _Traits, _Allocator>::pos_type
613basic_stringbuf<_CharT, _Traits, _Allocator>::seekpos(pos_type __sp,
614                                                      ios_base::openmode __wch)
615{
616    return seekoff(__sp, ios_base::beg, __wch);
617}
618
619// basic_istringstream
620
621template <class _CharT, class _Traits, class _Allocator>
622class _LIBCPP_TEMPLATE_VIS basic_istringstream
623    : public basic_istream<_CharT, _Traits>
624{
625public:
626    typedef _CharT                         char_type;
627    typedef _Traits                        traits_type;
628    typedef typename traits_type::int_type int_type;
629    typedef typename traits_type::pos_type pos_type;
630    typedef typename traits_type::off_type off_type;
631    typedef _Allocator                     allocator_type;
632
633    typedef basic_string<char_type, traits_type, allocator_type> string_type;
634
635private:
636    basic_stringbuf<char_type, traits_type, allocator_type> __sb_;
637
638public:
639    // 27.8.2.1 Constructors:
640    inline _LIBCPP_INLINE_VISIBILITY
641    explicit basic_istringstream(ios_base::openmode __wch = ios_base::in);
642    inline _LIBCPP_INLINE_VISIBILITY
643    explicit basic_istringstream(const string_type& __s,
644                                 ios_base::openmode __wch = ios_base::in);
645#ifndef _LIBCPP_CXX03_LANG
646    inline _LIBCPP_INLINE_VISIBILITY
647    basic_istringstream(basic_istringstream&& __rhs);
648
649    // 27.8.2.2 Assign and swap:
650    basic_istringstream& operator=(basic_istringstream&& __rhs);
651#endif  // _LIBCPP_CXX03_LANG
652    inline _LIBCPP_INLINE_VISIBILITY
653    void swap(basic_istringstream& __rhs);
654
655    // 27.8.2.3 Members:
656    inline _LIBCPP_INLINE_VISIBILITY
657    basic_stringbuf<char_type, traits_type, allocator_type>* rdbuf() const;
658    inline _LIBCPP_INLINE_VISIBILITY
659    string_type str() const;
660    inline _LIBCPP_INLINE_VISIBILITY
661    void str(const string_type& __s);
662};
663
664template <class _CharT, class _Traits, class _Allocator>
665basic_istringstream<_CharT, _Traits, _Allocator>::basic_istringstream(ios_base::openmode __wch)
666    : basic_istream<_CharT, _Traits>(&__sb_),
667      __sb_(__wch | ios_base::in)
668{
669}
670
671template <class _CharT, class _Traits, class _Allocator>
672basic_istringstream<_CharT, _Traits, _Allocator>::basic_istringstream(const string_type& __s,
673                                                                      ios_base::openmode __wch)
674    : basic_istream<_CharT, _Traits>(&__sb_),
675      __sb_(__s, __wch | ios_base::in)
676{
677}
678
679#ifndef _LIBCPP_CXX03_LANG
680
681template <class _CharT, class _Traits, class _Allocator>
682basic_istringstream<_CharT, _Traits, _Allocator>::basic_istringstream(basic_istringstream&& __rhs)
683    : basic_istream<_CharT, _Traits>(_VSTD::move(__rhs)),
684      __sb_(_VSTD::move(__rhs.__sb_))
685{
686    basic_istream<_CharT, _Traits>::set_rdbuf(&__sb_);
687}
688
689template <class _CharT, class _Traits, class _Allocator>
690basic_istringstream<_CharT, _Traits, _Allocator>&
691basic_istringstream<_CharT, _Traits, _Allocator>::operator=(basic_istringstream&& __rhs)
692{
693    basic_istream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
694    __sb_ = _VSTD::move(__rhs.__sb_);
695    return *this;
696}
697
698#endif  // _LIBCPP_CXX03_LANG
699
700template <class _CharT, class _Traits, class _Allocator>
701void basic_istringstream<_CharT, _Traits, _Allocator>::swap(basic_istringstream& __rhs)
702{
703    basic_istream<char_type, traits_type>::swap(__rhs);
704    __sb_.swap(__rhs.__sb_);
705}
706
707template <class _CharT, class _Traits, class _Allocator>
708inline _LIBCPP_INLINE_VISIBILITY
709void
710swap(basic_istringstream<_CharT, _Traits, _Allocator>& __x,
711     basic_istringstream<_CharT, _Traits, _Allocator>& __y)
712{
713    __x.swap(__y);
714}
715
716template <class _CharT, class _Traits, class _Allocator>
717basic_stringbuf<_CharT, _Traits, _Allocator>*
718basic_istringstream<_CharT, _Traits, _Allocator>::rdbuf() const
719{
720    return const_cast<basic_stringbuf<char_type, traits_type, allocator_type>*>(&__sb_);
721}
722
723template <class _CharT, class _Traits, class _Allocator>
724basic_string<_CharT, _Traits, _Allocator>
725basic_istringstream<_CharT, _Traits, _Allocator>::str() const
726{
727    return __sb_.str();
728}
729
730template <class _CharT, class _Traits, class _Allocator>
731void basic_istringstream<_CharT, _Traits, _Allocator>::str(const string_type& __s)
732{
733    __sb_.str(__s);
734}
735
736// basic_ostringstream
737
738template <class _CharT, class _Traits, class _Allocator>
739class _LIBCPP_TEMPLATE_VIS basic_ostringstream
740    : public basic_ostream<_CharT, _Traits>
741{
742public:
743    typedef _CharT                         char_type;
744    typedef _Traits                        traits_type;
745    typedef typename traits_type::int_type int_type;
746    typedef typename traits_type::pos_type pos_type;
747    typedef typename traits_type::off_type off_type;
748    typedef _Allocator                     allocator_type;
749
750    typedef basic_string<char_type, traits_type, allocator_type> string_type;
751
752private:
753    basic_stringbuf<char_type, traits_type, allocator_type> __sb_;
754
755public:
756    // 27.8.2.1 Constructors:
757    inline _LIBCPP_INLINE_VISIBILITY
758    explicit basic_ostringstream(ios_base::openmode __wch = ios_base::out);
759    inline _LIBCPP_INLINE_VISIBILITY
760    explicit basic_ostringstream(const string_type& __s,
761                                 ios_base::openmode __wch = ios_base::out);
762#ifndef _LIBCPP_CXX03_LANG
763    inline _LIBCPP_INLINE_VISIBILITY
764    basic_ostringstream(basic_ostringstream&& __rhs);
765
766    // 27.8.2.2 Assign and swap:
767    basic_ostringstream& operator=(basic_ostringstream&& __rhs);
768#endif  // _LIBCPP_CXX03_LANG
769    inline _LIBCPP_INLINE_VISIBILITY
770    void swap(basic_ostringstream& __rhs);
771
772    // 27.8.2.3 Members:
773    inline _LIBCPP_INLINE_VISIBILITY
774    basic_stringbuf<char_type, traits_type, allocator_type>* rdbuf() const;
775    inline _LIBCPP_INLINE_VISIBILITY
776    string_type str() const;
777    inline _LIBCPP_INLINE_VISIBILITY
778    void str(const string_type& __s);
779};
780
781template <class _CharT, class _Traits, class _Allocator>
782basic_ostringstream<_CharT, _Traits, _Allocator>::basic_ostringstream(ios_base::openmode __wch)
783    : basic_ostream<_CharT, _Traits>(&__sb_),
784      __sb_(__wch | ios_base::out)
785{
786}
787
788template <class _CharT, class _Traits, class _Allocator>
789basic_ostringstream<_CharT, _Traits, _Allocator>::basic_ostringstream(const string_type& __s,
790                                                                      ios_base::openmode __wch)
791    : basic_ostream<_CharT, _Traits>(&__sb_),
792      __sb_(__s, __wch | ios_base::out)
793{
794}
795
796#ifndef _LIBCPP_CXX03_LANG
797
798template <class _CharT, class _Traits, class _Allocator>
799basic_ostringstream<_CharT, _Traits, _Allocator>::basic_ostringstream(basic_ostringstream&& __rhs)
800    : basic_ostream<_CharT, _Traits>(_VSTD::move(__rhs)),
801      __sb_(_VSTD::move(__rhs.__sb_))
802{
803    basic_ostream<_CharT, _Traits>::set_rdbuf(&__sb_);
804}
805
806template <class _CharT, class _Traits, class _Allocator>
807basic_ostringstream<_CharT, _Traits, _Allocator>&
808basic_ostringstream<_CharT, _Traits, _Allocator>::operator=(basic_ostringstream&& __rhs)
809{
810    basic_ostream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
811    __sb_ = _VSTD::move(__rhs.__sb_);
812    return *this;
813}
814
815#endif  // _LIBCPP_CXX03_LANG
816
817template <class _CharT, class _Traits, class _Allocator>
818void
819basic_ostringstream<_CharT, _Traits, _Allocator>::swap(basic_ostringstream& __rhs)
820{
821    basic_ostream<char_type, traits_type>::swap(__rhs);
822    __sb_.swap(__rhs.__sb_);
823}
824
825template <class _CharT, class _Traits, class _Allocator>
826inline _LIBCPP_INLINE_VISIBILITY
827void
828swap(basic_ostringstream<_CharT, _Traits, _Allocator>& __x,
829     basic_ostringstream<_CharT, _Traits, _Allocator>& __y)
830{
831    __x.swap(__y);
832}
833
834template <class _CharT, class _Traits, class _Allocator>
835basic_stringbuf<_CharT, _Traits, _Allocator>*
836basic_ostringstream<_CharT, _Traits, _Allocator>::rdbuf() const
837{
838    return const_cast<basic_stringbuf<char_type, traits_type, allocator_type>*>(&__sb_);
839}
840
841template <class _CharT, class _Traits, class _Allocator>
842basic_string<_CharT, _Traits, _Allocator>
843basic_ostringstream<_CharT, _Traits, _Allocator>::str() const
844{
845    return __sb_.str();
846}
847
848template <class _CharT, class _Traits, class _Allocator>
849void
850basic_ostringstream<_CharT, _Traits, _Allocator>::str(const string_type& __s)
851{
852    __sb_.str(__s);
853}
854
855// basic_stringstream
856
857template <class _CharT, class _Traits, class _Allocator>
858class _LIBCPP_TEMPLATE_VIS basic_stringstream
859    : public basic_iostream<_CharT, _Traits>
860{
861public:
862    typedef _CharT                         char_type;
863    typedef _Traits                        traits_type;
864    typedef typename traits_type::int_type int_type;
865    typedef typename traits_type::pos_type pos_type;
866    typedef typename traits_type::off_type off_type;
867    typedef _Allocator                     allocator_type;
868
869    typedef basic_string<char_type, traits_type, allocator_type> string_type;
870
871private:
872    basic_stringbuf<char_type, traits_type, allocator_type> __sb_;
873
874public:
875    // 27.8.2.1 Constructors:
876    inline _LIBCPP_INLINE_VISIBILITY
877    explicit basic_stringstream(ios_base::openmode __wch = ios_base::in | ios_base::out);
878    inline _LIBCPP_INLINE_VISIBILITY
879    explicit basic_stringstream(const string_type& __s,
880                                ios_base::openmode __wch = ios_base::in | ios_base::out);
881#ifndef _LIBCPP_CXX03_LANG
882    inline _LIBCPP_INLINE_VISIBILITY
883    basic_stringstream(basic_stringstream&& __rhs);
884
885    // 27.8.2.2 Assign and swap:
886    basic_stringstream& operator=(basic_stringstream&& __rhs);
887#endif  // _LIBCPP_CXX03_LANG
888    inline _LIBCPP_INLINE_VISIBILITY
889    void swap(basic_stringstream& __rhs);
890
891    // 27.8.2.3 Members:
892    inline _LIBCPP_INLINE_VISIBILITY
893    basic_stringbuf<char_type, traits_type, allocator_type>* rdbuf() const;
894    inline _LIBCPP_INLINE_VISIBILITY
895    string_type str() const;
896    inline _LIBCPP_INLINE_VISIBILITY
897    void str(const string_type& __s);
898};
899
900template <class _CharT, class _Traits, class _Allocator>
901basic_stringstream<_CharT, _Traits, _Allocator>::basic_stringstream(ios_base::openmode __wch)
902    : basic_iostream<_CharT, _Traits>(&__sb_),
903      __sb_(__wch)
904{
905}
906
907template <class _CharT, class _Traits, class _Allocator>
908basic_stringstream<_CharT, _Traits, _Allocator>::basic_stringstream(const string_type& __s,
909                                                                    ios_base::openmode __wch)
910    : basic_iostream<_CharT, _Traits>(&__sb_),
911      __sb_(__s, __wch)
912{
913}
914
915#ifndef _LIBCPP_CXX03_LANG
916
917template <class _CharT, class _Traits, class _Allocator>
918basic_stringstream<_CharT, _Traits, _Allocator>::basic_stringstream(basic_stringstream&& __rhs)
919    : basic_iostream<_CharT, _Traits>(_VSTD::move(__rhs)),
920      __sb_(_VSTD::move(__rhs.__sb_))
921{
922    basic_istream<_CharT, _Traits>::set_rdbuf(&__sb_);
923}
924
925template <class _CharT, class _Traits, class _Allocator>
926basic_stringstream<_CharT, _Traits, _Allocator>&
927basic_stringstream<_CharT, _Traits, _Allocator>::operator=(basic_stringstream&& __rhs)
928{
929    basic_iostream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
930    __sb_ = _VSTD::move(__rhs.__sb_);
931    return *this;
932}
933
934#endif  // _LIBCPP_CXX03_LANG
935
936template <class _CharT, class _Traits, class _Allocator>
937void
938basic_stringstream<_CharT, _Traits, _Allocator>::swap(basic_stringstream& __rhs)
939{
940    basic_iostream<char_type, traits_type>::swap(__rhs);
941    __sb_.swap(__rhs.__sb_);
942}
943
944template <class _CharT, class _Traits, class _Allocator>
945inline _LIBCPP_INLINE_VISIBILITY
946void
947swap(basic_stringstream<_CharT, _Traits, _Allocator>& __x,
948     basic_stringstream<_CharT, _Traits, _Allocator>& __y)
949{
950    __x.swap(__y);
951}
952
953template <class _CharT, class _Traits, class _Allocator>
954basic_stringbuf<_CharT, _Traits, _Allocator>*
955basic_stringstream<_CharT, _Traits, _Allocator>::rdbuf() const
956{
957    return const_cast<basic_stringbuf<char_type, traits_type, allocator_type>*>(&__sb_);
958}
959
960template <class _CharT, class _Traits, class _Allocator>
961basic_string<_CharT, _Traits, _Allocator>
962basic_stringstream<_CharT, _Traits, _Allocator>::str() const
963{
964    return __sb_.str();
965}
966
967template <class _CharT, class _Traits, class _Allocator>
968void
969basic_stringstream<_CharT, _Traits, _Allocator>::str(const string_type& __s)
970{
971    __sb_.str(__s);
972}
973
974_LIBCPP_END_NAMESPACE_STD
975
976_LIBCPP_POP_MACROS
977
978#endif  // _LIBCPP_SSTREAM
979