STD::WBUFFER_CONVERT(3cxx)

🌸 NAME 🌸

okay bestie, this is the manual page for std::wbuffer_convert< _Codecvt, _Elem, _Tr > in manual section (3cxx) β€” header vibes: STD::WBUFFER_CONVERT(3cxx). It’s all about buffer conversions. πŸ’–


πŸ¦‹ SYNOPSIS πŸ¦‹

#include <locale>

It inherits std::basic_streambuf< _CharT, _Traits >. inherited main-character energy, periodt. πŸ‘‘

πŸ’– Public Types πŸ’–

  • typedef _Codecvt::state_type state_type
  • typedef _CharT char_type
  • typedef _Traits traits_type
  • typedef traits_type::int_type int_type
  • typedef traits_type::pos_type pos_type
  • typedef traits_type::off_type off_type
  • typedef basic_streambuf< char_type, traits_type > __streambuf_type β€” This is a non-standard type.

πŸŽ€ Public Member Functions πŸŽ€

  • wbuffer_convert () β€” the default constructor, cute and parameterless.
  • wbuffer_convert (const wbuffer_convert &)=delete β€” copy constructor? deleted, not today bestie.
  • wbuffer_convert (streambuf *__bytebuf, _Codecvt *__pcvt=new _Codecvt, state_type __state=state_type()) β€” the real constructor moment.
  • locale getloc () const β€” locale access.
  • streamsize in_avail () β€” looking ahead into the stream.
  • wbuffer_convert & operator= (const wbuffer_convert &)=delete β€” assignment? also deleted, we don’t do that here.
  • locale pubimbue (const locale &__loc) β€” entry point for imbue().
  • streambuf * rdbuf () const noexcept β€” get the buffer.
  • streambuf * rdbuf (streambuf *__bytebuf) noexcept β€” set the buffer.
  • 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.
  • state_type state () const noexcept β€” the conversion state following the last conversion.
  • int_type sungetc () β€” moving backwards in the input stream.
  • 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) β€” listed, no description given.
  • void __safe_pbump (streamsize __n) β€” listed, no description given.
  • void gbump (int __n) β€” moving the read position.
  • virtual void imbue (const locale &__loc) β€” changes translations.
  • _Wide_streambuf::int_type overflow (typename _Wide_streambuf::int_type __out) β€” consumes data from the buffer; writes to the controlled sequence.
  • virtual int_type pbackfail (int_type __c=traits_type::eof()) β€” tries to back up the input sequence.
  • void pbump (int __n) β€” moving the write position.
  • virtual pos_type seekoff (off_type, ios_base::seekdir, ios_base::openmode=ios_base::in|ios_base::out) β€” alters the stream positions.
  • virtual pos_type seekpos (pos_type, ios_base::openmode=ios_base::in|ios_base::out) β€” alters the stream positions.
  • virtual basic_streambuf< char_type, _Traits > * setbuf (char_type *, streamsize) β€” 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) β€” listed, no description given.
  • int sync () β€” synchronizes the buffer arrays with the controlled sequences.
  • virtual int_type uflow () β€” fetches more data from the controlled sequence.
  • _Wide_streambuf::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.
  • streamsize xsputn (const typename _Wide_streambuf::char_type *__s, streamsize __n) β€” the other xsputn overload, also listed.
  • 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 πŸ’œ

  • locale _M_buf_locale β€” current locale setting.
  • 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.
  • 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.

πŸ”₯ Detailed Description πŸ”₯

the template is literally this, bestie:

template<typename _Codecvt, typename _Elem = wchar_t, typename _Tr =
    char_traits<_Elem>>
    class std::wbuffer_convert< _Codecvt, _Elem, _Tr >"Buffer conversions.

⭐ Member Typedef Documentation ⭐

__streambuf_type

template<typename _CharT , typename _Traits > typedef
    basic_streambuf<char_type, traits_type> std::basic_streambuf< _CharT,
    _Traits >::__streambuf_type [inherited]

This is a non-standard type.

char_type

template<typename _CharT , typename _Traits > typedef _CharT
    std::basic_streambuf< _CharT, _Traits >::char_type [inherited]

These are standard types. They permit a standardized way of referring to names of (or names dependent on) the template parameters, which are specific to the implementation.

int_type

template<typename _CharT , typename _Traits > typedef traits_type::int_type
    std::basic_streambuf< _CharT, _Traits >::int_type [inherited]

These are standard types. They permit a standardized way of referring to names of (or names dependent on) the template parameters, which are specific to the implementation.

