--- name: "__gnu_cxx::enc_filebuf" section: "3cxx" platform: "linux" package: "libstdc++-12-doc" version: "12.4.0-5" release: "Debian 13 (Trixie)" platforms: ["linux"] url: "https://new.carta.tech/__gnu_cxx::enc_filebuf/3cxx" --- # \_\_gnu\_cxx::enc\_filebuf(3cxx) class enc\_filebuf. ## NAME \_\_gnu\_cxx::enc\_filebuf\< \_CharT \> - class enc\_filebuf. ## SYNOPSIS `#include ` Inherits **std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>**. ### Public Types typedef codecvt\< char\_type, char, \_\_state\_type \> **\_\_codecvt\_type**\ typedef \_\_basic\_file\< char \> **\_\_file\_type**\ typedef **basic\_filebuf**\< char\_type, **traits\_type** \> **\_\_filebuf\_type**\ typedef **traits\_type::state\_type** **\_\_state\_type**\ typedef **basic\_streambuf**\< char\_type, **traits\_type** \> **\_\_streambuf\_type**\ typedef \_CharT **char\_type**\ typedef traits\_type::int\_type **int\_type**\ typedef **traits\_type::off\_type** **off\_type**\ typedef **traits\_type::pos\_type** **pos\_type**\ typedef **traits\_type::state\_type** **state\_type**\ typedef **encoding\_char\_traits**\< \_CharT \> **traits\_type**\ ### Public Member Functions **enc\_filebuf** (**state\_type** &\_\_state)\ **\_\_filebuf\_type** \* **close** ()\ Closes the currently associated file. locale **getloc** () const\ Locale access. streamsize **in\_avail** ()\ Looking ahead into the stream. bool **is\_open** () const throw ()\ Returns true if the external file is open. \_If\_fs\_path\< \_Path, **\_\_filebuf\_type** \* \> **open** (const \_Path &\_\_s, ios\_base::openmode \_\_mode)\ Opens an external file. **\_\_filebuf\_type** \* **open** (const char \*\_\_s, ios\_base::openmode \_\_mode)\ Opens an external file. **\_\_filebuf\_type** \* **open** (const **std::string** &\_\_s, ios\_base::openmode \_\_mode)\ Opens an external file. locale **pubimbue** (const locale &\_\_loc)\ Entry point for imbue(). int\_type **sbumpc** ()\ Getting the next character. int\_type **sgetc** ()\ Getting the next character. streamsize **sgetn** (char\_type \*\_\_s, streamsize \_\_n)\ Entry point for xsgetn. int\_type **snextc** ()\ Getting the next character. int\_type **sputbackc** (char\_type \_\_c)\ Pushing characters back into the input stream. int\_type **sputc** (char\_type \_\_c)\ Entry point for all single-character output functions. streamsize **sputn** (const char\_type \*\_\_s, streamsize \_\_n)\ Entry point for all single-character output functions. int\_type **sungetc** ()\ Moving backwards in the input stream. void **swap** (**basic\_filebuf** &)\ **basic\_streambuf** \* **pubsetbuf** (char\_type \*\_\_s, streamsize \_\_n)\ Entry points for derived buffer functions. **pos\_type** **pubseekoff** (off\_type \_\_off, ios\_base::seekdir \_\_way, ios\_base::openmode \_\_mode=ios\_base::in\|ios\_base::out)\ Alters the stream position. **pos\_type** **pubseekpos** (**pos\_type** \_\_sp, ios\_base::openmode \_\_mode=ios\_base::in\|ios\_base::out)\ Alters the stream position. int **pubsync** ()\ Calls virtual sync function. ### Protected Member Functions void **\_\_safe\_gbump** (streamsize \_\_n)\ void **\_\_safe\_pbump** (streamsize \_\_n)\ void **\_M\_allocate\_internal\_buffer** ()\ bool **\_M\_convert\_to\_external** (char\_type \*, streamsize)\ void **\_M\_create\_pback** ()\ void **\_M\_destroy\_internal\_buffer** () throw ()\ void **\_M\_destroy\_pback** () throw ()\ int **\_M\_get\_ext\_pos** (\_\_state\_type &\_\_state)\ **pos\_type** **\_M\_seek** (off\_type \_\_off, ios\_base::seekdir \_\_way, \_\_state\_type \_\_state)\ void **\_M\_set\_buffer** (streamsize \_\_off)\ bool **\_M\_terminate\_output** ()\ void **gbump** (int \_\_n)\ Moving the read position. virtual void **imbue** (const locale &\_\_loc)\ Changes translations. virtual int\_type **overflow** (int\_type \_\_c=\_Traits::eof())\ Consumes data from the buffer; writes to the controlled sequence. virtual int\_type **pbackfail** (int\_type \_\_c=\_Traits::eof())\ Tries to back up the input sequence. void **pbump** (int \_\_n)\ Moving the write position. virtual **pos\_type** **seekoff** (off\_type \_\_off, ios\_base::seekdir \_\_way, ios\_base::openmode \_\_mode=ios\_base::in\|ios\_base::out)\ Alters the stream positions. virtual **pos\_type** **seekpos** (**pos\_type** \_\_pos, ios\_base::openmode \_\_mode=ios\_base::in\|ios\_base::out)\ Alters the stream positions. virtual **\_\_streambuf\_type** \* **setbuf** (char\_type \*\_\_s, streamsize \_\_n)\ Manipulates the buffer. void **setg** (char\_type \*\_\_gbeg, char\_type \*\_\_gnext, char\_type \*\_\_gend)\ Setting the three read area pointers. void **setp** (char\_type \*\_\_pbeg, char\_type \*\_\_pend)\ Setting the three write area pointers. virtual streamsize **showmanyc** ()\ Investigating the data available. void **swap** (**basic\_streambuf** &\_\_sb)\ virtual int **sync** ()\ Synchronizes the buffer arrays with the controlled sequences. virtual int\_type **uflow** ()\ Fetches more data from the controlled sequence. virtual int\_type **underflow** ()\ Fetches more data from the controlled sequence. virtual streamsize **xsgetn** (char\_type \*\_\_s, streamsize \_\_n)\ Multiple character extraction. virtual streamsize **xsputn** (const char\_type \*\_\_s, streamsize \_\_n)\ Multiple character insertion. char\_type \* **eback** () const\ Access to the get area. char\_type \* **gptr** () const\ Access to the get area. char\_type \* **egptr** () const\ Access to the get area. char\_type \* **pbase** () const\ Access to the put area. char\_type \* **pptr** () const\ Access to the put area. char\_type \* **epptr** () const\ Access to the put area. ### Protected Attributes char\_type \* **\_M\_buf**\ Pointer to the beginning of internal buffer. bool **\_M\_buf\_allocated**\ locale **\_M\_buf\_locale**\ Current locale setting. size\_t **\_M\_buf\_size**\ const **\_\_codecvt\_type** \* **\_M\_codecvt**\ char \* **\_M\_ext\_buf**\ streamsize **\_M\_ext\_buf\_size**\ char \* **\_M\_ext\_end**\ const char \* **\_M\_ext\_next**\ \_\_file\_type **\_M\_file**\ char\_type \* **\_M\_in\_beg**\ Start of get area. char\_type \* **\_M\_in\_cur**\ Current read area. char\_type \* **\_M\_in\_end**\ End of get area. \_\_c\_lock **\_M\_lock**\ ios\_base::openmode **\_M\_mode**\ Place to stash in \|\| out \|\| in \| out settings for current filebuf. char\_type \* **\_M\_out\_beg**\ Start of put area. char\_type \* **\_M\_out\_cur**\ Current put area. char\_type \* **\_M\_out\_end**\ End of put area. bool **\_M\_reading**\ \_\_state\_type **\_M\_state\_beg**\ \_\_state\_type **\_M\_state\_cur**\ \_\_state\_type **\_M\_state\_last**\ bool **\_M\_writing**\ char\_type **\_M\_pback**\ char\_type \* **\_M\_pback\_cur\_save**\ char\_type \* **\_M\_pback\_end\_save**\ bool **\_M\_pback\_init**\ ## Detailed Description ### template\ class \_\_gnu\_cxx::enc\_filebuf\< \_CharT \>"class enc\_filebuf. ## Member Function Documentation ### void std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_M\_create\_pback ()` [inline]`, ` [protected]`, ` [inherited]` Initializes pback buffers, and moves normal buffers to safety. Assumptions: \_M\_in\_cur has already been moved back ### void std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_M\_destroy\_pback ()` [inline]`, ` [protected]`, ` [inherited]` Deactivates pback buffer contents, and restores normal buffer. Assumptions: The pback buffer has only moved forward. ### void std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_M\_set\_buffer (streamsize \_\_off)` [inline]`, ` [protected]`, ` [inherited]` This function sets the pointers of the internal buffer, both get and put areas. Typically: \_\_off == egptr() - eback() upon underflow/uflow (**read** mode); \_\_off == 0 upon overflow (**write** mode); \_\_off == -1 upon open, setbuf, seekoff/pos (**uncommitted** mode). NB: epptr() - pbase() == \_M\_buf\_size - 1, since \_M\_buf\_size reflects the actual allocated memory and the last cell is reserved for the overflow char of a full put area. ### basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_\_filebuf\_type \* std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::close ()` [inherited]` Closes the currently associated file. **Returns** `this` on success, NULL on failure If no file is currently open, this function immediately fails. If a *put buffer area* exists, `overflow(eof)` is called to flush all the characters. The file is then closed. If any operations fail, this function also fails. ### template\ char\_type \* std::basic\_streambuf\< \_CharT, \_Traits \>::eback () const` [inline]`, ` [protected]`, ` [inherited]` Access to the get area. These functions are only available to other protected functions, including derived classes. - • eback() returns the beginning pointer for the input sequence - • gptr() returns the next pointer for the input sequence - • egptr() returns the end pointer for the input sequence ### template\ char\_type \* std::basic\_streambuf\< \_CharT, \_Traits \>::egptr () const` [inline]`, ` [protected]`, ` [inherited]` Access to the get area. These functions are only available to other protected functions, including derived classes. - • eback() returns the beginning pointer for the input sequence - • gptr() returns the next pointer for the input sequence - • egptr() returns the end pointer for the input sequence Referenced by **std::wbuffer\_convert\< \_Codecvt, \_Elem, \_Tr \>::underflow()**. ### template\ char\_type \* std::basic\_streambuf\< \_CharT, \_Traits \>::epptr () const` [inline]`, ` [protected]`, ` [inherited]` Access to the put area. These functions are only available to other protected functions, including derived classes. - • pbase() returns the beginning pointer for the output sequence - • pptr() returns the next pointer for the output sequence - • epptr() returns the end pointer for the output sequence ### template\ void std::basic\_streambuf\< \_CharT, \_Traits \>::gbump (int \_\_n)` [inline]`, ` [protected]`, ` [inherited]` Moving the read position. **Parameters** *\_\_n* The delta by which to move. This just advances the read position without returning any data. ### template\ locale std::basic\_streambuf\< \_CharT, \_Traits \>::getloc () const` [inline]`, ` [inherited]` Locale access. **Returns** The current locale in effect. If pubimbue(loc) has been called, then the most recent `loc` is returned. Otherwise the global locale in effect at the time of construction is returned. ### template\ char\_type \* std::basic\_streambuf\< \_CharT, \_Traits \>::gptr () const` [inline]`, ` [protected]`, ` [inherited]` Access to the get area. These functions are only available to other protected functions, including derived classes. - • eback() returns the beginning pointer for the input sequence - • gptr() returns the next pointer for the input sequence - • egptr() returns the end pointer for the input sequence Referenced by **std::wbuffer\_convert\< \_Codecvt, \_Elem, \_Tr \>::underflow()**. ### void std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::imbue (const locale & \_\_loc)` [protected]`, ` [virtual]`, ` [inherited]` Changes translations. **Parameters** *\_\_loc* A new locale. Translations done during I/O which depend on the current locale are changed by this call. The standard adds, *Between invocations of this function a class derived from streambuf can safely cache results of calls to locale functions and to members of facets so obtained.* **Note** Base class version does nothing. Reimplemented from **std::basic\_streambuf\< \_CharT, \_Traits \>**. ### template\ streamsize std::basic\_streambuf\< \_CharT, \_Traits \>::in\_avail ()` [inline]`, ` [inherited]` Looking ahead into the stream. **Returns** The number of characters available. If a read position is available, returns the number of characters available for reading before the buffer must be refilled. Otherwise returns the derived `showmanyc()`. ### bool std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::is\_open () const` [inline]`, ` [inherited]` Returns true if the external file is open. ### \_If\_fs\_path\< \_Path, \_\_filebuf\_type \* \> std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::open (const \_Path & \_\_s, ios\_base::openmode \_\_mode)` [inline]`, ` [inherited]` Opens an external file. **Parameters** *\_\_s* The name of the file, as a filesystem::path. \ *\_\_mode* The open mode flags. **Returns** `this` on success, NULL on failure ### basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_\_filebuf\_type \* std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::open (const char \* \_\_s, ios\_base::openmode \_\_mode)` [inherited]` Opens an external file. **Parameters** *\_\_s* The name of the file. \ *\_\_mode* The open mode flags. **Returns** `this` on success, NULL on failure If a file is already open, this function immediately fails. Otherwise it tries to open the file named *\_\_s* using the flags given in *\_\_mode*. Table 92, adapted here, gives the relation between openmode combinations and the equivalent `fopen()` flags. (NB: lines app, in\|out\|app, in\|app, binary\|app, binary\|in\|out\|app, and binary\|in\|app per DR 596) ``` +---------------------------------------------------------+ | ios_base Flag combination stdio equivalent | |binary in out trunc app | +---------------------------------------------------------+ | + w | | + + a | | + a | | + + w | | + r | | + + r+ | | + + + w+ | | + + + a+ | | + + a+ | +---------------------------------------------------------+ | + + wb | | + + + ab | | + + ab | | + + + wb | | + + rb | | + + + r+b | | + + + + w+b | | + + + + a+b | | + + + a+b | +---------------------------------------------------------+ ``` ### \_\_filebuf\_type \* std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::open (const std::string & \_\_s, ios\_base::openmode \_\_mode)` [inline]`, ` [inherited]` Opens an external file. **Parameters** *\_\_s* The name of the file. \ *\_\_mode* The open mode flags. **Returns** `this` on success, NULL on failure ### basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::int\_type std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::overflow (int\_type \_\_c = `_Traits::eof()`)` [protected]`, ` [virtual]`, ` [inherited]` Consumes data from the buffer; writes to the controlled sequence. **Parameters** *\_\_c* An additional character to consume. **Returns** eof() to indicate failure, something else (usually *\_\_c*, or not\_eof()) Informally, this function is called when the output buffer is full (or does not exist, as buffering need not actually be done). If a buffer exists, it is *consumed*, with *some effect* on the controlled sequence. (Typically, the buffer is written out to the sequence verbatim.) In either case, the character *c* is also written out, if *\_\_c* is not `eof()`. For a formal definition of this function, see a good text such as Langer & Kreft, or \[27.5.2.4.5\]/3-7. A functioning output streambuf can be created by overriding only this function (no buffer area will be used). **Note** Base class version does nothing, returns eof(). Reimplemented from **std::basic\_streambuf\< \_CharT, \_Traits \>**. ### basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::int\_type std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::pbackfail (int\_type \_\_c = `_Traits::eof()`)` [protected]`, ` [virtual]`, ` [inherited]` Tries to back up the input sequence. **Parameters** *\_\_c* The character to be inserted back into the sequence. **Returns** eof() on failure, *some other value* on success **Postcondition** The constraints of `gptr()`, `eback()`, and `pptr()` are the same as for `underflow()`. **Note** Base class version does nothing, returns eof(). Reimplemented from **std::basic\_streambuf\< \_CharT, \_Traits \>**. ### template\ char\_type \* std::basic\_streambuf\< \_CharT, \_Traits \>::pbase () const` [inline]`, ` [protected]`, ` [inherited]` Access to the put area. These functions are only available to other protected functions, including derived classes. - • pbase() returns the beginning pointer for the output sequence - • pptr() returns the next pointer for the output sequence - • epptr() returns the end pointer for the output sequence ### template\ void std::basic\_streambuf\< \_CharT, \_Traits \>::pbump (int \_\_n)` [inline]`, ` [protected]`, ` [inherited]` Moving the write position. **Parameters** *\_\_n* The delta by which to move. This just advances the write position without returning any data. ### template\ char\_type \* std::basic\_streambuf\< \_CharT, \_Traits \>::pptr () const` [inline]`, ` [protected]`, ` [inherited]` Access to the put area. These functions are only available to other protected functions, including derived classes. - • pbase() returns the beginning pointer for the output sequence - • pptr() returns the next pointer for the output sequence - • epptr() returns the end pointer for the output sequence ### template\ locale std::basic\_streambuf\< \_CharT, \_Traits \>::pubimbue (const locale & \_\_loc)` [inline]`, ` [inherited]` Entry point for imbue(). **Parameters** *\_\_loc* The new locale. **Returns** The previous locale. Calls the derived imbue(\_\_loc). ### template\ pos\_type std::basic\_streambuf\< \_CharT, \_Traits \>::pubseekoff (off\_type \_\_off, ios\_base::seekdir \_\_way, ios\_base::openmode \_\_mode = ios\_base::in` | `ios\_base::out)` [inline]`, ` [inherited]` Alters the stream position. **Parameters** *\_\_off* Offset. \ *\_\_way* Value for ios\_base::seekdir. \ *\_\_mode* Value for ios\_base::openmode. Calls virtual seekoff function. ### template\ pos\_type std::basic\_streambuf\< \_CharT, \_Traits \>::pubseekpos (pos\_type \_\_sp, ios\_base::openmode \_\_mode = ios\_base::in` | `ios\_base::out)` [inline]`, ` [inherited]` Alters the stream position. **Parameters** *\_\_sp* Position \ *\_\_mode* Value for ios\_base::openmode. Calls virtual seekpos function. ### template\ basic\_streambuf \* std::basic\_streambuf\< \_CharT, \_Traits \>::pubsetbuf (char\_type \* \_\_s, streamsize \_\_n)` [inline]`, ` [inherited]` Entry points for derived buffer functions. The public versions of `pubfoo` dispatch to the protected derived `foo` member functions, passing the arguments (if any) and returning the result unchanged. ### template\ int std::basic\_streambuf\< \_CharT, \_Traits \>::pubsync ()` [inline]`, ` [inherited]` Calls virtual sync function. ### template\ int\_type std::basic\_streambuf\< \_CharT, \_Traits \>::sbumpc ()` [inline]`, ` [inherited]` Getting the next character. **Returns** The next character, or eof. If the input read position is available, returns that character and increments the read pointer, otherwise calls and returns `uflow()`. ### basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::pos\_type std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::seekoff (off\_type \_\_off, ios\_base::seekdir \_\_way, ios\_base::openmode \_\_mode = `ios_base::in | ios_base::out`)` [protected]`, ` [virtual]`, ` [inherited]` Alters the stream positions. Each derived class provides its own appropriate behavior. **Note** Base class version does nothing, returns a `pos_type` that represents an invalid stream position. Reimplemented from **std::basic\_streambuf\< \_CharT, \_Traits \>**. ### basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::pos\_type std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::seekpos (pos\_type \_\_pos, ios\_base::openmode \_\_mode = `ios_base::in | ios_base::out`)` [protected]`, ` [virtual]`, ` [inherited]` Alters the stream positions. Each derived class provides its own appropriate behavior. **Note** Base class version does nothing, returns a `pos_type` that represents an invalid stream position. Reimplemented from **std::basic\_streambuf\< \_CharT, \_Traits \>**. ### basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_\_streambuf\_type \* std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::setbuf (char\_type \* \_\_s, streamsize \_\_n)` [protected]`, ` [virtual]`, ` [inherited]` Manipulates the buffer. **Parameters** *\_\_s* Pointer to a buffer area. \ *\_\_n* Size of *\_\_s*. **Returns** `this` If no file has been opened, and both *\_\_s* and *\_\_n* are zero, then the stream becomes unbuffered. Otherwise, `__s` is used as a buffer; see https://gcc.gnu.org/onlinedocs/libstdc++/manual/streambufs.html#io.streambuf.buffering for more. Reimplemented from **std::basic\_streambuf\< \_CharT, \_Traits \>**. ### template\ void std::basic\_streambuf\< \_CharT, \_Traits \>::setg (char\_type \* \_\_gbeg, char\_type \* \_\_gnext, char\_type \* \_\_gend)` [inline]`, ` [protected]`, ` [inherited]` Setting the three read area pointers. **Parameters** *\_\_gbeg* A pointer. \ *\_\_gnext* A pointer. \ *\_\_gend* A pointer. **Postcondition** *\_\_gbeg* == `eback()`, *\_\_gnext* == `gptr()`, and *\_\_gend* == `egptr()` Referenced by **std::wbuffer\_convert\< \_Codecvt, \_Elem, \_Tr \>::wbuffer\_convert()**. ### template\ void std::basic\_streambuf\< \_CharT, \_Traits \>::setp (char\_type \* \_\_pbeg, char\_type \* \_\_pend)` [inline]`, ` [protected]`, ` [inherited]` Setting the three write area pointers. **Parameters** *\_\_pbeg* A pointer. \ *\_\_pend* A pointer. **Postcondition** *\_\_pbeg* == `pbase()`, *\_\_pbeg* == `pptr()`, and *\_\_pend* == `epptr()` Referenced by **std::wbuffer\_convert\< \_Codecvt, \_Elem, \_Tr \>::wbuffer\_convert()**. ### template\ int\_type std::basic\_streambuf\< \_CharT, \_Traits \>::sgetc ()` [inline]`, ` [inherited]` Getting the next character. **Returns** The next character, or eof. If the input read position is available, returns that character, otherwise calls and returns `underflow()`. Does not move the read position after fetching the character. ### template\ streamsize std::basic\_streambuf\< \_CharT, \_Traits \>::sgetn (char\_type \* \_\_s, streamsize \_\_n)` [inline]`, ` [inherited]` Entry point for xsgetn. **Parameters** *\_\_s* A buffer area. \ *\_\_n* A count. Returns xsgetn(\_\_s,\_\_n). The effect is to fill *\_\_s*\[0\] through *\_\_s*\[\_\_n-1\] with characters from the input sequence, if possible. ### streamsize std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::showmanyc ()` [protected]`, ` [virtual]`, ` [inherited]` Investigating the data available. **Returns** An estimate of the number of characters available in the input sequence, or -1. *If it returns a positive value, then successive calls to* `underflow()` *will not return* `traits::eof()` *until at least that number of characters have been supplied. If* `showmanyc()` *returns -1, then calls to* `underflow()` *or* `uflow()` *will fail.*` [27.5.2.4.3]/1` **Note** `Base class version does nothing, returns zero. ` `The standard adds that `*the intention is not only that the calls \[to underflow or uflow\] will not return* `eof()` *but that they will return immediately.*` ` `The standard adds that `*the morphemes of* `showmanyc` *are* **es-how-many-see***, not* **show-manic***.* **Reimplemented from std::basic\_streambuf\< \_CharT, \_Traits \>.** ### template\ int\_type std::basic\_streambuf\< \_CharT, \_Traits \>::snextc ()` [inline]`, ` [inherited]` **Getting the next character.** **Returns** **The next character, or eof.** **Calls** `sbumpc()`**, and if that function returns** `traits::eof()`**, so does this function. Otherwise,** `sgetc()`**.** ### template\ int\_type std::basic\_streambuf\< \_CharT, \_Traits \>::sputbackc (char\_type \_\_c)` [inline]`, ` [inherited]` **Pushing characters back into the input stream.** **Parameters** *\_\_c* **The character to push back.** **Returns** **The previous character, if possible.** **Similar to sungetc(), but** *\_\_c* **is pushed onto the stream instead of** *the previous character.* **If successful, the next character fetched from the input stream will be** *\_\_c***.** ### template\ int\_type std::basic\_streambuf\< \_CharT, \_Traits \>::sputc (char\_type \_\_c)` [inline]`, ` [inherited]` **Entry point for all single-character output functions.** **Parameters** *\_\_c* **A character to output.** **Returns** *\_\_c***, if possible.** **One of two public output functions.** **If a write position is available for the output sequence (i.e., the buffer is not full), stores** *\_\_c* **in that position, increments the position, and returns** `traits::to_int_type(__c)`**. If a write position is not available, returns** `overflow(__c)`**.** **Referenced by std::wbuffer\_convert\< \_Codecvt, \_Elem, \_Tr \>::overflow().** ### template\ streamsize std::basic\_streambuf\< \_CharT, \_Traits \>::sputn (const char\_type \* \_\_s, streamsize \_\_n)` [inline]`, ` [inherited]` **Entry point for all single-character output functions.** **Parameters** *\_\_s* **A buffer read area.** \ *\_\_n* **A count.** **One of two public output functions.** **Returns xsputn(\_\_s,\_\_n). The effect is to write** *\_\_s***\[0\] through** *\_\_s***\[\_\_n-1\] to the output sequence, if possible.** ### template\ int\_type std::basic\_streambuf\< \_CharT, \_Traits \>::sungetc ()` [inline]`, ` [inherited]` **Moving backwards in the input stream.** **Returns** **The previous character, if possible.** **If a putback position is available, this function decrements the input pointer and returns that character. Otherwise, calls and returns pbackfail(). The effect is to** *unget* **the last character** *gotten***.** ### int std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::sync ()` [protected]`, ` [virtual]`, ` [inherited]` **Synchronizes the buffer arrays with the controlled sequences.** **Returns** **-1 on failure.** **Each derived class provides its own appropriate behavior, including the definition of** *failure***.** **Note** **Base class version does nothing, returns zero.** **Reimplemented from std::basic\_streambuf\< \_CharT, \_Traits \>.** ### template\ virtual int\_type std::basic\_streambuf\< \_CharT, \_Traits \>::uflow ()` [inline]`, ` [protected]`, ` [virtual]`, ` [inherited]` **Fetches more data from the controlled sequence.** **Returns** **The first character from the** *pending sequence***.** **Informally, this function does the same thing as** `underflow()`**, and in fact is required to call that function. It also returns the new character, like** `underflow()` **does. However, this function also moves the read position forward by one.** **Reimplemented in \_\_gnu\_cxx::stdio\_sync\_filebuf\< \_CharT, \_Traits \>.** ### basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::int\_type std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::underflow ()` [protected]`, ` [virtual]`, ` [inherited]` **Fetches more data from the controlled sequence.** **Returns** **The first character from the** *pending sequence***.** **Informally, this function is called when the input buffer is exhausted (or does not exist, as buffering need not actually be done). If a buffer exists, it is** *refilled***. In either case, the next available character is returned, or** `traits::eof()` **to indicate a null pending sequence.** **For a formal definition of the pending sequence, see a good text such as Langer & Kreft, or \[27.5.2.4.3\]/7-14.** **A functioning input streambuf can be created by overriding only this function (no buffer area will be used). For an example, see https://gcc.gnu.org/onlinedocs/libstdc++/manual/streambufs.html** **Note** **Base class version does nothing, returns eof().** **Reimplemented from std::basic\_streambuf\< \_CharT, \_Traits \>.** ### streamsize std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::xsgetn (char\_type \* \_\_s, streamsize \_\_n)` [protected]`, ` [virtual]`, ` [inherited]` **Multiple character extraction.** **Parameters** *\_\_s* **A buffer area.** \ *\_\_n* **Maximum number of characters to assign.** **Returns** **The number of characters assigned.** **Fills** *\_\_s***\[0\] through** *\_\_s***\[\_\_n-1\] with characters from the input sequence, as if by** `sbumpc()`**. Stops when either** *\_\_n* **characters have been copied, or when** `traits::eof()` **would be copied.** **It is expected that derived classes provide a more efficient implementation by overriding this definition.** **Reimplemented from std::basic\_streambuf\< \_CharT, \_Traits \>.** ### streamsize std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::xsputn (const char\_type \* \_\_s, streamsize \_\_n)` [protected]`, ` [virtual]`, ` [inherited]` **Multiple character insertion.** **Parameters** *\_\_s* **A buffer area.** \ *\_\_n* **Maximum number of characters to write.** **Returns** **The number of characters written.** **Writes** *\_\_s***\[0\] through** *\_\_s***\[\_\_n-1\] to the output sequence, as if by** `sputc()`**. Stops when either** *n* **characters have been copied, or when** `sputc()` **would return** `traits::eof()`**.** **It is expected that derived classes provide a more efficient implementation by overriding this definition.** **Reimplemented from std::basic\_streambuf\< \_CharT, \_Traits \>.** ## Member Data Documentation ### char\_type\* std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_M\_buf` [protected]`, ` [inherited]` **Pointer to the beginning of internal buffer.** ### template\ locale std::basic\_streambuf\< \_CharT, \_Traits \>::\_M\_buf\_locale` [protected]`, ` [inherited]` **Current locale setting.** **Referenced by std::basic\_filebuf\< \_CharT, \_Traits \>::basic\_filebuf().** ### size\_t std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_M\_buf\_size` [protected]`, ` [inherited]` **Actual size of internal buffer. This number is equal to the size of the put area + 1 position, reserved for the overflow char of a full area.** ### char\* std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_M\_ext\_buf` [protected]`, ` [inherited]` **Buffer for external characters. Used for input when codecvt::always\_noconv() == false. When valid, this corresponds to eback().** ### streamsize std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_M\_ext\_buf\_size` [protected]`, ` [inherited]` **Size of buffer held by \_M\_ext\_buf.** ### const char\* std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_M\_ext\_next` [protected]`, ` [inherited]` **Pointers into the buffer held by \_M\_ext\_buf that delimit a subsequence of bytes that have been read but not yet converted. When valid, \_M\_ext\_next corresponds to egptr().** ### template\ char\_type\* std::basic\_streambuf\< \_CharT, \_Traits \>::\_M\_in\_beg` [protected]`, ` [inherited]` **Start of get area.** ### template\ char\_type\* std::basic\_streambuf\< \_CharT, \_Traits \>::\_M\_in\_cur` [protected]`, ` [inherited]` **Current read area.** ### template\ char\_type\* std::basic\_streambuf\< \_CharT, \_Traits \>::\_M\_in\_end` [protected]`, ` [inherited]` **End of get area.** ### ios\_base::openmode std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_M\_mode` [protected]`, ` [inherited]` **Place to stash in \|\| out \|\| in \| out settings for current filebuf.** ### template\ char\_type\* std::basic\_streambuf\< \_CharT, \_Traits \>::\_M\_out\_beg` [protected]`, ` [inherited]` **Start of put area.** ### template\ char\_type\* std::basic\_streambuf\< \_CharT, \_Traits \>::\_M\_out\_cur` [protected]`, ` [inherited]` **Current put area.** ### template\ char\_type\* std::basic\_streambuf\< \_CharT, \_Traits \>::\_M\_out\_end` [protected]`, ` [inherited]` **End of put area.** ### char\_type std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_M\_pback` [protected]`, ` [inherited]` **Necessary bits for putback buffer management.** **Note** **pbacks of over one character are not currently supported.** ### char\_type\* std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_M\_pback\_cur\_save` [protected]`, ` [inherited]` **Necessary bits for putback buffer management.** **Note** **pbacks of over one character are not currently supported.** ### char\_type\* std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_M\_pback\_end\_save` [protected]`, ` [inherited]` **Necessary bits for putback buffer management.** **Note** **pbacks of over one character are not currently supported.** ### bool std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_M\_pback\_init` [protected]`, ` [inherited]` **Necessary bits for putback buffer management.** **Note** **pbacks of over one character are not currently supported.** ### bool std::basic\_filebuf\< \_CharT, encoding\_char\_traits\< \_CharT \> \>::\_M\_reading` [protected]`, ` [inherited]` **\_M\_reading == false && \_M\_writing == false for uncommitted mode; \_M\_reading == true for read mode; \_M\_writing == true for write mode;** **NB: \_M\_reading == true && \_M\_writing == true is unused.** ## Author **Generated automatically by Doxygen for libstdc++ from the source code.**