1// Stream buffer classes -*- C++ -*- 
2 
3// Copyright (C) 1997-2019 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 
45namespace std _GLIBCXX_VISIBILITY(default) 
46{ 
47_GLIBCXX_BEGIN_NAMESPACE_VERSION 
48 
49#define _IsUnused __attribute__ ((__unused__)) 
50 
51 template<typename _CharT, typename _Traits> 
52 streamsize 
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> 
122 class basic_streambuf 
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. 
140 typedef basic_streambuf<char_type, traits_type> __streambuf_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>; 
146 friend class istreambuf_iterator<char_type, traits_type>; 
147 friend class ostreambuf_iterator<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, 
160 istreambuf_iterator<_CharT2> >::__type 
161 find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, 
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 template<typename _CharT2, typename _Traits2> 
170 friend basic_istream<_CharT2, _Traits2>& 
171 operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*); 
172 
173 template<typename _CharT2, typename _Traits2, typename _Alloc> 
174 friend basic_istream<_CharT2, _Traits2>& 
175 operator>>(basic_istream<_CharT2, _Traits2>&, 
176 basic_string<_CharT2, _Traits2, _Alloc>&); 
177 
178 template<typename _CharT2, typename _Traits2, typename _Alloc> 
179 friend basic_istream<_CharT2, _Traits2>& 
180 getline(basic_istream<_CharT2, _Traits2>&, 
181 basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2); 
182 
183 protected: 
184 /* 
185 * This is based on _IO_FILE, just reordered to be more consistent, 
186 * and is intended to be the most minimal abstraction for an 
187 * internal buffer. 
188 * - get == input == read 
189 * - put == output == write 
190 */ 
191 char_type* _M_in_beg; ///< Start of get area. 
192 char_type* _M_in_cur; ///< Current read area. 
193 char_type* _M_in_end; ///< End of get area. 
194 char_type* _M_out_beg; ///< Start of put area. 
195 char_type* _M_out_cur; ///< Current put area. 
196 char_type* _M_out_end; ///< End of put area. 
197 
198 /// Current locale setting. 
199 locale _M_buf_locale; 
200 
201 public: 
202 /// Destructor deallocates no buffer space. 
203 virtual 
204 ~basic_streambuf() 
205 { } 
206 
207 // [27.5.2.2.1] locales 
208 /** 
209 * @brief Entry point for imbue(). 
210 * @param __loc The new locale. 
211 * @return The previous locale. 
212 * 
213 * Calls the derived imbue(__loc). 
214 */ 
215 locale 
216 pubimbue(const locale& __loc) 
217 { 
218 locale __tmp(this->getloc()); 
219 this->imbue(__loc); 
220 _M_buf_locale = __loc; 
221 return __tmp; 
222 } 
223 
224 /** 
225 * @brief Locale access. 
226 * @return The current locale in effect. 
227 * 
228 * If pubimbue(loc) has been called, then the most recent @c loc 
229 * is returned. Otherwise the global locale in effect at the time 
230 * of construction is returned. 
231 */ 
232 locale 
233 getloc() const 
234 { return _M_buf_locale; } 
235 
236 // [27.5.2.2.2] buffer management and positioning 
237 //@{ 
238 /** 
239 * @brief Entry points for derived buffer functions. 
240 * 
241 * The public versions of @c pubfoo dispatch to the protected 
242 * derived @c foo member functions, passing the arguments (if any) 
243 * and returning the result unchanged. 
244 */ 
245 basic_streambuf* 
246 pubsetbuf(char_type* __s, streamsize __n) 
247 { return this->setbuf(__s, __n); } 
248 
249 /** 
250 * @brief Alters the stream position. 
251 * @param __off Offset. 
252 * @param __way Value for ios_base::seekdir. 
253 * @param __mode Value for ios_base::openmode. 
254 * 
255 * Calls virtual seekoff function. 
256 */ 
257 pos_type 
258 pubseekoff(off_type __off, ios_base::seekdir __way, 
259 ios_base::openmode __mode = ios_base::in | ios_base::out) 
260 { return this->seekoff(__off, __way, __mode); } 
261 
262 /** 
263 * @brief Alters the stream position. 
264 * @param __sp Position 
265 * @param __mode Value for ios_base::openmode. 
266 * 
267 * Calls virtual seekpos function. 
268 */ 
269 pos_type 
270 pubseekpos(pos_type __sp, 
271 ios_base::openmode __mode = ios_base::in | ios_base::out) 
272 { return this->seekpos(__sp, __mode); } 
273 
274 /** 
275 * @brief Calls virtual sync function. 
276 */ 
277 int 
278 pubsync() { return this->sync(); } 
279 //@} 
280 
281 // [27.5.2.2.3] get area 
282 /** 
283 * @brief Looking ahead into the stream. 
284 * @return The number of characters available. 
285 * 
286 * If a read position is available, returns the number of characters 
287 * available for reading before the buffer must be refilled. 
288 * Otherwise returns the derived @c showmanyc(). 
289 */ 
290 streamsize 
291 in_avail() 
292 { 
293 const streamsize __ret = this->egptr() - this->gptr(); 
294 return __ret ? __ret : this->showmanyc(); 
295 } 
296 
297 /** 
298 * @brief Getting the next character. 
299 * @return The next character, or eof. 
300 * 
301 * Calls @c sbumpc(), and if that function returns 
302 * @c traits::eof(), so does this function. Otherwise, @c sgetc(). 
303 */ 
304 int_type 
305 snextc() 
306 { 
307 int_type __ret = traits_type::eof(); 
308 if (__builtin_expect(!traits_type::eq_int_type(this->sbumpc(), 
309 __ret), true)) 
310 __ret = this->sgetc(); 
311 return __ret; 
312 } 
313 
314 /** 
315 * @brief Getting the next character. 
316 * @return The next character, or eof. 
317 * 
318 * If the input read position is available, returns that character 
319 * and increments the read pointer, otherwise calls and returns 
320 * @c uflow(). 
321 */ 
322 int_type 
323 sbumpc() 
324 { 
325 int_type __ret; 
326 if (__builtin_expect(this->gptr() < this->egptr(), true)) 
327 { 
328 __ret = traits_type::to_int_type(*this->gptr()); 
329 this->gbump(1); 
330 } 
331 else 
332 __ret = this->uflow(); 
333 return __ret; 
334 } 
335 
336 /** 
337 * @brief Getting the next character. 
338 * @return The next character, or eof. 
339 * 
340 * If the input read position is available, returns that character, 
341 * otherwise calls and returns @c underflow(). Does not move the 
342 * read position after fetching the character. 
343 */ 
344 int_type 
345 sgetc() 
346 { 
347 int_type __ret; 
348 if (__builtin_expect(this->gptr() < this->egptr(), true)) 
349 __ret = traits_type::to_int_type(*this->gptr()); 
350 else 
351 __ret = this->underflow(); 
352 return __ret; 
353 } 
354 
355 /** 
356 * @brief Entry point for xsgetn. 
357 * @param __s A buffer area. 
358 * @param __n A count. 
359 * 
360 * Returns xsgetn(__s,__n). The effect is to fill @a __s[0] through 
361 * @a __s[__n-1] with characters from the input sequence, if possible. 
362 */ 
363 streamsize 
364 sgetn(char_type* __s, streamsize __n) 
365 { return this->xsgetn(__s, __n); } 
366 
367 // [27.5.2.2.4] putback 
368 /** 
369 * @brief Pushing characters back into the input stream. 
370 * @param __c The character to push back. 
371 * @return The previous character, if possible. 
372 * 
373 * Similar to sungetc(), but @a __c is pushed onto the stream 
374 * instead of <em>the previous character.</em> If successful, 
375 * the next character fetched from the input stream will be @a 
376 * __c. 
377 */ 
378 int_type 
379 sputbackc(char_type __c) 
380 { 
381 int_type __ret; 
382 const bool __testpos = this->eback() < this->gptr(); 
383 if (__builtin_expect(!__testpos || 
384 !traits_type::eq(__c, this->gptr()[-1]), false)) 
385 __ret = this->pbackfail(traits_type::to_int_type(__c)); 
386 else 
387 { 
388 this->gbump(-1); 
389 __ret = traits_type::to_int_type(*this->gptr()); 
390 } 
391 return __ret; 
392 } 
393 
394 /** 
395 * @brief Moving backwards in the input stream. 
396 * @return The previous character, if possible. 
397 * 
398 * If a putback position is available, this function decrements 
399 * the input pointer and returns that character. Otherwise, 
400 * calls and returns pbackfail(). The effect is to @a unget 
401 * the last character @a gotten. 
402 */ 
403 int_type 
404 sungetc() 
405 { 
406 int_type __ret; 
407 if (__builtin_expect(this->eback() < this->gptr(), true)) 
408 { 
409 this->gbump(-1); 
410 __ret = traits_type::to_int_type(*this->gptr()); 
411 } 
412 else 
413 __ret = this->pbackfail(); 
414 return __ret; 
415 } 
416 
417 // [27.5.2.2.5] put area 
418 /** 
419 * @brief Entry point for all single-character output functions. 
420 * @param __c A character to output. 
421 * @return @a __c, if possible. 
422 * 
423 * One of two public output functions. 
424 * 
425 * If a write position is available for the output sequence (i.e., 
426 * the buffer is not full), stores @a __c in that position, increments 
427 * the position, and returns @c traits::to_int_type(__c). If a write 
428 * position is not available, returns @c overflow(__c). 
429 */ 
430 int_type 
431 sputc(char_type __c) 
432 { 
433 int_type __ret; 
434 if (__builtin_expect(this->pptr() < this->epptr(), true)) 
435 { 
436 *this->pptr() = __c; 
437 this->pbump(1); 
438 __ret = traits_type::to_int_type(__c); 
439 } 
440 else 
441 __ret = this->overflow(traits_type::to_int_type(__c)); 
442 return __ret; 
443 } 
444 
445 /** 
446 * @brief Entry point for all single-character output functions. 
447 * @param __s A buffer read area. 
448 * @param __n A count. 
449 * 
450 * One of two public output functions. 
451 * 
452 * 
453 * Returns xsputn(__s,__n). The effect is to write @a __s[0] through 
454 * @a __s[__n-1] to the output sequence, if possible. 
455 */ 
456 streamsize 
457 sputn(const char_type* __s, streamsize __n) 
458 { return this->xsputn(__s, __n); } 
459 
460 protected: 
461 /** 
462 * @brief Base constructor. 
463 * 
464 * Only called from derived constructors, and sets up all the 
465 * buffer data to zero, including the pointers described in the 
466 * basic_streambuf class description. Note that, as a result, 
467 * - the class starts with no read nor write positions available, 
468 * - this is not an error 
469 */ 
470 basic_streambuf() 
471 : _M_in_beg(0), _M_in_cur(0), _M_in_end(0), 
472 _M_out_beg(0), _M_out_cur(0), _M_out_end(0), 
473 _M_buf_locale(locale()) 
474 { } 
475 
476 // [27.5.2.3.1] get area access 
477 //@{ 
478 /** 
479 * @brief Access to the get area. 
480 * 
481 * These functions are only available to other protected functions, 
482 * including derived classes. 
483 * 
484 * - eback() returns the beginning pointer for the input sequence 
485 * - gptr() returns the next pointer for the input sequence 
486 * - egptr() returns the end pointer for the input sequence 
487 */ 
488 char_type* 
489 eback() const { return _M_in_beg; } 
490 
491 char_type* 
492 gptr() const { return _M_in_cur; } 
493 
494 char_type* 
495 egptr() const { return _M_in_end; } 
496 //@} 
497 
498 /** 
499 * @brief Moving the read position. 
500 * @param __n The delta by which to move. 
501 * 
502 * This just advances the read position without returning any data. 
503 */ 
504 void 
505 gbump(int __n) { _M_in_cur += __n; } 
506 
507 /** 
508 * @brief Setting the three read area pointers. 
509 * @param __gbeg A pointer. 
510 * @param __gnext A pointer. 
511 * @param __gend A pointer. 
512 * @post @a __gbeg == @c eback(), @a __gnext == @c gptr(), and 
513 * @a __gend == @c egptr() 
514 */ 
515 void 
516 setg(char_type* __gbeg, char_type* __gnext, char_type* __gend) 
517 { 
518 _M_in_beg = __gbeg; 
519 _M_in_cur = __gnext; 
520 _M_in_end = __gend; 
521 } 
522 
523 // [27.5.2.3.2] put area access 
524 //@{ 
525 /** 
526 * @brief Access to the put area. 
527 * 
528 * These functions are only available to other protected functions, 
529 * including derived classes. 
530 * 
531 * - pbase() returns the beginning pointer for the output sequence 
532 * - pptr() returns the next pointer for the output sequence 
533 * - epptr() returns the end pointer for the output sequence 
534 */ 
535 char_type* 
536 pbase() const { return _M_out_beg; } 
537 
538 char_type* 
539 pptr() const { return _M_out_cur; } 
540 
541 char_type* 
542 epptr() const { return _M_out_end; } 
543 //@} 
544 
545 /** 
546 * @brief Moving the write position. 
547 * @param __n The delta by which to move. 
548 * 
549 * This just advances the write position without returning any data. 
550 */ 
551 void 
552 pbump(int __n) { _M_out_cur += __n; } 
553 
554 /** 
555 * @brief Setting the three write area pointers. 
556 * @param __pbeg A pointer. 
557 * @param __pend A pointer. 
558 * @post @a __pbeg == @c pbase(), @a __pbeg == @c pptr(), and 
559 * @a __pend == @c epptr() 
560 */ 
561 void 
562 setp(char_type* __pbeg, char_type* __pend) 
563 { 
564 _M_out_beg = _M_out_cur = __pbeg; 
565 _M_out_end = __pend; 
566 } 
567 
568 // [27.5.2.4] virtual functions 
569 // [27.5.2.4.1] locales 
570 /** 
571 * @brief Changes translations. 
572 * @param __loc A new locale. 
573 * 
574 * Translations done during I/O which depend on the current 
575 * locale are changed by this call. The standard adds, 
576 * <em>Between invocations of this function a class derived 
577 * from streambuf can safely cache results of calls to locale 
578 * functions and to members of facets so obtained.</em> 
579 * 
580 * @note Base class version does nothing. 
581 */ 
582 virtual void 
583 imbue(const locale& __loc _IsUnused) 
584 { } 
585 
586 // [27.5.2.4.2] buffer management and positioning 
587 /** 
588 * @brief Manipulates the buffer. 
589 * 
590 * Each derived class provides its own appropriate behavior. See 
591 * the next-to-last paragraph of 
592 * https://gcc.gnu.org/onlinedocs/libstdc++/manual/streambufs.html#io.streambuf.buffering 
593 * for more on this function. 
594 * 
595 * @note Base class version does nothing, returns @c this. 
596 */ 
597 virtual basic_streambuf<char_type,_Traits>* 
598 setbuf(char_type*, streamsize) 
599 { return this; } 
600 
601 /** 
602 * @brief Alters the stream positions. 
603 * 
604 * Each derived class provides its own appropriate behavior. 
605 * @note Base class version does nothing, returns a @c pos_type 
606 * that represents an invalid stream position. 
607 */ 
608 virtual pos_type 
609 seekoff(off_type, ios_base::seekdir, 
610 ios_base::openmode /*__mode*/ = ios_base::in | ios_base::out) 
611 { return pos_type(off_type(-1)); } 
612 
613 /** 
614 * @brief Alters the stream positions. 
615 * 
616 * Each derived class provides its own appropriate behavior. 
617 * @note Base class version does nothing, returns a @c pos_type 
618 * that represents an invalid stream position. 
619 */ 
620 virtual pos_type 
621 seekpos(pos_type, 
622 ios_base::openmode /*__mode*/ = ios_base::in | ios_base::out) 
623 { return pos_type(off_type(-1)); } 
624 
625 /** 
626 * @brief Synchronizes the buffer arrays with the controlled sequences. 
627 * @return -1 on failure. 
628 * 
629 * Each derived class provides its own appropriate behavior, 
630 * including the definition of @a failure. 
631 * @note Base class version does nothing, returns zero. 
632 */ 
633 virtual int 
634 sync() { return 0; } 
635 
636 // [27.5.2.4.3] get area 
637 /** 
638 * @brief Investigating the data available. 
639 * @return An estimate of the number of characters available in the 
640 * input sequence, or -1. 
641 * 
642 * <em>If it returns a positive value, then successive calls to 
643 * @c underflow() will not return @c traits::eof() until at 
644 * least that number of characters have been supplied. If @c 
645 * showmanyc() returns -1, then calls to @c underflow() or @c 
646 * uflow() will fail.</em> [27.5.2.4.3]/1 
647 * 
648 * @note Base class version does nothing, returns zero. 
649 * @note The standard adds that <em>the intention is not only that the 
650 * calls [to underflow or uflow] will not return @c eof() but 
651 * that they will return immediately.</em> 
652 * @note The standard adds that <em>the morphemes of @c showmanyc are 
653 * @b es-how-many-see, not @b show-manic.</em> 
654 */ 
655 virtual streamsize 
656 showmanyc() { return 0; } 
657 
658 /** 
659 * @brief Multiple character extraction. 
660 * @param __s A buffer area. 
661 * @param __n Maximum number of characters to assign. 
662 * @return The number of characters assigned. 
663 * 
664 * Fills @a __s[0] through @a __s[__n-1] with characters from the input 
665 * sequence, as if by @c sbumpc(). Stops when either @a __n characters 
666 * have been copied, or when @c traits::eof() would be copied. 
667 * 
668 * It is expected that derived classes provide a more efficient 
669 * implementation by overriding this definition. 
670 */ 
671 virtual streamsize 
672 xsgetn(char_type* __s, streamsize __n); 
673 
674 /** 
675 * @brief Fetches more data from the controlled sequence. 
676 * @return The first character from the <em>pending sequence</em>. 
677 * 
678 * Informally, this function is called when the input buffer is 
679 * exhausted (or does not exist, as buffering need not actually be 
680 * done). If a buffer exists, it is @a refilled. In either case, the 
681 * next available character is returned, or @c traits::eof() to 
682 * indicate a null pending sequence. 
683 * 
684 * For a formal definition of the pending sequence, see a good text 
685 * such as Langer & Kreft, or [27.5.2.4.3]/7-14. 
686 * 
687 * A functioning input streambuf can be created by overriding only 
688 * this function (no buffer area will be used). For an example, see 
689 * https://gcc.gnu.org/onlinedocs/libstdc++/manual/streambufs.html 
690 * 
691 * @note Base class version does nothing, returns eof(). 
692 */ 
693 virtual int_type 
694 underflow() 
695 { return traits_type::eof(); } 
696 
697 /** 
698 * @brief Fetches more data from the controlled sequence. 
699 * @return The first character from the <em>pending sequence</em>. 
700 * 
701 * Informally, this function does the same thing as @c underflow(), 
702 * and in fact is required to call that function. It also returns 
703 * the new character, like @c underflow() does. However, this 
704 * function also moves the read position forward by one. 
705 */ 
706 virtual int_type 
707 uflow() 
708 { 
709 int_type __ret = traits_type::eof(); 
710 const bool __testeof = traits_type::eq_int_type(this->underflow(), 
711 __ret); 
712 if (!__testeof) 
713 { 
714 __ret = traits_type::to_int_type(*this->gptr()); 
715 this->gbump(1); 
716 } 
717 return __ret; 
718 } 
719 
720 // [27.5.2.4.4] putback 
721 /** 
722 * @brief Tries to back up the input sequence. 
723 * @param __c The character to be inserted back into the sequence. 
724 * @return eof() on failure, <em>some other value</em> on success 
725 * @post The constraints of @c gptr(), @c eback(), and @c pptr() 
726 * are the same as for @c underflow(). 
727 * 
728 * @note Base class version does nothing, returns eof(). 
729 */ 
730 virtual int_type 
731 pbackfail(int_type __c _IsUnused = traits_type::eof()) 
732 { return traits_type::eof(); } 
733 
734 // Put area: 
735 /** 
736 * @brief Multiple character insertion. 
737 * @param __s A buffer area. 
738 * @param __n Maximum number of characters to write. 
739 * @return The number of characters written. 
740 * 
741 * Writes @a __s[0] through @a __s[__n-1] to the output sequence, as if 
742 * by @c sputc(). Stops when either @a n characters have been 
743 * copied, or when @c sputc() would return @c traits::eof(). 
744 * 
745 * It is expected that derived classes provide a more efficient 
746 * implementation by overriding this definition. 
747 */ 
748 virtual streamsize 
749 xsputn(const char_type* __s, streamsize __n); 
750 
751 /** 
752 * @brief Consumes data from the buffer; writes to the 
753 * controlled sequence. 
754 * @param __c An additional character to consume. 
755 * @return eof() to indicate failure, something else (usually 
756 * @a __c, or not_eof()) 
757 * 
758 * Informally, this function is called when the output buffer 
759 * is full (or does not exist, as buffering need not actually 
760 * be done). If a buffer exists, it is @a consumed, with 
761 * <em>some effect</em> on the controlled sequence. 
762 * (Typically, the buffer is written out to the sequence 
763 * verbatim.) In either case, the character @a c is also 
764 * written out, if @a __c is not @c eof(). 
765 * 
766 * For a formal definition of this function, see a good text 
767 * such as Langer & Kreft, or [27.5.2.4.5]/3-7. 
768 * 
769 * A functioning output streambuf can be created by overriding only 
770 * this function (no buffer area will be used). 
771 * 
772 * @note Base class version does nothing, returns eof(). 
773 */ 
774 virtual int_type 
775 overflow(int_type __c _IsUnused = traits_type::eof()) 
776 { return traits_type::eof(); } 
777 
778#if _GLIBCXX_USE_DEPRECATED && __cplusplus <= 201402L 
779 // Annex D.6 (removed in C++17) 
780 public: 
781 /** 
782 * @brief Tosses a character. 
783 * 
784 * Advances the read pointer, ignoring the character that would have 
785 * been read. 
786 * 
787 * See http://gcc.gnu.org/ml/libstdc++/2002-05/msg00168.html 
788 */ 
789#if __cplusplus >= 201103L 
790 [[__deprecated__("stossc is deprecated, use sbumpc instead")]] 
791#endif 
792 void 
793 stossc() 
794 { 
795 if (this->gptr() < this->egptr()) 
796 this->gbump(1); 
797 else 
798 this->uflow(); 
799 } 
800#endif 
801 
802 // Also used by specializations for char and wchar_t in src. 
803 void 
804 __safe_gbump(streamsize __n) { _M_in_cur += __n; } 
805 
806 void 
807 __safe_pbump(streamsize __n) { _M_out_cur += __n; } 
808 
809#if __cplusplus < 201103L 
810 private: 
811#else 
812 protected: 
813#endif 
814 basic_streambuf(const basic_streambuf&); 
815 
816 basic_streambuf& 
817 operator=(const basic_streambuf&); 
818 
819#if __cplusplus >= 201103L 
820 void 
821 swap(basic_streambuf& __sb) 
822 { 
823 std::swap(_M_in_beg, __sb._M_in_beg); 
824 std::swap(_M_in_cur, __sb._M_in_cur); 
825 std::swap(_M_in_end, __sb._M_in_end); 
826 std::swap(_M_out_beg, __sb._M_out_beg); 
827 std::swap(_M_out_cur, __sb._M_out_cur); 
828 std::swap(_M_out_end, __sb._M_out_end); 
829 std::swap(_M_buf_locale, __sb._M_buf_locale); 
830 } 
831#endif 
832 }; 
833 
834#if __cplusplus >= 201103L 
835 template<typename _CharT, typename _Traits> 
836 std::basic_streambuf<_CharT, _Traits>:: 
837 basic_streambuf(const basic_streambuf&) = default; 
838 
839 template<typename _CharT, typename _Traits> 
840 std::basic_streambuf<_CharT, _Traits>& 
841 std::basic_streambuf<_CharT, _Traits>:: 
842 operator=(const basic_streambuf&) = default; 
843#endif 
844 
845 // Explicit specialization declarations, defined in src/streambuf.cc. 
846 template<> 
847 streamsize 
848 __copy_streambufs_eof(basic_streambuf<char>* __sbin, 
849 basic_streambuf<char>* __sbout, bool& __ineof); 
850#ifdef _GLIBCXX_USE_WCHAR_T 
851 template<> 
852 streamsize 
853 __copy_streambufs_eof(basic_streambuf<wchar_t>* __sbin, 
854 basic_streambuf<wchar_t>* __sbout, bool& __ineof); 
855#endif 
856 
857#undef _IsUnused 
858 
859_GLIBCXX_END_NAMESPACE_VERSION 
860} // namespace 
861 
862#include <bits/streambuf.tcc> 
863 
864#endif /* _GLIBCXX_STREAMBUF */ 
865