off_type

template<typename _CharT , typename _Traits > typedef traits_type::off_type
    std::basic_streambuf< _CharT, _Traits >::off_type [inherited]

These are standard types. They permit a standardized way of referring to names of (or names dependent on) the template parameters, which are specific to the implementation.

pos_type

template<typename _CharT , typename _Traits > typedef traits_type::pos_type
    std::basic_streambuf< _CharT, _Traits >::pos_type [inherited]

These are standard types. They permit a standardized way of referring to names of (or names dependent on) the template parameters, which are specific to the implementation.

traits_type

template<typename _CharT , typename _Traits > typedef _Traits
    std::basic_streambuf< _CharT, _Traits >::traits_type [inherited]

These are standard types. They permit a standardized way of referring to names of (or names dependent on) the template parameters, which are specific to the implementation.


πŸ’… Constructor & Destructor Documentation πŸ’…

default wbuffer_convert ()

template<typename _Codecvt , typename _Elem  = wchar_t, typename _Tr  =
    char_traits<_Elem>> std::wbuffer_convert< _Codecvt, _Elem, _Tr
    >::wbuffer_convert () [inline]

Default constructor.

wbuffer_convert (streambuf * __bytebuf, _Codecvt * __pcvt = new _Codecvt, state_type __state = state_type())

template<typename _Codecvt , typename _Elem  = wchar_t, typename _Tr  =
    char_traits<_Elem>> std::wbuffer_convert< _Codecvt, _Elem, _Tr
    >::wbuffer_convert (streambuf * __bytebuf, _Codecvt * __pcvt = new
    _Codecvt, state_type __state = state_type()) [inline],  [explicit]

Constructor.

Parameters

  • __bytebuf β€” The underlying byte stream buffer.
  • __pcvt β€” The facet to use for conversions.
  • __state β€” Initial conversion state.

Takes ownership of __pcvt and will delete it in the destructor.

References std::basic_streambuf< _CharT, _Traits >::setg(), and std::basic_streambuf< _CharT, _Traits >::setp().


🌈 Member Function Documentation 🌈

eback () const

template<typename _CharT , typename _Traits > 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

References std::basic_streambuf< _CharT, _Traits >::_M_in_beg.

Referenced by std::basic_streambuf< _CharT, _Traits >::sputbackc(), and std::basic_streambuf< _CharT, _Traits >::sungetc().

egptr () const

template<typename _CharT , typename _Traits > 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

References std::basic_streambuf< _CharT, _Traits >::_M_in_end.

Referenced by std::basic_streambuf< _CharT, _Traits >::in_avail(), std::basic_streambuf< _CharT, _Traits >::sbumpc(), std::basic_streambuf< _CharT, _Traits >::sgetc(), std::basic_stringbuf< _CharT, _Traits, _Alloc >::showmanyc(), and std::wbuffer_convert< _Codecvt, _Elem, _Tr >::underflow().

epptr () const

template<typename _CharT , typename _Traits > 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

References std::basic_streambuf< _CharT, _Traits >::_M_out_end.

Referenced by std::basic_streambuf< _CharT, _Traits >::sputc().

gbump (int __n)

template<typename _CharT , typename _Traits > 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.

References std::basic_streambuf< _CharT, _Traits >::_M_in_cur.

Referenced by std::basic_streambuf< _CharT, _Traits >::sbumpc(), std::basic_streambuf< _CharT, _Traits >::sputbackc(), std::basic_streambuf< _CharT, _Traits >::sungetc(), and std::basic_streambuf< _CharT, _Traits >::uflow().

getloc () const

template<typename _CharT , typename _Traits > 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.

Peep the reference list for the bit above:

  • References std::basic_streambuf< _CharT, _Traits >::_M_buf_locale.
  • Referenced by std::basic_streambuf< _CharT, _Traits >::pubimbue().

🌸 gptr() β€” access to the get area, but make it protected

template<typename _CharT , typename _Traits > char_type *
std::basic_streambuf< _CharT, _Traits >::gptr () const

Okay so bestie, these get-area functions are only available to other protected functions, including derived classes. It's giving VIP section, not public-public.

  • 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

It's tagged [inline], [protected], and [inherited].

References std::basic_streambuf< _CharT, _Traits >::_M_in_cur.

