external/bsd/libc++/dist/libcxx/include/streambuf

   1 // -*- C++ -*-
   2 //===------------------------- streambuf ----------------------------------===//
   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_STEAMBUF
  12 #define _LIBCPP_STEAMBUF
  13
  14 /*
  15     streambuf synopsis
  16
  17 namespace std
  18 {
  19
  20 template <class charT, class traits = char_traits<charT> >
  21 class basic_streambuf
  22 {
  23 public:
  24     // types:
  25     typedef charT char_type;
  26     typedef traits traits_type;
  27     typedef typename traits_type::int_type int_type;
  28     typedef typename traits_type::pos_type pos_type;
  29     typedef typename traits_type::off_type off_type;
  30
  31     virtual ~basic_streambuf();
  32
  33     // 27.6.2.2.1 locales:
  34     locale pubimbue(const locale& loc);
  35     locale getloc() const;
  36
  37     // 27.6.2.2.2 buffer and positioning:
  38     basic_streambuf* pubsetbuf(char_type* s, streamsize n);
  39     pos_type pubseekoff(off_type off, ios_base::seekdir way,
  40                         ios_base::openmode which = ios_base::in | ios_base::out);
  41     pos_type pubseekpos(pos_type sp,
  42                         ios_base::openmode which = ios_base::in | ios_base::out);
  43     int pubsync();
  44
  45     // Get and put areas:
  46     // 27.6.2.2.3 Get area:
  47     streamsize in_avail();
  48     int_type snextc();
  49     int_type sbumpc();
  50     int_type sgetc();
  51     streamsize sgetn(char_type* s, streamsize n);
  52
  53     // 27.6.2.2.4 Putback:
  54     int_type sputbackc(char_type c);
  55     int_type sungetc();
  56
  57     // 27.6.2.2.5 Put area:
  58     int_type sputc(char_type c);
  59     streamsize sputn(const char_type* s, streamsize n);
  60
  61 protected:
  62     basic_streambuf();
  63     basic_streambuf(const basic_streambuf& rhs);
  64     basic_streambuf& operator=(const basic_streambuf& rhs);
  65     void swap(basic_streambuf& rhs);
  66
  67     // 27.6.2.3.2 Get area:
  68     char_type* eback() const;
  69     char_type* gptr() const;
  70     char_type* egptr() const;
  71     void gbump(int n);
  72     void setg(char_type* gbeg, char_type* gnext, char_type* gend);
  73
  74     // 27.6.2.3.3 Put area:
  75     char_type* pbase() const;
  76     char_type* pptr() const;
  77     char_type* epptr() const;
  78     void pbump(int n);
  79     void setp(char_type* pbeg, char_type* pend);
  80
  81     // 27.6.2.4 virtual functions:
  82     // 27.6.2.4.1 Locales:
  83     virtual void imbue(const locale& loc);
  84
  85     // 27.6.2.4.2 Buffer management and positioning:
  86     virtual basic_streambuf* setbuf(char_type* s, streamsize n);
  87     virtual pos_type seekoff(off_type off, ios_base::seekdir way,
  88                              ios_base::openmode which = ios_base::in | ios_base::out);
  89     virtual pos_type seekpos(pos_type sp,
  90                              ios_base::openmode which = ios_base::in | ios_base::out);
  91     virtual int sync();
  92
  93     // 27.6.2.4.3 Get area:
  94     virtual streamsize showmanyc();
  95     virtual streamsize xsgetn(char_type* s, streamsize n);
  96     virtual int_type underflow();
  97     virtual int_type uflow();
  98
  99     // 27.6.2.4.4 Putback:
 100     virtual int_type pbackfail(int_type c = traits_type::eof());
 101
 102     // 27.6.2.4.5 Put area:
 103     virtual streamsize xsputn(const char_type* s, streamsize n);
 104     virtual int_type overflow (int_type c = traits_type::eof());
 105 };
 106
 107 }  // std
 108
 109 */
 110
 111 #include <__config>
 112 #include <iosfwd>
 113 #include <ios>
 114
 115 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 116 #pragma GCC system_header
 117 #endif
 118
 119 _LIBCPP_BEGIN_NAMESPACE_STD
 120
 121 template <class _CharT, class _Traits>
 122 class _LIBCPP_TYPE_VIS_ONLY basic_streambuf
 123 {
 124 public:
 125     // types:
 126     typedef _CharT                         char_type;
 127     typedef _Traits                        traits_type;
 128     typedef typename traits_type::int_type int_type;
 129     typedef typename traits_type::pos_type pos_type;
 130     typedef typename traits_type::off_type off_type;
 131
 132     virtual ~basic_streambuf();
 133
 134     // 27.6.2.2.1 locales:
 135     locale pubimbue(const locale& __loc);
 136     locale getloc() const;
 137
 138     // 27.6.2.2.2 buffer and positioning:
 139     basic_streambuf* pubsetbuf(char_type* __s, streamsize __n);
 140     pos_type pubseekoff(off_type __off, ios_base::seekdir __way,
 141                         ios_base::openmode __which = ios_base::in | ios_base::out);
 142     pos_type pubseekpos(pos_type __sp,
 143                         ios_base::openmode __which = ios_base::in | ios_base::out);
 144     int pubsync();
 145
 146     // Get and put areas:
 147     // 27.6.2.2.3 Get area:
 148     streamsize in_avail();
 149     int_type snextc();
 150     int_type sbumpc();
 151     int_type sgetc();
 152     streamsize sgetn(char_type* __s, streamsize __n);
 153
 154     // 27.6.2.2.4 Putback:
 155     int_type sputbackc(char_type __c);
 156     int_type sungetc();
 157
 158     // 27.6.2.2.5 Put area:
 159     int_type sputc(char_type __c);
 160     streamsize sputn(const char_type* __s, streamsize __n);
 161
 162 protected:
 163     basic_streambuf();
 164     basic_streambuf(const basic_streambuf& __rhs);
 165     basic_streambuf& operator=(const basic_streambuf& __rhs);
 166     void swap(basic_streambuf& __rhs);
 167
 168     // 27.6.2.3.2 Get area:
 169     _LIBCPP_ALWAYS_INLINE char_type* eback() const {return __binp_;}
 170     _LIBCPP_ALWAYS_INLINE char_type* gptr()  const {return __ninp_;}
 171     _LIBCPP_ALWAYS_INLINE char_type* egptr() const {return __einp_;}
 172     void gbump(int __n);
 173     void setg(char_type* __gbeg, char_type* __gnext, char_type* __gend);
 174
 175     // 27.6.2.3.3 Put area:
 176     _LIBCPP_ALWAYS_INLINE char_type* pbase() const {return __bout_;}
 177     _LIBCPP_ALWAYS_INLINE char_type* pptr()  const {return __nout_;}
 178     _LIBCPP_ALWAYS_INLINE char_type* epptr() const {return __eout_;}
 179     void pbump(int __n);
 180     void setp(char_type* __pbeg, char_type* __pend);
 181
 182     // 27.6.2.4 virtual functions:
 183     // 27.6.2.4.1 Locales:
 184     virtual void imbue(const locale& __loc);
 185
 186     // 27.6.2.4.2 Buffer management and positioning:
 187     virtual basic_streambuf* setbuf(char_type* __s, streamsize __n);
 188     virtual pos_type seekoff(off_type __off, ios_base::seekdir __way,
 189                              ios_base::openmode __which = ios_base::in | ios_base::out);
 190     virtual pos_type seekpos(pos_type __sp,
 191                              ios_base::openmode __which = ios_base::in | ios_base::out);
 192     virtual int sync();
 193
 194     // 27.6.2.4.3 Get area:
 195     virtual streamsize showmanyc();
 196     virtual streamsize xsgetn(char_type* __s, streamsize __n);
 197     virtual int_type underflow();
 198     virtual int_type uflow();
 199
 200     // 27.6.2.4.4 Putback:
 201     virtual int_type pbackfail(int_type __c = traits_type::eof());
 202
 203     // 27.6.2.4.5 Put area:
 204     virtual streamsize xsputn(const char_type* __s, streamsize __n);
 205     virtual int_type overflow(int_type __c = traits_type::eof());
 206
 207 private:
 208     locale __loc_;
 209     char_type* __binp_;
 210     char_type* __ninp_;
 211     char_type* __einp_;
 212     char_type* __bout_;
 213     char_type* __nout_;
 214     char_type* __eout_;
 215 };
 216
 217 template <class _CharT, class _Traits>
 218 basic_streambuf<_CharT, _Traits>::~basic_streambuf()
 219 {
 220 }
 221
 222 template <class _CharT, class _Traits>
 223 inline _LIBCPP_INLINE_VISIBILITY
 224 locale
 225 basic_streambuf<_CharT, _Traits>::pubimbue(const locale& __loc)
 226 {
 227     imbue(__loc);
 228     locale __r = __loc_;
 229     __loc_ = __loc;
 230     return __r;
 231 }
 232
 233 template <class _CharT, class _Traits>
 234 inline _LIBCPP_INLINE_VISIBILITY
 235 locale
 236 basic_streambuf<_CharT, _Traits>::getloc() const
 237 {
 238     return __loc_;
 239 }
 240
 241 template <class _CharT, class _Traits>
 242 inline _LIBCPP_INLINE_VISIBILITY
 243 basic_streambuf<_CharT, _Traits>*
 244 basic_streambuf<_CharT, _Traits>::pubsetbuf(char_type* __s, streamsize __n)
 245 {
 246     return setbuf(__s, __n);
 247 }
 248
 249 template <class _CharT, class _Traits>
 250 inline _LIBCPP_INLINE_VISIBILITY
 251 typename basic_streambuf<_CharT, _Traits>::pos_type
 252 basic_streambuf<_CharT, _Traits>::pubseekoff(off_type __off,
 253                                              ios_base::seekdir __way,
 254                                              ios_base::openmode __which)
 255 {
 256     return seekoff(__off, __way, __which);
 257 }
 258
 259 template <class _CharT, class _Traits>
 260 inline _LIBCPP_INLINE_VISIBILITY
 261 typename basic_streambuf<_CharT, _Traits>::pos_type
 262 basic_streambuf<_CharT, _Traits>::pubseekpos(pos_type __sp,
 263                                              ios_base::openmode __which)
 264 {
 265     return seekpos(__sp, __which);
 266 }
 267
 268 template <class _CharT, class _Traits>
 269 inline _LIBCPP_INLINE_VISIBILITY
 270 int
 271 basic_streambuf<_CharT, _Traits>::pubsync()
 272 {
 273     return sync();
 274 }
 275
 276 template <class _CharT, class _Traits>
 277 inline _LIBCPP_INLINE_VISIBILITY
 278 streamsize
 279 basic_streambuf<_CharT, _Traits>::in_avail()
 280 {
 281     if (__ninp_ < __einp_)
 282         return static_cast<streamsize>(__einp_ - __ninp_);
 283     return showmanyc();
 284 }
 285
 286 template <class _CharT, class _Traits>
 287 inline _LIBCPP_INLINE_VISIBILITY
 288 typename basic_streambuf<_CharT, _Traits>::int_type
 289 basic_streambuf<_CharT, _Traits>::snextc()
 290 {
 291     if (sbumpc() == traits_type::eof())
 292         return traits_type::eof();
 293     return sgetc();
 294 }
 295
 296 template <class _CharT, class _Traits>
 297 inline _LIBCPP_INLINE_VISIBILITY
 298 typename basic_streambuf<_CharT, _Traits>::int_type
 299 basic_streambuf<_CharT, _Traits>::sbumpc()
 300 {
 301     if (__ninp_ == __einp_)
 302         return uflow();
 303     return traits_type::to_int_type(*__ninp_++);
 304 }
 305
 306 template <class _CharT, class _Traits>
 307 inline _LIBCPP_INLINE_VISIBILITY
 308 typename basic_streambuf<_CharT, _Traits>::int_type
 309 basic_streambuf<_CharT, _Traits>::sgetc()
 310 {
 311     if (__ninp_ == __einp_)
 312         return underflow();
 313     return traits_type::to_int_type(*__ninp_);
 314 }
 315
 316 template <class _CharT, class _Traits>
 317 inline _LIBCPP_INLINE_VISIBILITY
 318 streamsize
 319 basic_streambuf<_CharT, _Traits>::sgetn(char_type* __s, streamsize __n)
 320 {
 321     return xsgetn(__s, __n);
 322 }
 323
 324 template <class _CharT, class _Traits>
 325 inline _LIBCPP_INLINE_VISIBILITY
 326 typename basic_streambuf<_CharT, _Traits>::int_type
 327 basic_streambuf<_CharT, _Traits>::sputbackc(char_type __c)
 328 {
 329     if (__binp_ == __ninp_ || !traits_type::eq(__c, __ninp_[-1]))
 330         return pbackfail(traits_type::to_int_type(__c));
 331     return traits_type::to_int_type(*--__ninp_);
 332 }
 333
 334 template <class _CharT, class _Traits>
 335 inline _LIBCPP_INLINE_VISIBILITY
 336 typename basic_streambuf<_CharT, _Traits>::int_type
 337 basic_streambuf<_CharT, _Traits>::sungetc()
 338 {
 339     if (__binp_ == __ninp_)
 340         return pbackfail();
 341     return traits_type::to_int_type(*--__ninp_);
 342 }
 343
 344 template <class _CharT, class _Traits>
 345 inline _LIBCPP_INLINE_VISIBILITY
 346 typename basic_streambuf<_CharT, _Traits>::int_type
 347 basic_streambuf<_CharT, _Traits>::sputc(char_type __c)
 348 {
 349     if (__nout_ == __eout_)
 350         return overflow(traits_type::to_int_type(__c));
 351     *__nout_++ = __c;
 352     return traits_type::to_int_type(__c);
 353 }
 354
 355 template <class _CharT, class _Traits>
 356 inline _LIBCPP_INLINE_VISIBILITY
 357 streamsize
 358 basic_streambuf<_CharT, _Traits>::sputn(const char_type* __s, streamsize __n)
 359 {
 360     return xsputn(__s, __n);
 361 }
 362
 363 template <class _CharT, class _Traits>
 364 basic_streambuf<_CharT, _Traits>::basic_streambuf()
 365     : __binp_(0),
 366       __ninp_(0),
 367       __einp_(0),
 368       __bout_(0),
 369       __nout_(0),
 370       __eout_(0)
 371 {
 372 }
 373
 374 template <class _CharT, class _Traits>
 375 basic_streambuf<_CharT, _Traits>::basic_streambuf(const basic_streambuf& __sb)
 376     : __loc_(__sb.__loc_),
 377       __binp_(__sb.__binp_),
 378       __ninp_(__sb.__ninp_),
 379       __einp_(__sb.__einp_),
 380       __bout_(__sb.__bout_),
 381       __nout_(__sb.__nout_),
 382       __eout_(__sb.__eout_)
 383 {
 384 }
 385
 386 template <class _CharT, class _Traits>
 387 basic_streambuf<_CharT, _Traits>&
 388 basic_streambuf<_CharT, _Traits>::operator=(const basic_streambuf& __sb)
 389 {
 390     __loc_ = __sb.__loc_;
 391     __binp_ = __sb.__binp_;
 392     __ninp_ = __sb.__ninp_;
 393     __einp_ = __sb.__einp_;
 394     __bout_ = __sb.__bout_;
 395     __nout_ = __sb.__nout_;
 396     __eout_ = __sb.__eout_;
 397     return *this;
 398 }
 399
 400 template <class _CharT, class _Traits>
 401 void
 402 basic_streambuf<_CharT, _Traits>::swap(basic_streambuf& __sb)
 403 {
 404     _VSTD::swap(__loc_, __sb.__loc_);
 405     _VSTD::swap(__binp_, __sb.__binp_);
 406     _VSTD::swap(__ninp_, __sb.__ninp_);
 407     _VSTD::swap(__einp_, __sb.__einp_);
 408     _VSTD::swap(__bout_, __sb.__bout_);
 409     _VSTD::swap(__nout_, __sb.__nout_);
 410     _VSTD::swap(__eout_, __sb.__eout_);
 411 }
 412
 413 template <class _CharT, class _Traits>
 414 inline _LIBCPP_INLINE_VISIBILITY
 415 void
 416 basic_streambuf<_CharT, _Traits>::gbump(int __n)
 417 {
 418     __ninp_ += __n;
 419 }
 420
 421 template <class _CharT, class _Traits>
 422 inline _LIBCPP_INLINE_VISIBILITY
 423 void
 424 basic_streambuf<_CharT, _Traits>::setg(char_type* __gbeg, char_type* __gnext,
 425                                                           char_type* __gend)
 426 {
 427     __binp_ = __gbeg;
 428     __ninp_ = __gnext;
 429     __einp_ = __gend;
 430 }
 431
 432 template <class _CharT, class _Traits>
 433 inline _LIBCPP_INLINE_VISIBILITY
 434 void
 435 basic_streambuf<_CharT, _Traits>::pbump(int __n)
 436 {
 437     __nout_ += __n;
 438 }
 439
 440 template <class _CharT, class _Traits>
 441 inline _LIBCPP_INLINE_VISIBILITY
 442 void
 443 basic_streambuf<_CharT, _Traits>::setp(char_type* __pbeg, char_type* __pend)
 444 {
 445     __bout_ = __nout_ = __pbeg;
 446     __eout_ = __pend;
 447 }
 448
 449 template <class _CharT, class _Traits>
 450 void
 451 basic_streambuf<_CharT, _Traits>::imbue(const locale&)
 452 {
 453 }
 454
 455 template <class _CharT, class _Traits>
 456 basic_streambuf<_CharT, _Traits>*
 457 basic_streambuf<_CharT, _Traits>::setbuf(char_type*, streamsize)
 458 {
 459     return this;
 460 }
 461
 462 template <class _CharT, class _Traits>
 463 typename basic_streambuf<_CharT, _Traits>::pos_type
 464 basic_streambuf<_CharT, _Traits>::seekoff(off_type, ios_base::seekdir,
 465                                           ios_base::openmode)
 466 {
 467     return pos_type(off_type(-1));
 468 }
 469
 470 template <class _CharT, class _Traits>
 471 typename basic_streambuf<_CharT, _Traits>::pos_type
 472 basic_streambuf<_CharT, _Traits>::seekpos(pos_type, ios_base::openmode)
 473 {
 474     return pos_type(off_type(-1));
 475 }
 476
 477 template <class _CharT, class _Traits>
 478 int
 479 basic_streambuf<_CharT, _Traits>::sync()
 480 {
 481     return 0;
 482 }
 483
 484 template <class _CharT, class _Traits>
 485 streamsize
 486 basic_streambuf<_CharT, _Traits>::showmanyc()
 487 {
 488     return 0;
 489 }
 490
 491 template <class _CharT, class _Traits>
 492 streamsize
 493 basic_streambuf<_CharT, _Traits>::xsgetn(char_type* __s, streamsize __n)
 494 {
 495     const int_type __eof = traits_type::eof();
 496     int_type __c;
 497     streamsize __i = 0;
 498     for (;__i < __n; ++__i, ++__s)
 499     {
 500         if (__ninp_ < __einp_)
 501             *__s = *__ninp_++;
 502         else if ((__c = uflow()) != __eof)
 503             *__s = traits_type::to_char_type(__c);
 504         else
 505             break;
 506     }
 507     return __i;
 508 }
 509
 510 template <class _CharT, class _Traits>
 511 typename basic_streambuf<_CharT, _Traits>::int_type
 512 basic_streambuf<_CharT, _Traits>::underflow()
 513 {
 514     return traits_type::eof();
 515 }
 516
 517 template <class _CharT, class _Traits>
 518 typename basic_streambuf<_CharT, _Traits>::int_type
 519 basic_streambuf<_CharT, _Traits>::uflow()
 520 {
 521     if (underflow() == traits_type::eof())
 522         return traits_type::eof();
 523     return traits_type::to_int_type(*__ninp_++);
 524 }
 525
 526 template <class _CharT, class _Traits>
 527 typename basic_streambuf<_CharT, _Traits>::int_type
 528 basic_streambuf<_CharT, _Traits>::pbackfail(int_type)
 529 {
 530     return traits_type::eof();
 531 }
 532
 533 template <class _CharT, class _Traits>
 534 streamsize
 535 basic_streambuf<_CharT, _Traits>::xsputn(const char_type* __s, streamsize __n)
 536 {
 537     streamsize __i = 0;
 538     int_type __eof = traits_type::eof();
 539     while( __i < __n)
 540     {
 541         if (__nout_ >= __eout_)
 542         {
 543             if (overflow(traits_type::to_int_type(*__s)) == __eof)
 544                 break;
 545             ++__s;
 546             ++__i;
 547         }
 548         else
 549         {
 550             streamsize __chunk_size = _VSTD::min(__eout_ - __nout_, __n - __i);
 551             traits_type::copy(__nout_, __s, __chunk_size);
 552             __nout_ += __chunk_size;
 553             __s     += __chunk_size;
 554             __i     += __chunk_size;
 555         }
 556     }
 557     return __i;
 558 }
 559
 560 template <class _CharT, class _Traits>
 561 typename basic_streambuf<_CharT, _Traits>::int_type
 562 basic_streambuf<_CharT, _Traits>::overflow(int_type)
 563 {
 564     return traits_type::eof();
 565 }
 566
 567 _LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_TYPE_VIS basic_streambuf<char>)
 568 _LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_TYPE_VIS basic_streambuf<wchar_t>)
 569
 570 _LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_TYPE_VIS basic_ios<char>)
 571 _LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_TYPE_VIS basic_ios<wchar_t>)
 572
 573 _LIBCPP_END_NAMESPACE_STD
 574
 575 #endif  // _LIBCPP_STEAMBUF