libstdc++
streambuf
Go to the documentation of this file.
1 // Stream buffer classes -*- C++ -*-
2 
3 // Copyright (C) 1997-2021 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
9 // any later version.
10 
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15 
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
19 
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 // <http://www.gnu.org/licenses/>.
24 
25 /** @file include/streambuf
26  * This is a Standard C++ Library header.
27  */
28 
29 //
30 // ISO C++ 14882: 27.5 Stream buffers
31 //
32 
33 #ifndef _GLIBXX_STREAMBUF
34 #define _GLIBXX_STREAMBUF 1
35 
36 #pragma GCC system_header
37 
38 #include <bits/c++config.h>
39 #include <iosfwd>
40 #include <bits/localefwd.h>
41 #include <bits/ios_base.h>
42 #include <bits/cpp_type_traits.h>
43 #include <ext/type_traits.h>
44 
45 namespace std _GLIBCXX_VISIBILITY(default)
46 {
47 _GLIBCXX_BEGIN_NAMESPACE_VERSION
48 
49 #define _IsUnused __attribute__ ((__unused__))
50 
51  template<typename _CharT, typename _Traits>
53  __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*,
54  basic_streambuf<_CharT, _Traits>*, bool&);
55 
56  /**
57  * @brief The actual work of input and output (interface).
58  * @ingroup io
59  *
60  * @tparam _CharT Type of character stream.
61  * @tparam _Traits Traits for character type, defaults to
62  * char_traits<_CharT>.
63  *
64  * This is a base class. Derived stream buffers each control a
65  * pair of character sequences: one for input, and one for output.
66  *
67  * Section [27.5.1] of the standard describes the requirements and
68  * behavior of stream buffer classes. That section (three paragraphs)
69  * is reproduced here, for simplicity and accuracy.
70  *
71  * -# Stream buffers can impose various constraints on the sequences
72  * they control. Some constraints are:
73  * - The controlled input sequence can be not readable.
74  * - The controlled output sequence can be not writable.
75  * - The controlled sequences can be associated with the contents of
76  * other representations for character sequences, such as external
77  * files.
78  * - The controlled sequences can support operations @e directly to or
79  * from associated sequences.
80  * - The controlled sequences can impose limitations on how the
81  * program can read characters from a sequence, write characters to
82  * a sequence, put characters back into an input sequence, or alter
83  * the stream position.
84  * .
85  * -# Each sequence is characterized by three pointers which, if non-null,
86  * all point into the same @c charT array object. The array object
87  * represents, at any moment, a (sub)sequence of characters from the
88  * sequence. Operations performed on a sequence alter the values
89  * stored in these pointers, perform reads and writes directly to or
90  * from associated sequences, and alter <em>the stream position</em> and
91  * conversion state as needed to maintain this subsequence relationship.
92  * The three pointers are:
93  * - the <em>beginning pointer</em>, or lowest element address in the
94  * array (called @e xbeg here);
95  * - the <em>next pointer</em>, or next element address that is a
96  * current candidate for reading or writing (called @e xnext here);
97  * - the <em>end pointer</em>, or first element address beyond the
98  * end of the array (called @e xend here).
99  * .
100  * -# The following semantic constraints shall always apply for any set
101  * of three pointers for a sequence, using the pointer names given
102  * immediately above:
103  * - If @e xnext is not a null pointer, then @e xbeg and @e xend shall
104  * also be non-null pointers into the same @c charT array, as
105  * described above; otherwise, @e xbeg and @e xend shall also be null.
106  * - If @e xnext is not a null pointer and @e xnext < @e xend for an
107  * output sequence, then a <em>write position</em> is available.
108  * In this case, @e *xnext shall be assignable as the next element
109  * to write (to put, or to store a character value, into the sequence).
110  * - If @e xnext is not a null pointer and @e xbeg < @e xnext for an
111  * input sequence, then a <em>putback position</em> is available.
112  * In this case, @e xnext[-1] shall have a defined value and is the
113  * next (preceding) element to store a character that is put back
114  * into the input sequence.
115  * - If @e xnext is not a null pointer and @e xnext< @e xend for an
116  * input sequence, then a <em>read position</em> is available.
117  * In this case, @e *xnext shall have a defined value and is the
118  * next element to read (to get, or to obtain a character value,
119  * from the sequence).
120  */
121  template<typename _CharT, typename _Traits>
123  {
124  public:
125  ///@{
126  /**
127  * These are standard types. They permit a standardized way of
128  * referring to names of (or names dependent on) the template
129  * parameters, which are specific to the implementation.
130  */
131  typedef _CharT char_type;
132  typedef _Traits traits_type;
133  typedef typename traits_type::int_type int_type;
134  typedef typename traits_type::pos_type pos_type;
135  typedef typename traits_type::off_type off_type;
136  ///@}
137 
138  ///@{
139  /// This is a non-standard type.
141  ///@}
142 
143  friend class basic_ios<char_type, traits_type>;
144  friend class basic_istream<char_type, traits_type>;
145  friend class basic_ostream<char_type, traits_type>;
148 
149  friend streamsize
150  __copy_streambufs_eof<>(basic_streambuf*, basic_streambuf*, bool&);
151 
152  template<bool _IsMove, typename _CharT2>
153  friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
154  _CharT2*>::__type
155  __copy_move_a2(istreambuf_iterator<_CharT2>,
156  istreambuf_iterator<_CharT2>, _CharT2*);
157 
158  template<typename _CharT2>
159  friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
162  const _CharT2&);
163 
164  template<typename _CharT2, typename _Distance>
165  friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
166  void>::__type
167  advance(istreambuf_iterator<_CharT2>&, _Distance);
168 
169  friend void __istream_extract(istream&, char*, streamsize);
170 
171  template<typename _CharT2, typename _Traits2, typename _Alloc>
175 
176  template<typename _CharT2, typename _Traits2, typename _Alloc>
180 
181  protected:
182  /*
183  * This is based on _IO_FILE, just reordered to be more consistent,
184  * and is intended to be the most minimal abstraction for an
185  * internal buffer.
186  * - get == input == read
187  * - put == output == write
188  */
189  char_type* _M_in_beg; ///< Start of get area.
190  char_type* _M_in_cur; ///< Current read area.
191  char_type* _M_in_end; ///< End of get area.
192  char_type* _M_out_beg; ///< Start of put area.
193  char_type* _M_out_cur; ///< Current put area.
194  char_type* _M_out_end; ///< End of put area.
195 
196  /// Current locale setting.
198 
199  public:
200  /// Destructor deallocates no buffer space.
201  virtual
203  { }
204 
205  // [27.5.2.2.1] locales
206  /**
207  * @brief Entry point for imbue().
208  * @param __loc The new locale.
209  * @return The previous locale.
210  *
211  * Calls the derived imbue(__loc).
212  */
213  locale
214  pubimbue(const locale& __loc)
215  {
216  locale __tmp(this->getloc());
217  this->imbue(__loc);
218  _M_buf_locale = __loc;
219  return __tmp;
220  }
221 
222  /**
223  * @brief Locale access.
224  * @return The current locale in effect.
225  *
226  * If pubimbue(loc) has been called, then the most recent @c loc
227  * is returned. Otherwise the global locale in effect at the time
228  * of construction is returned.
229  */
230  locale
231  getloc() const
232  { return _M_buf_locale; }
233 
234  // [27.5.2.2.2] buffer management and positioning
235  ///@{
236  /**
237  * @brief Entry points for derived buffer functions.
238  *
239  * The public versions of @c pubfoo dispatch to the protected
240  * derived @c foo member functions, passing the arguments (if any)
241  * and returning the result unchanged.
242  */
245  { return this->setbuf(__s, __n); }
246 
247  /**
248  * @brief Alters the stream position.
249  * @param __off Offset.
250  * @param __way Value for ios_base::seekdir.
251  * @param __mode Value for ios_base::openmode.
252  *
253  * Calls virtual seekoff function.
254  */
255  pos_type
256  pubseekoff(off_type __off, ios_base::seekdir __way,
257  ios_base::openmode __mode = ios_base::in | ios_base::out)
258  { return this->seekoff(__off, __way, __mode); }
259 
260  /**
261  * @brief Alters the stream position.
262  * @param __sp Position
263  * @param __mode Value for ios_base::openmode.
264  *
265  * Calls virtual seekpos function.
266  */
267  pos_type
269  ios_base::openmode __mode = ios_base::in | ios_base::out)
270  { return this->seekpos(__sp, __mode); }
271 
272  /**
273  * @brief Calls virtual sync function.
274  */
275  int
276  pubsync() { return this->sync(); }
277  ///@}
278 
279  // [27.5.2.2.3] get area
280  /**
281  * @brief Looking ahead into the stream.
282  * @return The number of characters available.
283  *
284  * If a read position is available, returns the number of characters
285  * available for reading before the buffer must be refilled.
286  * Otherwise returns the derived @c showmanyc().
287  */
288  streamsize
290  {
291  const streamsize __ret = this->egptr() - this->gptr();
292  return __ret ? __ret : this->showmanyc();
293  }
294 
295  /**
296  * @brief Getting the next character.
297  * @return The next character, or eof.
298  *
299  * Calls @c sbumpc(), and if that function returns
300  * @c traits::eof(), so does this function. Otherwise, @c sgetc().
301  */
302  int_type
304  {
305  int_type __ret = traits_type::eof();
306  if (__builtin_expect(!traits_type::eq_int_type(this->sbumpc(),
307  __ret), true))
308  __ret = this->sgetc();
309  return __ret;
310  }
311 
312  /**
313  * @brief Getting the next character.
314  * @return The next character, or eof.
315  *
316  * If the input read position is available, returns that character
317  * and increments the read pointer, otherwise calls and returns
318  * @c uflow().
319  */
320  int_type
322  {
323  int_type __ret;
324  if (__builtin_expect(this->gptr() < this->egptr(), true))
325  {
326  __ret = traits_type::to_int_type(*this->gptr());
327  this->gbump(1);
328  }
329  else
330  __ret = this->uflow();
331  return __ret;
332  }
333 
334  /**
335  * @brief Getting the next character.
336  * @return The next character, or eof.
337  *
338  * If the input read position is available, returns that character,
339  * otherwise calls and returns @c underflow(). Does not move the
340  * read position after fetching the character.
341  */
342  int_type
344  {
345  int_type __ret;
346  if (__builtin_expect(this->gptr() < this->egptr(), true))
347  __ret = traits_type::to_int_type(*this->gptr());
348  else
349  __ret = this->underflow();
350  return __ret;
351  }
352 
353  /**
354  * @brief Entry point for xsgetn.
355  * @param __s A buffer area.
356  * @param __n A count.
357  *
358  * Returns xsgetn(__s,__n). The effect is to fill @a __s[0] through
359  * @a __s[__n-1] with characters from the input sequence, if possible.
360  */
361  streamsize
363  { return this->xsgetn(__s, __n); }
364 
365  // [27.5.2.2.4] putback
366  /**
367  * @brief Pushing characters back into the input stream.
368  * @param __c The character to push back.
369  * @return The previous character, if possible.
370  *
371  * Similar to sungetc(), but @a __c is pushed onto the stream
372  * instead of <em>the previous character.</em> If successful,
373  * the next character fetched from the input stream will be @a
374  * __c.
375  */
376  int_type
378  {
379  int_type __ret;
380  const bool __testpos = this->eback() < this->gptr();
381  if (__builtin_expect(!__testpos ||
382  !traits_type::eq(__c, this->gptr()[-1]), false))
383  __ret = this->pbackfail(traits_type::to_int_type(__c));
384  else
385  {
386  this->gbump(-1);
387  __ret = traits_type::to_int_type(*this->gptr());
388  }
389  return __ret;
390  }
391 
392  /**
393  * @brief Moving backwards in the input stream.
394  * @return The previous character, if possible.
395  *
396  * If a putback position is available, this function decrements
397  * the input pointer and returns that character. Otherwise,
398  * calls and returns pbackfail(). The effect is to @a unget
399  * the last character @a gotten.
400  */
401  int_type
403  {
404  int_type __ret;
405  if (__builtin_expect(this->eback() < this->gptr(), true))
406  {
407  this->gbump(-1);
408  __ret = traits_type::to_int_type(*this->gptr());
409  }
410  else
411  __ret = this->pbackfail();
412  return __ret;
413  }
414 
415  // [27.5.2.2.5] put area
416  /**
417  * @brief Entry point for all single-character output functions.
418  * @param __c A character to output.
419  * @return @a __c, if possible.
420  *
421  * One of two public output functions.
422  *
423  * If a write position is available for the output sequence (i.e.,
424  * the buffer is not full), stores @a __c in that position, increments
425  * the position, and returns @c traits::to_int_type(__c). If a write
426  * position is not available, returns @c overflow(__c).
427  */
428  int_type
430  {
431  int_type __ret;
432  if (__builtin_expect(this->pptr() < this->epptr(), true))
433  {
434  *this->pptr() = __c;
435  this->pbump(1);
436  __ret = traits_type::to_int_type(__c);
437  }
438  else
439  __ret = this->overflow(traits_type::to_int_type(__c));
440  return __ret;
441  }
442 
443  /**
444  * @brief Entry point for all single-character output functions.
445  * @param __s A buffer read area.
446  * @param __n A count.
447  *
448  * One of two public output functions.
449  *
450  *
451  * Returns xsputn(__s,__n). The effect is to write @a __s[0] through
452  * @a __s[__n-1] to the output sequence, if possible.
453  */
454  streamsize
455  sputn(const char_type* __s, streamsize __n)
456  { return this->xsputn(__s, __n); }
457 
458  protected:
459  /**
460  * @brief Base constructor.
461  *
462  * Only called from derived constructors, and sets up all the
463  * buffer data to zero, including the pointers described in the
464  * basic_streambuf class description. Note that, as a result,
465  * - the class starts with no read nor write positions available,
466  * - this is not an error
467  */
469  : _M_in_beg(0), _M_in_cur(0), _M_in_end(0),
470  _M_out_beg(0), _M_out_cur(0), _M_out_end(0),
472  { }
473 
474  // [27.5.2.3.1] get area access
475  ///@{
476  /**
477  * @brief Access to the get area.
478  *
479  * These functions are only available to other protected functions,
480  * including derived classes.
481  *
482  * - eback() returns the beginning pointer for the input sequence
483  * - gptr() returns the next pointer for the input sequence
484  * - egptr() returns the end pointer for the input sequence
485  */
486  char_type*
487  eback() const { return _M_in_beg; }
488 
489  char_type*
490  gptr() const { return _M_in_cur; }
491 
492  char_type*
493  egptr() const { return _M_in_end; }
494  ///@}
495 
496  /**
497  * @brief Moving the read position.
498  * @param __n The delta by which to move.
499  *
500  * This just advances the read position without returning any data.
501  */
502  void
503  gbump(int __n) { _M_in_cur += __n; }
504 
505  /**
506  * @brief Setting the three read area pointers.
507  * @param __gbeg A pointer.
508  * @param __gnext A pointer.
509  * @param __gend A pointer.
510  * @post @a __gbeg == @c eback(), @a __gnext == @c gptr(), and
511  * @a __gend == @c egptr()
512  */
513  void
514  setg(char_type* __gbeg, char_type* __gnext, char_type* __gend)
515  {
516  _M_in_beg = __gbeg;
517  _M_in_cur = __gnext;
518  _M_in_end = __gend;
519  }
520 
521  // [27.5.2.3.2] put area access
522  ///@{
523  /**
524  * @brief Access to the put area.
525  *
526  * These functions are only available to other protected functions,
527  * including derived classes.
528  *
529  * - pbase() returns the beginning pointer for the output sequence
530  * - pptr() returns the next pointer for the output sequence
531  * - epptr() returns the end pointer for the output sequence
532  */
533  char_type*
534  pbase() const { return _M_out_beg; }
535 
536  char_type*
537  pptr() const { return _M_out_cur; }
538 
539  char_type*
540  epptr() const { return _M_out_end; }
541  ///@}
542 
543  /**
544  * @brief Moving the write position.
545  * @param __n The delta by which to move.
546  *
547  * This just advances the write position without returning any data.
548  */
549  void
550  pbump(int __n) { _M_out_cur += __n; }
551 
552  /**
553  * @brief Setting the three write area pointers.
554  * @param __pbeg A pointer.
555  * @param __pend A pointer.
556  * @post @a __pbeg == @c pbase(), @a __pbeg == @c pptr(), and
557  * @a __pend == @c epptr()
558  */
559  void
560  setp(char_type* __pbeg, char_type* __pend)
561  {
562  _M_out_beg = _M_out_cur = __pbeg;
563  _M_out_end = __pend;
564  }
565 
566  // [27.5.2.4] virtual functions
567  // [27.5.2.4.1] locales
568  /**
569  * @brief Changes translations.
570  * @param __loc A new locale.
571  *
572  * Translations done during I/O which depend on the current
573  * locale are changed by this call. The standard adds,
574  * <em>Between invocations of this function a class derived
575  * from streambuf can safely cache results of calls to locale
576  * functions and to members of facets so obtained.</em>
577  *
578  * @note Base class version does nothing.
579  */
580  virtual void
581  imbue(const locale& __loc _IsUnused)
582  { }
583 
584  // [27.5.2.4.2] buffer management and positioning
585  /**
586  * @brief Manipulates the buffer.
587  *
588  * Each derived class provides its own appropriate behavior. See
589  * the next-to-last paragraph of
590  * https://gcc.gnu.org/onlinedocs/libstdc++/manual/streambufs.html#io.streambuf.buffering
591  * for more on this function.
592  *
593  * @note Base class version does nothing, returns @c this.
594  */
597  { return this; }
598 
599  /**
600  * @brief Alters the stream positions.
601  *
602  * Each derived class provides its own appropriate behavior.
603  * @note Base class version does nothing, returns a @c pos_type
604  * that represents an invalid stream position.
605  */
606  virtual pos_type
607  seekoff(off_type, ios_base::seekdir,
608  ios_base::openmode /*__mode*/ = ios_base::in | ios_base::out)
609  { return pos_type(off_type(-1)); }
610 
611  /**
612  * @brief Alters the stream positions.
613  *
614  * Each derived class provides its own appropriate behavior.
615  * @note Base class version does nothing, returns a @c pos_type
616  * that represents an invalid stream position.
617  */
618  virtual pos_type
620  ios_base::openmode /*__mode*/ = ios_base::in | ios_base::out)
621  { return pos_type(off_type(-1)); }
622 
623  /**
624  * @brief Synchronizes the buffer arrays with the controlled sequences.
625  * @return -1 on failure.
626  *
627  * Each derived class provides its own appropriate behavior,
628  * including the definition of @a failure.
629  * @note Base class version does nothing, returns zero.
630  */
631  virtual int
632  sync() { return 0; }
633 
634  // [27.5.2.4.3] get area
635  /**
636  * @brief Investigating the data available.
637  * @return An estimate of the number of characters available in the
638  * input sequence, or -1.
639  *
640  * <em>If it returns a positive value, then successive calls to
641  * @c underflow() will not return @c traits::eof() until at
642  * least that number of characters have been supplied. If @c
643  * showmanyc() returns -1, then calls to @c underflow() or @c
644  * uflow() will fail.</em> [27.5.2.4.3]/1
645  *
646  * @note Base class version does nothing, returns zero.
647  * @note The standard adds that <em>the intention is not only that the
648  * calls [to underflow or uflow] will not return @c eof() but
649  * that they will return immediately.</em>
650  * @note The standard adds that <em>the morphemes of @c showmanyc are
651  * @b es-how-many-see, not @b show-manic.</em>
652  */
653  virtual streamsize
654  showmanyc() { return 0; }
655 
656  /**
657  * @brief Multiple character extraction.
658  * @param __s A buffer area.
659  * @param __n Maximum number of characters to assign.
660  * @return The number of characters assigned.
661  *
662  * Fills @a __s[0] through @a __s[__n-1] with characters from the input
663  * sequence, as if by @c sbumpc(). Stops when either @a __n characters
664  * have been copied, or when @c traits::eof() would be copied.
665  *
666  * It is expected that derived classes provide a more efficient
667  * implementation by overriding this definition.
668  */
669  virtual streamsize
670  xsgetn(char_type* __s, streamsize __n);
671 
672  /**
673  * @brief Fetches more data from the controlled sequence.
674  * @return The first character from the <em>pending sequence</em>.
675  *
676  * Informally, this function is called when the input buffer is
677  * exhausted (or does not exist, as buffering need not actually be
678  * done). If a buffer exists, it is @a refilled. In either case, the
679  * next available character is returned, or @c traits::eof() to
680  * indicate a null pending sequence.
681  *
682  * For a formal definition of the pending sequence, see a good text
683  * such as Langer & Kreft, or [27.5.2.4.3]/7-14.
684  *
685  * A functioning input streambuf can be created by overriding only
686  * this function (no buffer area will be used). For an example, see
687  * https://gcc.gnu.org/onlinedocs/libstdc++/manual/streambufs.html
688  *
689  * @note Base class version does nothing, returns eof().
690  */
691  virtual int_type
693  { return traits_type::eof(); }
694 
695  /**
696  * @brief Fetches more data from the controlled sequence.
697  * @return The first character from the <em>pending sequence</em>.
698  *
699  * Informally, this function does the same thing as @c underflow(),
700  * and in fact is required to call that function. It also returns
701  * the new character, like @c underflow() does. However, this
702  * function also moves the read position forward by one.
703  */
704  virtual int_type
706  {
707  int_type __ret = traits_type::eof();
708  const bool __testeof = traits_type::eq_int_type(this->underflow(),
709  __ret);
710  if (!__testeof)
711  {
712  __ret = traits_type::to_int_type(*this->gptr());
713  this->gbump(1);
714  }
715  return __ret;
716  }
717 
718  // [27.5.2.4.4] putback
719  /**
720  * @brief Tries to back up the input sequence.
721  * @param __c The character to be inserted back into the sequence.
722  * @return eof() on failure, <em>some other value</em> on success
723  * @post The constraints of @c gptr(), @c eback(), and @c pptr()
724  * are the same as for @c underflow().
725  *
726  * @note Base class version does nothing, returns eof().
727  */
728  virtual int_type
729  pbackfail(int_type __c _IsUnused = traits_type::eof())
730  { return traits_type::eof(); }
731 
732  // Put area:
733  /**
734  * @brief Multiple character insertion.
735  * @param __s A buffer area.
736  * @param __n Maximum number of characters to write.
737  * @return The number of characters written.
738  *
739  * Writes @a __s[0] through @a __s[__n-1] to the output sequence, as if
740  * by @c sputc(). Stops when either @a n characters have been
741  * copied, or when @c sputc() would return @c traits::eof().
742  *
743  * It is expected that derived classes provide a more efficient
744  * implementation by overriding this definition.
745  */
746  virtual streamsize
747  xsputn(const char_type* __s, streamsize __n);
748 
749  /**
750  * @brief Consumes data from the buffer; writes to the
751  * controlled sequence.
752  * @param __c An additional character to consume.
753  * @return eof() to indicate failure, something else (usually
754  * @a __c, or not_eof())
755  *
756  * Informally, this function is called when the output buffer
757  * is full (or does not exist, as buffering need not actually
758  * be done). If a buffer exists, it is @a consumed, with
759  * <em>some effect</em> on the controlled sequence.
760  * (Typically, the buffer is written out to the sequence
761  * verbatim.) In either case, the character @a c is also
762  * written out, if @a __c is not @c eof().
763  *
764  * For a formal definition of this function, see a good text
765  * such as Langer & Kreft, or [27.5.2.4.5]/3-7.
766  *
767  * A functioning output streambuf can be created by overriding only
768  * this function (no buffer area will be used).
769  *
770  * @note Base class version does nothing, returns eof().
771  */
772  virtual int_type
773  overflow(int_type __c _IsUnused = traits_type::eof())
774  { return traits_type::eof(); }
775 
776 #if _GLIBCXX_USE_DEPRECATED && __cplusplus <= 201402L
777  // Annex D.6 (removed in C++17)
778  public:
779  /**
780  * @brief Tosses a character.
781  *
782  * Advances the read pointer, ignoring the character that would have
783  * been read.
784  *
785  * See http://gcc.gnu.org/ml/libstdc++/2002-05/msg00168.html
786  */
787  _GLIBCXX_DEPRECATED_SUGGEST("std::basic_streambuf::sbumpc")
788  void
789  stossc()
790  {
791  if (this->gptr() < this->egptr())
792  this->gbump(1);
793  else
794  this->uflow();
795  }
796 #endif
797 
798  // Also used by specializations for char and wchar_t in src.
799  void
800  __safe_gbump(streamsize __n) { _M_in_cur += __n; }
801 
802  void
803  __safe_pbump(streamsize __n) { _M_out_cur += __n; }
804 
805 #if __cplusplus < 201103L
806  private:
807 #else
808  protected:
809 #endif
811 
813  operator=(const basic_streambuf&);
814 
815 #if __cplusplus >= 201103L
816  void
817  swap(basic_streambuf& __sb)
818  {
819  std::swap(_M_in_beg, __sb._M_in_beg);
820  std::swap(_M_in_cur, __sb._M_in_cur);
821  std::swap(_M_in_end, __sb._M_in_end);
822  std::swap(_M_out_beg, __sb._M_out_beg);
823  std::swap(_M_out_cur, __sb._M_out_cur);
824  std::swap(_M_out_end, __sb._M_out_end);
825  std::swap(_M_buf_locale, __sb._M_buf_locale);
826  }
827 #endif
828  };
829 
830 #if __cplusplus >= 201103L
831  template<typename _CharT, typename _Traits>
833  basic_streambuf(const basic_streambuf&) = default;
834 
835  template<typename _CharT, typename _Traits>
838  operator=(const basic_streambuf&) = default;
839 #endif
840 
841  // Explicit specialization declarations, defined in src/streambuf.cc.
842  template<>
843  streamsize
844  __copy_streambufs_eof(basic_streambuf<char>* __sbin,
845  basic_streambuf<char>* __sbout, bool& __ineof);
846 #ifdef _GLIBCXX_USE_WCHAR_T
847  template<>
848  streamsize
849  __copy_streambufs_eof(basic_streambuf<wchar_t>* __sbin,
850  basic_streambuf<wchar_t>* __sbout, bool& __ineof);
851 #endif
852 
853 #undef _IsUnused
854 
855 _GLIBCXX_END_NAMESPACE_VERSION
856 } // namespace
857 
858 #include <bits/streambuf.tcc>
859 
860 #endif /* _GLIBCXX_STREAMBUF */
void swap(any &__x, any &__y) noexcept
Exchange the states of two any objects.
Definition: any:422
ISO C++ entities toplevel namespace is std.
std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, bitset< _Nb > &__x)
Global I/O operators for bitsets.
Definition: bitset:1472
ptrdiff_t streamsize
Integral type for I/O operation counts and buffer sizes.
Definition: postypes.h:68
basic_istream< _CharT, _Traits > & getline(basic_istream< _CharT, _Traits > &__is, basic_string< _CharT, _Traits, _Alloc > &__str, _CharT __delim)
Read a line from stream into a string.
Template class basic_ios, virtual base class for all stream classes.
Definition: basic_ios.h:68
The actual work of input and output (interface).
Definition: streambuf:123
virtual pos_type seekpos(pos_type, ios_base::openmode=ios_base::in|ios_base::out)
Alters the stream positions.
Definition: streambuf:619
char_type * _M_in_beg
Start of get area.
Definition: streambuf:189
locale getloc() const
Locale access.
Definition: streambuf:231
traits_type::int_type int_type
Definition: streambuf:133
basic_streambuf< char_type, traits_type > __streambuf_type
This is a non-standard type.
Definition: streambuf:140
virtual int_type overflow(int_type __c=traits_type::eof())
Consumes data from the buffer; writes to the controlled sequence.
Definition: streambuf:773
virtual streamsize xsputn(const char_type *__s, streamsize __n)
Multiple character insertion.
Definition: streambuf.tcc:80
pos_type pubseekpos(pos_type __sp, ios_base::openmode __mode=ios_base::in|ios_base::out)
Alters the stream position.
Definition: streambuf:268
char_type * gptr() const
Access to the get area.
Definition: streambuf:490
void setg(char_type *__gbeg, char_type *__gnext, char_type *__gend)
Setting the three read area pointers.
Definition: streambuf:514
char_type * pbase() const
Access to the put area.
Definition: streambuf:534
virtual int sync()
Synchronizes the buffer arrays with the controlled sequences.
Definition: streambuf:632
virtual int_type uflow()
Fetches more data from the controlled sequence.
Definition: streambuf:705
basic_streambuf * pubsetbuf(char_type *__s, streamsize __n)
Entry points for derived buffer functions.
Definition: streambuf:244
traits_type::pos_type pos_type
Definition: streambuf:134
streamsize sputn(const char_type *__s, streamsize __n)
Entry point for all single-character output functions.
Definition: streambuf:455
virtual streamsize xsgetn(char_type *__s, streamsize __n)
Multiple character extraction.
Definition: streambuf.tcc:46
char_type * _M_out_beg
Start of put area.
Definition: streambuf:192
char_type * epptr() const
Access to the put area.
Definition: streambuf:540
int_type snextc()
Getting the next character.
Definition: streambuf:303
virtual void imbue(const locale &__loc)
Changes translations.
Definition: streambuf:581
int_type sbumpc()
Getting the next character.
Definition: streambuf:321
char_type * _M_in_cur
Current read area.
Definition: streambuf:190
streamsize sgetn(char_type *__s, streamsize __n)
Entry point for xsgetn.
Definition: streambuf:362
char_type * _M_out_cur
Current put area.
Definition: streambuf:193
virtual streamsize showmanyc()
Investigating the data available.
Definition: streambuf:654
int_type sungetc()
Moving backwards in the input stream.
Definition: streambuf:402
virtual int_type pbackfail(int_type __c=traits_type::eof())
Tries to back up the input sequence.
Definition: streambuf:729
locale pubimbue(const locale &__loc)
Entry point for imbue().
Definition: streambuf:214
streamsize in_avail()
Looking ahead into the stream.
Definition: streambuf:289
void gbump(int __n)
Moving the read position.
Definition: streambuf:503
char_type * eback() const
Access to the get area.
Definition: streambuf:487
virtual int_type underflow()
Fetches more data from the controlled sequence.
Definition: streambuf:692
virtual basic_streambuf< char_type, _Traits > * setbuf(char_type *, streamsize)
Manipulates the buffer.
Definition: streambuf:596
void setp(char_type *__pbeg, char_type *__pend)
Setting the three write area pointers.
Definition: streambuf:560
_Traits traits_type
Definition: streambuf:132
pos_type pubseekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode=ios_base::in|ios_base::out)
Alters the stream position.
Definition: streambuf:256
void pbump(int __n)
Moving the write position.
Definition: streambuf:550
int_type sgetc()
Getting the next character.
Definition: streambuf:343
int pubsync()
Calls virtual sync function.
Definition: streambuf:276
char_type * egptr() const
Access to the get area.
Definition: streambuf:493
virtual pos_type seekoff(off_type, ios_base::seekdir, ios_base::openmode=ios_base::in|ios_base::out)
Alters the stream positions.
Definition: streambuf:607
char_type * _M_in_end
End of get area.
Definition: streambuf:191
virtual ~basic_streambuf()
Destructor deallocates no buffer space.
Definition: streambuf:202
traits_type::off_type off_type
Definition: streambuf:135
int_type sputbackc(char_type __c)
Pushing characters back into the input stream.
Definition: streambuf:377
locale _M_buf_locale
Current locale setting.
Definition: streambuf:197
char_type * _M_out_end
End of put area.
Definition: streambuf:194
int_type sputc(char_type __c)
Entry point for all single-character output functions.
Definition: streambuf:429
char_type * pptr() const
Access to the put area.
Definition: streambuf:537
basic_streambuf()
Base constructor.
Definition: streambuf:468
Template class basic_istream.
Definition: istream:59
Template class basic_ostream.
Definition: ostream:59
Provides input iterator semantics for streambufs.
Provides output iterator semantics for streambufs.
Managing sequences of characters and character-like objects.
static const openmode in
Open for input. Default for ifstream and fstream.
Definition: ios_base.h:461
static const openmode out
Open for output. Default for ofstream and fstream.
Definition: ios_base.h:464
Container class for localization functionality.