Referenced by std::basic_streambuf< _CharT, _Traits >::in_avail(), std::basic_streambuf< _CharT, _Traits >::sbumpc(), std::basic_streambuf< _CharT, _Traits >::sgetc(), std::basic_stringbuf< _CharT, _Traits, _Alloc >::showmanyc(), std::basic_streambuf< _CharT, _Traits >::sputbackc(), std::basic_streambuf< _CharT, _Traits >::sungetc(), std::basic_streambuf< _CharT, _Traits >::uflow(), and std::wbuffer_convert< _Codecvt, _Elem, _Tr >::underflow().

πŸ’… imbue() β€” changes translations

template<typename _CharT , typename _Traits > virtual void
std::basic_streambuf< _CharT, _Traits >::imbue (const locale & __loc)

Tags: [inline], [protected], [virtual], [inherited]. The whole protected-virtual package, slay.

Parameters

  • __loc β€” a new locale.

Translations done during I/O which depend on the current locale are changed by this call. The standard adds β€” and I quote β€” β€œ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.” So caching is safe between calls, no cap.

Note: Base class version does nothing. Literally nothing. It’s decorative πŸ’€.

Reimplemented in std::basic_filebuf< _CharT, _Traits >, std::basic_filebuf< _CharT, encoding_char_traits< _CharT > >, std::basic_filebuf< _CharT, std::char_traits< _CharT > >, and std::basic_filebuf< char_type, traits_type >.

Referenced by std::basic_streambuf< _CharT, _Traits >::pubimbue().

πŸ” in_avail() β€” looking ahead into the stream

template<typename _CharT , typename _Traits > streamsize
std::basic_streambuf< _CharT, _Traits >::in_avail ()

[inline], [inherited].

Returns: the number of characters available.

If a read position is available, it returns the number of characters available for reading before the buffer must be refilled. Otherwise it returns the derived showmanyc(). Very β€œhow many snacks are left in the bag” energy πŸ“.

References std::basic_streambuf< _CharT, _Traits >::egptr(), std::basic_streambuf< _CharT, _Traits >::gptr(), and std::basic_streambuf< _CharT, _Traits >::showmanyc().


πŸ”₯ overflow() β€” the wbuffer_convert one, consumes data and writes to the controlled sequence

template<typename _Codecvt , typename _Elem  = wchar_t, typename _Tr  =
char_traits<_Elem>> _Wide_streambuf::int_type std::wbuffer_convert<
_Codecvt, _Elem, _Tr >::overflow (typename _Wide_streambuf::int_type __c)

[inline], [protected], [virtual]. Main character function energy.

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. Yes, they really said β€œa good text,” iconic citation behavior 😭.

A functioning output streambuf can be created by overriding only this function (no buffer area will be used). Lowkey the minimal-effort slay.

Note: Base class version does nothing, returns eof().

Reimplemented from std::basic_streambuf< _CharT, _Traits >.

References std::basic_streambuf< _CharT, _Traits >::sputc().

🐚 pbackfail() β€” tries to back up the input sequence

template<typename _CharT , typename _Traits > virtual int_type
std::basic_streambuf< _CharT, _Traits >::pbackfail (int_type __c =
traits_type::eof())

[inline], [protected], [virtual], [inherited].

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 in std::basic_filebuf< _CharT, _Traits >, std::basic_filebuf< _CharT, encoding_char_traits< _CharT > >, std::basic_filebuf< _CharT, std::char_traits< _CharT > >, std::basic_filebuf< char_type, traits_type >, __gnu_cxx::stdio_sync_filebuf< _CharT, _Traits >, and std::basic_stringbuf< _CharT, _Traits, _Alloc >.

Referenced by std::basic_streambuf< _CharT, _Traits >::sputbackc(), and std::basic_streambuf< _CharT, _Traits >::sungetc().

πŸŽ€ pbase() β€” access to the put area

template<typename _CharT , typename _Traits > char_type *
std::basic_streambuf< _CharT, _Traits >::pbase () const

[inline], [protected], [inherited].

These functions are only available to other protected functions, including derived classes. Same protected-bestie rules as the get area, fr fr.

  • 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

References std::basic_streambuf< _CharT, _Traits >::_M_out_beg.

Referenced by std::basic_stringbuf< _CharT, _Traits, _Alloc >::str().

πŸ¦‹ pbump() β€” moving the write position

template<typename _CharT , typename _Traits > void std::basic_streambuf<
_CharT, _Traits >::pbump (int __n)

[inline], [protected], [inherited].

Parameters

  • __n β€” the delta by which to move.

This just advances the write position without returning any data. It’s giving β€œwalk forward, don’t touch anything” πŸ’….

