contrib/libc++/include/sstream

   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
  17 template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
  18 class basic_stringbuf
  19     : public basic_streambuf<charT, traits>
  20 {
  21 public:
  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
  43 protected:
  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
  55 template <class charT, class traits, class Allocator>
  56   void swap(basic_stringbuf<charT, traits, Allocator>& x,
  57             basic_stringbuf<charT, traits, Allocator>& y);
  58
  59 typedef basic_stringbuf<char>    stringbuf;
  60 typedef basic_stringbuf<wchar_t> wstringbuf;
  61
  62 template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
  63 class basic_istringstream
  64     : public basic_istream<charT, traits>
  65 {
  66 public:
  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
  90 template <class charT, class traits, class Allocator>
  91   void swap(basic_istringstream<charT, traits, Allocator>& x,
  92             basic_istringstream<charT, traits, Allocator>& y);
  93
  94 typedef basic_istringstream<char>    istringstream;
  95 typedef basic_istringstream<wchar_t> wistringstream;
  96
  97 template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
  98 class basic_ostringstream
  99     : public basic_ostream<charT, traits>
 100 {
 101 public:
 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
 126 template <class charT, class traits, class Allocator>
 127   void swap(basic_ostringstream<charT, traits, Allocator>& x,
 128             basic_ostringstream<charT, traits, Allocator>& y);
 129
 130 typedef basic_ostringstream<char>    ostringstream;
 131 typedef basic_ostringstream<wchar_t> wostringstream;
 132
 133 template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
 134 class basic_stringstream
 135     : public basic_iostream<charT, traits>
 136 {
 137 public:
 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
 162 template <class charT, class traits, class Allocator>
 163   void swap(basic_stringstream<charT, traits, Allocator>& x,
 164             basic_stringstream<charT, traits, Allocator>& y);
 165
 166 typedef basic_stringstream<char>    stringstream;
 167 typedef 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
 190 template <class _CharT, class _Traits, class _Allocator>
 191 class _LIBCPP_TEMPLATE_VIS basic_stringbuf
 192     : public basic_streambuf<_CharT, _Traits>
 193 {
 194 public:
 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
 204 private:
 205
 206     string_type __str_;
 207     mutable char_type* __hm_;
 208     ios_base::openmode __mode_;
 209
 210 public:
 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
 229 protected:
 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
 241 template <class _CharT, class _Traits, class _Allocator>
 242 basic_stringbuf<_CharT, _Traits, _Allocator>::basic_stringbuf(ios_base::openmode __wch)
 243     : __hm_(0),
 244       __mode_(__wch)
 245 {
 246     str(string_type());
 247 }
 248
 249 template <class _CharT, class _Traits, class _Allocator>
 250 basic_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
 261 template <class _CharT, class _Traits, class _Allocator>
 262 basic_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
 302 template <class _CharT, class _Traits, class _Allocator>
 303 basic_stringbuf<_CharT, _Traits, _Allocator>&
 304 basic_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
 352 template <class _CharT, class _Traits, class _Allocator>
 353 void
 354 basic_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
 429 template <class _CharT, class _Traits, class _Allocator>
 430 inline _LIBCPP_INLINE_VISIBILITY
 431 void
 432 swap(basic_stringbuf<_CharT, _Traits, _Allocator>& __x,
 433      basic_stringbuf<_CharT, _Traits, _Allocator>& __y)
 434 {
 435     __x.swap(__y);
 436 }
 437
 438 template <class _CharT, class _Traits, class _Allocator>
 439 basic_string<_CharT, _Traits, _Allocator>
 440 basic_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
 453 template <class _CharT, class _Traits, class _Allocator>
 454 void
 455 basic_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
 478 template <class _CharT, class _Traits, class _Allocator>
 479 typename basic_stringbuf<_CharT, _Traits, _Allocator>::int_type
 480 basic_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
 494 template <class _CharT, class _Traits, class _Allocator>
 495 typename basic_stringbuf<_CharT, _Traits, _Allocator>::int_type
 496 basic_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
 518 template <class _CharT, class _Traits, class _Allocator>
 519 typename basic_stringbuf<_CharT, _Traits, _Allocator>::int_type
 520 basic_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
 560 template <class _CharT, class _Traits, class _Allocator>
 561 typename basic_stringbuf<_CharT, _Traits, _Allocator>::pos_type
 562 basic_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
 611 template <class _CharT, class _Traits, class _Allocator>
 612 typename basic_stringbuf<_CharT, _Traits, _Allocator>::pos_type
 613 basic_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
 621 template <class _CharT, class _Traits, class _Allocator>
 622 class _LIBCPP_TEMPLATE_VIS basic_istringstream
 623     : public basic_istream<_CharT, _Traits>
 624 {
 625 public:
 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
 635 private:
 636     basic_stringbuf<char_type, traits_type, allocator_type> __sb_;
 637
 638 public:
 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
 664 template <class _CharT, class _Traits, class _Allocator>
 665 basic_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
 671 template <class _CharT, class _Traits, class _Allocator>
 672 basic_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
 681 template <class _CharT, class _Traits, class _Allocator>
 682 basic_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
 689 template <class _CharT, class _Traits, class _Allocator>
 690 basic_istringstream<_CharT, _Traits, _Allocator>&
 691 basic_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
 700 template <class _CharT, class _Traits, class _Allocator>
 701 void 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
 707 template <class _CharT, class _Traits, class _Allocator>
 708 inline _LIBCPP_INLINE_VISIBILITY
 709 void
 710 swap(basic_istringstream<_CharT, _Traits, _Allocator>& __x,
 711      basic_istringstream<_CharT, _Traits, _Allocator>& __y)
 712 {
 713     __x.swap(__y);
 714 }
 715
 716 template <class _CharT, class _Traits, class _Allocator>
 717 basic_stringbuf<_CharT, _Traits, _Allocator>*
 718 basic_istringstream<_CharT, _Traits, _Allocator>::rdbuf() const
 719 {
 720     return const_cast<basic_stringbuf<char_type, traits_type, allocator_type>*>(&__sb_);
 721 }
 722
 723 template <class _CharT, class _Traits, class _Allocator>
 724 basic_string<_CharT, _Traits, _Allocator>
 725 basic_istringstream<_CharT, _Traits, _Allocator>::str() const
 726 {
 727     return __sb_.str();
 728 }
 729
 730 template <class _CharT, class _Traits, class _Allocator>
 731 void basic_istringstream<_CharT, _Traits, _Allocator>::str(const string_type& __s)
 732 {
 733     __sb_.str(__s);
 734 }
 735
 736 // basic_ostringstream
 737
 738 template <class _CharT, class _Traits, class _Allocator>
 739 class _LIBCPP_TEMPLATE_VIS basic_ostringstream
 740     : public basic_ostream<_CharT, _Traits>
 741 {
 742 public:
 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
 752 private:
 753     basic_stringbuf<char_type, traits_type, allocator_type> __sb_;
 754
 755 public:
 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
 781 template <class _CharT, class _Traits, class _Allocator>
 782 basic_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
 788 template <class _CharT, class _Traits, class _Allocator>
 789 basic_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
 798 template <class _CharT, class _Traits, class _Allocator>
 799 basic_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
 806 template <class _CharT, class _Traits, class _Allocator>
 807 basic_ostringstream<_CharT, _Traits, _Allocator>&
 808 basic_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
 817 template <class _CharT, class _Traits, class _Allocator>
 818 void
 819 basic_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
 825 template <class _CharT, class _Traits, class _Allocator>
 826 inline _LIBCPP_INLINE_VISIBILITY
 827 void
 828 swap(basic_ostringstream<_CharT, _Traits, _Allocator>& __x,
 829      basic_ostringstream<_CharT, _Traits, _Allocator>& __y)
 830 {
 831     __x.swap(__y);
 832 }
 833
 834 template <class _CharT, class _Traits, class _Allocator>
 835 basic_stringbuf<_CharT, _Traits, _Allocator>*
 836 basic_ostringstream<_CharT, _Traits, _Allocator>::rdbuf() const
 837 {
 838     return const_cast<basic_stringbuf<char_type, traits_type, allocator_type>*>(&__sb_);
 839 }
 840
 841 template <class _CharT, class _Traits, class _Allocator>
 842 basic_string<_CharT, _Traits, _Allocator>
 843 basic_ostringstream<_CharT, _Traits, _Allocator>::str() const
 844 {
 845     return __sb_.str();
 846 }
 847
 848 template <class _CharT, class _Traits, class _Allocator>
 849 void
 850 basic_ostringstream<_CharT, _Traits, _Allocator>::str(const string_type& __s)
 851 {
 852     __sb_.str(__s);
 853 }
 854
 855 // basic_stringstream
 856
 857 template <class _CharT, class _Traits, class _Allocator>
 858 class _LIBCPP_TEMPLATE_VIS basic_stringstream
 859     : public basic_iostream<_CharT, _Traits>
 860 {
 861 public:
 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
 871 private:
 872     basic_stringbuf<char_type, traits_type, allocator_type> __sb_;
 873
 874 public:
 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
 900 template <class _CharT, class _Traits, class _Allocator>
 901 basic_stringstream<_CharT, _Traits, _Allocator>::basic_stringstream(ios_base::openmode __wch)
 902     : basic_iostream<_CharT, _Traits>(&__sb_),
 903       __sb_(__wch)
 904 {
 905 }
 906
 907 template <class _CharT, class _Traits, class _Allocator>
 908 basic_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
 917 template <class _CharT, class _Traits, class _Allocator>
 918 basic_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
 925 template <class _CharT, class _Traits, class _Allocator>
 926 basic_stringstream<_CharT, _Traits, _Allocator>&
 927 basic_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
 936 template <class _CharT, class _Traits, class _Allocator>
 937 void
 938 basic_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
 944 template <class _CharT, class _Traits, class _Allocator>
 945 inline _LIBCPP_INLINE_VISIBILITY
 946 void
 947 swap(basic_stringstream<_CharT, _Traits, _Allocator>& __x,
 948      basic_stringstream<_CharT, _Traits, _Allocator>& __y)
 949 {
 950     __x.swap(__y);
 951 }
 952
 953 template <class _CharT, class _Traits, class _Allocator>
 954 basic_stringbuf<_CharT, _Traits, _Allocator>*
 955 basic_stringstream<_CharT, _Traits, _Allocator>::rdbuf() const
 956 {
 957     return const_cast<basic_stringbuf<char_type, traits_type, allocator_type>*>(&__sb_);
 958 }
 959
 960 template <class _CharT, class _Traits, class _Allocator>
 961 basic_string<_CharT, _Traits, _Allocator>
 962 basic_stringstream<_CharT, _Traits, _Allocator>::str() const
 963 {
 964     return __sb_.str();
 965 }
 966
 967 template <class _CharT, class _Traits, class _Allocator>
 968 void
 969 basic_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