References std::basic_streambuf< _CharT, _Traits >::_M_out_cur.

Referenced by std::basic_streambuf< _CharT, _Traits >::sputc().

⭐ pptr() β€” also access to the put area

template<typename _CharT , typename _Traits > char_type *
std::basic_streambuf< _CharT, _Traits >::pptr () const

[inline], [protected], [inherited].

The put-area trio again, because repetition is how you learn:

  • 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

References std::basic_streambuf< _CharT, _Traits >::_M_out_cur.

Referenced by std::basic_streambuf< _CharT, _Traits >::sputc().


πŸ’œ pubimbue() β€” entry point for imbue()

template<typename _CharT , typename _Traits > locale std::basic_streambuf<
_CharT, _Traits >::pubimbue (const locale & __loc)

[inline], [inherited].

Parameters

  • __loc β€” the new locale.

Returns: the previous locale.

Calls the derived imbue(__loc). Public-facing bestie just forwards the vibe to the protected one 🫢.

References std::basic_streambuf< _CharT, _Traits >::_M_buf_locale, std::basic_streambuf< _CharT, _Traits >::getloc(), and std::basic_streambuf< _CharT, _Traits >::imbue().

🌈 pubseekoff() β€” alters the stream position

template<typename _CharT , typename _Traits > 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].

Parameters

  • __off β€” offset.
  • __way β€” value for ios_base::seekdir.
  • __mode β€” value for ios_base::openmode. Default is ios_base::in | ios_base::out.

Calls virtual seekoff function.

References std::basic_streambuf< _CharT, _Traits >::seekoff().

🧚 pubseekpos() β€” also alters the stream position

template<typename _CharT , typename _Traits > pos_type std::basic_streambuf<
_CharT, _Traits >::pubseekpos (pos_type __sp, ios_base::openmode __mode
= ios_base::in | ios_base::out)

[inline], [inherited].

Parameters

  • __sp β€” position.
  • __mode β€” value for ios_base::openmode. Default is ios_base::in | ios_base::out.

Calls virtual seekpos function.

References std::basic_streambuf< _CharT, _Traits >::seekpos().

πŸ“ pubsetbuf() β€” entry points for derived buffer functions

template<typename _CharT , typename _Traits > basic_streambuf *
std::basic_streambuf< _CharT, _Traits >::pubsetbuf (char_type * __s,
streamsize __n)

[inline], [inherited].

The public versions of pubfoo dispatch to the protected derived foo member functions, passing the arguments (if any) and returning the result unchanged. Yes, that’s the whole bit: public wrapper says β€œgo ask my protected friend,” returns whatever they say, no notes.

References std::basic_streambuf< _CharT, _Traits >::setbuf().

🌸 pubsync() β€” calls virtual sync

template<typename _CharT , typename _Traits > int std::basic_streambuf<
_CharT, _Traits >::pubsync ()

[inline], [inherited].

Calls virtual sync function.

References std::basic_streambuf< _CharT, _Traits >::sync().

Referenced by std::basic_istream< _CharT, _Traits >::sync().

πŸ’« sbumpc() β€” getting the next character

template<typename _CharT , typename _Traits > int_type std::basic_streambuf<
_CharT, _Traits >::sbumpc ()

[inline], [inherited].

Returns: the next character, or eof.

If the input read position is available, it returns that character and increments the read pointer, otherwise it calls and returns uflow(). Very β€œgrab the next snack or ask the kitchen” behavior πŸ“.

References std::basic_streambuf< _CharT, _Traits >::egptr(), std::basic_streambuf< _CharT, _Traits >::gbump(), std::basic_streambuf< _CharT, _Traits >::gptr(), and std::basic_streambuf< _CharT, _Traits >::uflow().

Referenced by std::basic_istream< char >::get(), std::basic_istream< _CharT, _Traits >::ignore(), std::basic_streambuf< _CharT, _Traits >::snextc(), and std::basic_istream< char >::sync().

πŸ‘‘ seekoff() β€” alters the stream positions

template<typename _CharT , typename _Traits > virtual pos_type
std::basic_streambuf< _CharT, _Traits >::seekoff (off_type,
ios_base::seekdir, ios_base::openmode = ios_base::in | ios_base::out)

[inline], [protected], [virtual], [inherited].

Each derived class provides its own appropriate behavior. Like, this is the blueprint; the actual implementation is each class’s own business.

Note: Base class version does nothing, returns a pos_type that represents an invalid stream position. So if you see invalid, that’s the base class being useless on purpose πŸ’€.

Reimplemented in std::basic_filebuf< _CharT, _Traits >, std::basic_filebuf< _CharT, encoding_char_traits< _CharT > >, std::basic_filebuf< _CharT, std::char_traits< _CharT > >, std::basic_filebuf< char_type, traits_type >, and std::basic_stringbuf< _CharT, _Traits, _Alloc >.

Referenced by std::basic_streambuf< _CharT, _Traits >::pubseekoff().

πŸ’Ž seekpos() β€” same energy, different function

template<typename _CharT , typename _Traits > virtual pos_type
std::basic_streambuf< _CharT, _Traits >::seekpos (pos_type,
ios_base::openmode = ios_base::in | ios_base::out)

[inline], [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 in std::basic_filebuf< _CharT, _Traits >, std::basic_filebuf< _CharT, encoding_char_traits< _CharT > >, std::basic_filebuf< _CharT, std::char_traits< _CharT > >, std::basic_filebuf< char_type, traits_type >, and std::basic_stringbuf< _CharT, _Traits, _Alloc >.

Referenced by std::basic_streambuf< _CharT, _Traits >::pubseekpos().

setbuf β€” the buffer-manipulation girlie ✨

template<typename _CharT , typename _Traits > virtual basic_streambuf<
       char_type, _Traits > * std::basic_streambuf< _CharT, _Traits >::setbuf
       (char_type *, streamsize) [inline],  [protected],  [virtual],
       [inherited]

Okay so this one manipulates the buffer. Every derived class gets to bring its own appropriate behavior β€” no cap, they all do their own thing. For the full lore, peep the next-to-last paragraph of https://gcc.gnu.org/onlinedocs/libstdc++/manual/streambufs.html#io.streambuf.buffering.

Note β€” the base class version literally does nothing and returns this.

Reimplemented in std::basic_filebuf< _CharT, _Traits >, std::basic_filebuf< _CharT, encoding_char_traits< _CharT > >, std::basic_filebuf< _CharT, std::char_traits< _CharT > >, std::basic_filebuf< char_type, traits_type >, and std::basic_stringbuf< _CharT, _Traits, _Alloc >.

Referenced by std::basic_streambuf< _CharT, _Traits >::pubsetbuf().


setg β€” setting the three read area pointers πŸŽ€

template<typename _CharT , typename _Traits > void std::basic_streambuf<
       _CharT, _Traits >::setg (char_type * __gbeg, char_type * __gnext,
       char_type * __gend) [inline],  [protected],  [inherited]

This is the read-area pointer setup, bestie. Three pointers, one vibe.

Parameters

  • __gbeg β€” A pointer.
  • __gnext β€” A pointer.
  • __gend β€” A pointer.

Postcondition β€” __gbeg == eback(), __gnext == gptr(), and __gend == egptr().

References std::basic_streambuf< _CharT, _Traits >::_M_in_beg, std::basic_streambuf< _CharT, _Traits >::_M_in_cur, and std::basic_streambuf< _CharT, _Traits >::_M_in_end.

Referenced by std::wbuffer_convert< _Codecvt, _Elem, _Tr >::wbuffer_convert().


setp β€” setting the three write area pointers πŸ¦‹

template<typename _CharT , typename _Traits > void std::basic_streambuf<
       _CharT, _Traits >::setp (char_type * __pbeg, char_type * __pend)
       [inline],  [protected],  [inherited]

The write-area pointer setup. It's giving "two pointers, but the postcondition mentions three because _M_out_cur is also in the mix." Slay.

Parameters

  • __pbeg β€” A pointer.
  • __pend β€” A pointer.

Postcondition β€” __pbeg == pbase(), __pbeg == pptr(), and __pend == epptr().

References std::basic_streambuf< _CharT, _Traits >::_M_out_beg, std::basic_streambuf< _CharT, _Traits >::_M_out_cur, and std::basic_streambuf< _CharT, _Traits >::_M_out_end.

Referenced by std::wbuffer_convert< _Codecvt, _Elem, _Tr >::wbuffer_convert().


sgetc β€” getting the next character πŸ‘‘

template<typename _CharT , typename _Traits > int_type std::basic_streambuf<
       _CharT, _Traits >::sgetc () [inline],  [inherited]

Bestie, this one gets the next character. It does not move the read position after fetching β€” it's a look, not a grab.

Returns β€” The next character, or eof.

If the input read position is available, it returns that character. Otherwise it calls and returns underflow(). Does not move the read position after fetching the character.

References std::basic_streambuf< _CharT, _Traits >::egptr(), std::basic_streambuf< _CharT, _Traits >::gptr(), and std::basic_streambuf< _CharT, _Traits >::underflow().

Referenced by std::basic_istream< char >::get(), std::basic_istream< _CharT, _Traits >::get(), std::basic_istream< _CharT, _Traits >::ignore(), std::basic_istream< char >::readsome(), and std::basic_streambuf< _CharT, _Traits >::snextc().


sgetn β€” entry point for xsgetn 🌟

template<typename _CharT , typename _Traits > streamsize
       std::basic_streambuf< _CharT, _Traits >::sgetn (char_type * __s,
       streamsize __n) [inline],  [inherited]

This is the public entry point for xsgetn, lowkey the bulk-read plug.

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.

References std::basic_streambuf< _CharT, _Traits >::xsgetn().


showmanyc β€” investigating the data available πŸ”

template<typename _CharT , typename _Traits > virtual streamsize
       std::basic_streambuf< _CharT, _Traits >::showmanyc () [inline],
       [protected],  [virtual],  [inherited]

Okay so this function is literally investigating how much data is available. The name is not "show-manic" β€” keep reading, the standard is gonna drag us for that.

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 β€” the base class version does nothing and 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. Iykyk. πŸ’€

Reimplemented in std::basic_filebuf< _CharT, _Traits >, std::basic_filebuf< _CharT, encoding_char_traits< _CharT > >, std::basic_filebuf< _CharT, std::char_traits< _CharT > >, std::basic_filebuf< char_type, traits_type >, and std::basic_stringbuf< _CharT, _Traits, _Alloc >.

Referenced by std::basic_streambuf< _CharT, _Traits >::in_avail().


snextc β€” getting the next character, again πŸ’œ

template<typename _CharT , typename _Traits > int_type std::basic_streambuf<
       _CharT, _Traits >::snextc () [inline],  [inherited]

The way this one works: it calls sbumpc(), and if that function returns traits::eof(), so does this function. Otherwise, sgetc(). It's giving "advance, then peek."

Returns β€” The next character, or eof.

References std::basic_streambuf< _CharT, _Traits >::sbumpc() and std::basic_streambuf< _CharT, _Traits >::sgetc().

Referenced by std::basic_istream< char >::get(), std::basic_istream< char >::ignore(), std::basic_istream< char >::operator>>(), and std::basic_istream< char >::putback().


sputbackc β€” pushing characters back into the input stream 🫢

template<typename _CharT , typename _Traits > int_type std::basic_streambuf<
       _CharT, _Traits >::sputbackc (char_type __c) [inline],  [inherited]

Pushing a character back into the input stream. It's similar to sungetc(), but __c is pushed onto the stream instead of the previous character. If it works, the next character fetched from the input stream will be __c.

Parameters

  • __c β€” The character to push back.

Returns β€” The previous character, if possible.

References std::basic_streambuf< _CharT, _Traits >::eback(), std::basic_streambuf< _CharT, _Traits >::gbump(), std::basic_streambuf< _CharT, _Traits >::gptr(), and std::basic_streambuf< _CharT, _Traits >::pbackfail().

Referenced by std::basic_istream< _CharT, _Traits >::putback().


sputc β€” entry point for all single-character output functions πŸ’…

template<typename _CharT , typename _Traits > int_type std::basic_streambuf<
       _CharT, _Traits >::sputc (char_type __c) [inline],  [inherited]

One of two public output functions. Main character energy for single-character output.

Parameters

  • __c β€” A character to output.

Returns β€” __c, if possible.

If a write position is available for the output sequence (i.e., the buffer is not full), it stores __c in that position, increments the position, and returns traits::to_int_type(__c). If a write position is not available, it returns overflow(__c).

References std::basic_streambuf< _CharT, _Traits >::epptr(), std::basic_streambuf< _CharT, _Traits >::overflow(), std::basic_streambuf< _CharT, _Traits >::pbump(), and std::basic_streambuf< _CharT, _Traits >::pptr().

Referenced by std::wbuffer_convert< _Codecvt, _Elem, _Tr >::overflow().


sputn β€” entry point for all single-character output functions πŸ“

template<typename _CharT , typename _Traits > streamsize
       std::basic_streambuf< _CharT, _Traits >::sputn (const char_type * __s,
       streamsize __n) [inline],  [inherited]

Another one of the two public output functions. Yes, the one-liner says "single-character" again β€” we are faithfully keeping the original energy, bestie. 😭

Parameters

  • __s β€” A buffer read area.
  • __n β€” A count.

Returns xsputn(__s,__n). The effect is to write __s[0] through __s[__n-1] to the output sequence, if possible.

References std::basic_streambuf< _CharT, _Traits >::xsputn().


state β€” the conversion state after the last conversion ✨

template<typename _Codecvt , typename _Elem  = wchar_t, typename _Tr  =
       char_traits<_Elem>> state_type std::wbuffer_convert< _Codecvt, _Elem,
       _Tr >::state () const [inline],  [noexcept]

The conversion state following the last conversion. That's the whole vibe. Short, sweet, stateful.


sungetc β€” moving backwards in the input stream πŸŽ€

template<typename _CharT , typename _Traits > int_type std::basic_streambuf<
       _CharT, _Traits >::sungetc () [inline],  [inherited]

Moving backwards, bestie. If a putback position is available, this function decrements the input pointer and returns that character. Otherwise, it calls and returns pbackfail(). The effect is to unget the last character gotten.

Returns β€” The previous character, if possible.

References std::basic_streambuf< _CharT, _Traits >::eback(), std::basic_streambuf< _CharT, _Traits >::gbump(), std::basic_streambuf< _CharT, _Traits >::gptr(), and std::basic_streambuf< _CharT, _Traits >::pbackfail().


sync β€” synchronizes the buffer arrays with the controlled sequences 🌈

template<typename _Codecvt , typename _Elem  = wchar_t, typename _Tr  =
       char_traits<_Elem>> int std::wbuffer_convert< _Codecvt, _Elem, _Tr
       >::sync () [inline],  [protected],  [virtual]

This one synchronizes the buffer arrays with the controlled sequences. Each derived class provides its own appropriate behavior, including the definition of failure.

Returns β€” -1 on failure.

Note β€” the base class version does nothing and returns zero.

Reimplemented from std::basic_streambuf< _CharT, _Traits >.


uflow β€” fetches more data from the controlled sequence πŸ”₯

template<typename _CharT , typename _Traits > virtual int_type
       std::basic_streambuf< _CharT, _Traits >::uflow () [inline],
       [protected],  [virtual],  [inherited]

Fetches more data from the controlled 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. Not me being both "same as underflow" and "plus one" β€” okay, werk.

Returns β€” The first character from the pending sequence.

Reimplemented in __gnu_cxx::stdio_sync_filebuf< _CharT, _Traits >.

References std::basic_streambuf< _CharT, _Traits >::gbump(), std::basic_streambuf< _CharT, _Traits >::gptr(), and std::basic_streambuf< _CharT, _Traits >::underflow().

Referenced by std::basic_streambuf< _CharT, _Traits >::sbumpc().


underflow β€” fetches more data from the controlled sequence πŸ‘‘

template<typename _Codecvt , typename _Elem  = wchar_t, typename _Tr  =
       char_traits<_Elem>> _Wide_streambuf::int_type std::wbuffer_convert<
       _Codecvt, _Elem, _Tr >::underflow () [inline],  [protected],  [virtual]

Fetches more data from the controlled 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.

Returns β€” The first character from the pending sequence.

Note β€” the base class version does nothing and returns eof().

Reimplemented from std::basic_streambuf< _CharT, _Traits >.

References std::basic_streambuf< _CharT, _Traits >::egptr() and std::basic_streambuf< _CharT, _Traits >::gptr().

  • template<typename _CharT , typename _Traits > streamsize std::basic_streambuf< _CharT, _Traits >::xsgetn (char_type * __s, streamsize __n) [protected], [virtual], [inherited] β€” bestie this is the multiple character extraction girly πŸ’…

Parameters

  • __s β€” a buffer area, the lil landing spot 🫢
  • __n β€” max number of characters to assign

Returns the number of characters assigned, periodt ✨

So what it does: fills __s[0] through __s[__n-1] with characters from the input sequence, as if by sbumpc(). It stops when either __n characters have been copied, or when traits::eof() would be copied. That's the whole vibe check 😭

It is expected that derived classes provide a more efficient implementation by overriding this definition β€” like, the base version is giving default-template energy and the subclasses are the main characters πŸ”₯

Reimplemented in std::basic_filebuf< _CharT, _Traits >, std::basic_filebuf< _CharT, encoding_char_traits< _CharT > >, std::basic_filebuf< _CharT, std::char_traits< _CharT > >, and std::basic_filebuf< char_type, traits_type >.

References std::min().

Referenced by std::basic_streambuf< _CharT, _Traits >::sgetn().

  • template<typename _CharT , typename _Traits > streamsize std::basic_streambuf< _CharT, _Traits >::xsputn (const char_type * __s, streamsize __n) [protected], [virtual], [inherited] β€” and this one is multiple character insertion πŸŽ€

Parameters

  • __s β€” a buffer area
  • __n β€” max number of characters to write

Returns the number of characters written, no cap πŸ’–

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(). Very demure, very mindful about when to stop 🌸

It is expected that derived classes provide a more efficient implementation by overriding this definition β€” again bestie, the subclasses ate πŸ’…

Reimplemented in std::basic_filebuf< _CharT, _Traits >, std::basic_filebuf< _CharT, encoding_char_traits< _CharT > >, std::basic_filebuf< _CharT, std::char_traits< _CharT > >, and std::basic_filebuf< char_type, traits_type >.

References std::min().

Referenced by std::basic_streambuf< _CharT, _Traits >::sputn().


✨ Member Data Documentation ✨

These are the protected lil data members and honestly they're the backstage crew of this whole operation 🧚

  • template<typename _CharT , typename _Traits > locale std::basic_streambuf< _CharT, _Traits >::_M_buf_locale [protected], [inherited] β€” current locale setting 🌍 the vibe of where you're from, linguistically

Referenced by std::basic_filebuf< _CharT, _Traits >::basic_filebuf(), std::basic_streambuf< _CharT, _Traits >::getloc(), and std::basic_streambuf< _CharT, _Traits >::pubimbue().

  • template<typename _CharT , typename _Traits > char_type* std::basic_streambuf< _CharT, _Traits >::_M_in_beg [protected], [inherited] β€” start of get area ⭐ where the reading begins

Referenced by std::basic_streambuf< _CharT, _Traits >::eback(), and std::basic_streambuf< _CharT, _Traits >::setg().

  • template<typename _CharT , typename _Traits > char_type* std::basic_streambuf< _CharT, _Traits >::_M_in_cur [protected], [inherited] β€” current read area πŸ‘€ the "you are here" marker, like the little dot on the mall map

Referenced by std::basic_streambuf< _CharT, _Traits >::gbump(), std::basic_streambuf< _CharT, _Traits >::gptr(), and std::basic_streambuf< _CharT, _Traits >::setg().

  • template<typename _CharT , typename _Traits > char_type* std::basic_streambuf< _CharT, _Traits >::_M_in_end [protected], [inherited] β€” end of get area πŸ›‘ the boundary, don't cross it

Referenced by std::basic_streambuf< _CharT, _Traits >::egptr(), and std::basic_streambuf< _CharT, _Traits >::setg().

  • template<typename _CharT , typename _Traits > char_type* std::basic_streambuf< _CharT, _Traits >::_M_out_beg [protected], [inherited] β€” start of put area ✍️ where the writing starts

Referenced by std::basic_streambuf< _CharT, _Traits >::pbase(), and std::basic_streambuf< _CharT, _Traits >::setp().

  • template<typename _CharT , typename _Traits > char_type* std::basic_streambuf< _CharT, _Traits >::_M_out_cur [protected], [inherited] β€” current put area πŸ–ŠοΈ the pen tip rn

Referenced by std::basic_streambuf< _CharT, _Traits >::pbump(), std::basic_streambuf< _CharT, _Traits >::pptr(), and std::basic_streambuf< _CharT, _Traits >::setp().

  • template<typename _CharT , typename _Traits > char_type* std::basic_streambuf< _CharT, _Traits >::_M_out_end [protected], [inherited] β€” end of put area 🏁 the finish line for writing

Referenced by std::basic_streambuf< _CharT, _Traits >::epptr(), and std::basic_streambuf< _CharT, _Traits >::setp().


πŸ‘‘ Author πŸ‘‘

Generated automatically by Doxygen for libstdc++ from the source code. So like, nobody hand-wrote this for us β€” the robot did it while we were asleep 😴✨ iconic honestly.


okay that's the whole page bestie, you made it to the end!! πŸŽ‰πŸ’– go forth and streambuf responsibly. this was libstdc++ (that's the source it got pulled from), page std::wbuffer_co...t, _Elem, _Tr >(3cxx), and the date on the tin is the one right there at the bottom β€” mwah, slay, bye πŸ¦‹πŸ’…

πŸ“¦ where this page comes from