basic_streambuf< _Elem, _Traits > Class Template Reference

Inheritance diagram for basic_streambuf< _Elem, _Traits >:

Public Types
typedef _Elem	char_type
typedef _Traits	traits_type
typedef _Traits::int_type	int_type
typedef _Traits::pos_type	pos_type
typedef _Traits::off_type	off_type

Public Member Functions
virtual __CLR_OR_THIS_CALL	~basic_streambuf () _NOEXCEPT
pos_type __CLR_OR_THIS_CALL	pubseekoff (off_type _Off, ios_base::seekdir _Way, ios_base::openmode _Mode=ios_base::in|ios_base::out)
pos_type __CLR_OR_THIS_CALL	pubseekoff (off_type _Off, ios_base::seek_dir _Way, ios_base::open_mode _Mode)
pos_type __CLR_OR_THIS_CALL	pubseekpos (pos_type _Pos, ios_base::openmode _Mode=ios_base::in|ios_base::out)
pos_type __CLR_OR_THIS_CALL	pubseekpos (pos_type _Pos, ios_base::open_mode _Mode)
_Myt *__CLR_OR_THIS_CALL	pubsetbuf (_Elem *_Buffer, streamsize _Count)
locale __CLR_OR_THIS_CALL	pubimbue (const locale &_Newlocale)
locale __CLR_OR_THIS_CALL	getloc () const
streamsize __CLR_OR_THIS_CALL	in_avail ()
int __CLR_OR_THIS_CALL	pubsync ()
int_type __CLR_OR_THIS_CALL	sbumpc ()
int_type __CLR_OR_THIS_CALL	sgetc ()
streamsize __CLR_OR_THIS_CALL	sgetn (_Elem *_Ptr, streamsize _Count)
int_type __CLR_OR_THIS_CALL	snextc ()
int_type __CLR_OR_THIS_CALL	sputbackc (_Elem _Ch)
void __CLR_OR_THIS_CALL	stossc ()
int_type __CLR_OR_THIS_CALL	sungetc ()
int_type __CLR_OR_THIS_CALL	sputc (_Elem _Ch)
streamsize __CLR_OR_THIS_CALL	sputn (const _Elem *_Ptr, streamsize _Count)
virtual void __CLR_OR_THIS_CALL	_Lock ()
virtual void __CLR_OR_THIS_CALL	_Unlock ()

Protected Member Functions
__CLR_OR_THIS_CALL	basic_streambuf ()
__CLR_OR_THIS_CALL	basic_streambuf (_Uninitialized)
__CLR_OR_THIS_CALL	basic_streambuf (const _Myt &_Right)
_Myt &__CLR_OR_THIS_CALL	operator= (const _Myt &_Right)
void __CLR_OR_THIS_CALL	swap (_Myt &_Right)
_Elem *__CLR_OR_THIS_CALL	eback () const
_Elem *__CLR_OR_THIS_CALL	gptr () const
_Elem *__CLR_OR_THIS_CALL	pbase () const
_Elem *__CLR_OR_THIS_CALL	pptr () const
_Elem *__CLR_OR_THIS_CALL	egptr () const
void __CLR_OR_THIS_CALL	gbump (int _Off)
void __CLR_OR_THIS_CALL	setg (_Elem *_First, _Elem *_Next, _Elem *_Last)
_Elem *__CLR_OR_THIS_CALL	epptr () const
_Elem *__CLR_OR_THIS_CALL	_Gndec ()
_Elem *__CLR_OR_THIS_CALL	_Gninc ()
_Elem *__CLR_OR_THIS_CALL	_Gnpreinc ()
streamsize __CLR_OR_THIS_CALL	_Gnavail () const
void __CLR_OR_THIS_CALL	pbump (int _Off)
void __CLR_OR_THIS_CALL	setp (_Elem *_First, _Elem *_Last)
void __CLR_OR_THIS_CALL	setp (_Elem *_First, _Elem *_Next, _Elem *_Last)
_Elem *__CLR_OR_THIS_CALL	_Pninc ()
streamsize __CLR_OR_THIS_CALL	_Pnavail () const
void __CLR_OR_THIS_CALL	_Init ()
void __CLR_OR_THIS_CALL	_Init (_Elem **_Gf, _Elem **_Gn, int *_Gc, _Elem **_Pf, _Elem **_Pn, int *_Pc)
virtual int_type __CLR_OR_THIS_CALL	overflow (int_type=_Traits::eof())
virtual int_type __CLR_OR_THIS_CALL	pbackfail (int_type=_Traits::eof())
virtual streamsize __CLR_OR_THIS_CALL	showmanyc ()
virtual int_type __CLR_OR_THIS_CALL	underflow ()
virtual int_type __CLR_OR_THIS_CALL	uflow ()
virtual streamsize __CLR_OR_THIS_CALL	xsgetn (_Elem *_Ptr, streamsize _Count)
virtual streamsize __CLR_OR_THIS_CALL	xsputn (const _Elem *_Ptr, streamsize _Count)
virtual pos_type __CLR_OR_THIS_CALL	seekoff (off_type, ios_base::seekdir, ios_base::openmode=ios_base::in|ios_base::out)
virtual pos_type __CLR_OR_THIS_CALL	seekpos (pos_type, ios_base::openmode=ios_base::in|ios_base::out)
virtual _Myt *__CLR_OR_THIS_CALL	setbuf (_Elem *, streamsize)
virtual int __CLR_OR_THIS_CALL	sync ()
virtual void __CLR_OR_THIS_CALL	imbue (const locale &)

Protected Attributes
locale *	_Plocale

Private Types
typedef basic_streambuf< _Elem, _Traits >	_Myt

Private Attributes
_Elem *	_Gfirst
_Elem *	_Pfirst
_Elem **	_IGfirst
_Elem **	_IPfirst
_Elem *	_Gnext
_Elem *	_Pnext
_Elem **	_IGnext
_Elem **	_IPnext
int	_Gcount
int	_Pcount
int *	_IGcount
int *	_IPcount

Member Typedef Documentation

template<class _Elem, class _Traits>

typedef basic_streambuf<_Elem, _Traits> basic_streambuf< _Elem, _Traits >::_Myt

private

template<class _Elem, class _Traits>

typedef _Elem basic_streambuf< _Elem, _Traits >::char_type

template<class _Elem, class _Traits>

typedef _Traits::int_type basic_streambuf< _Elem, _Traits >::int_type

template<class _Elem, class _Traits>

typedef _Traits::off_type basic_streambuf< _Elem, _Traits >::off_type

template<class _Elem, class _Traits>

typedef _Traits::pos_type basic_streambuf< _Elem, _Traits >::pos_type

template<class _Elem, class _Traits>

typedef _Traits basic_streambuf< _Elem, _Traits >::traits_type

Constructor & Destructor Documentation

template<class _Elem, class _Traits>

__CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::basic_streambuf ( )

inlineprotected

        : _Plocale(_NEW_CRT locale)
        {   // construct with no buffers
        _Init();
        }

template<class _Elem, class _Traits>

__CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::basic_streambuf ( _Uninitialized  )

inlineprotected

        {   // construct uninitialized
        }

template<class _Elem, class _Traits>

__CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::basic_streambuf ( const _Myt &  _Right )

inlineprotected

        : _Plocale(_NEW_CRT locale(_Right.getloc()))
        {   // construct by copying _Right
        _Init();
        setp(_Right.pbase(), _Right.pptr(), _Right.epptr());
        setg(_Right.eback(), _Right.gptr(), _Right.egptr());
        }

template<class _Elem, class _Traits>

virtual __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::~basic_streambuf ( )

inlinevirtual

        {   // destroy the object
        _DELETE_CRT(_Plocale);
        }

Member Function Documentation

template<class _Elem, class _Traits>

streamsize __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::_Gnavail ( ) const

inlineprotected

        {   // count number of available elements in read buffer
        return (*_IGnext != 0 ? *_IGcount : 0);
        }

template<class _Elem, class _Traits>

_Elem* __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::_Gndec ( )

inlineprotected

        {   // decrement current position in read buffer
        ++*_IGcount;
        return (--*_IGnext);
        }

template<class _Elem, class _Traits>

_Elem* __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::_Gninc ( )

inlineprotected

        {   // increment current position in read buffer
        --*_IGcount;
        return ((*_IGnext)++);
        }

template<class _Elem, class _Traits>

_Elem* __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::_Gnpreinc ( )

inlineprotected

        {   // preincrement current position in read buffer
        --*_IGcount;
        return (++(*_IGnext));
        }

template<class _Elem, class _Traits>

void __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::_Init ( )

inlineprotected

        {   // initialize buffer parameters for no buffers
        _IGfirst = &_Gfirst;
        _IPfirst = &_Pfirst;
        _IGnext = &_Gnext;
        _IPnext = &_Pnext;
        _IGcount = &_Gcount;
        _IPcount = &_Pcount;
        setp(0, 0);
        setg(0, 0, 0);
        }

template<class _Elem, class _Traits>

void __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::_Init ( _Elem **  _Gf, _Elem **  _Gn, int *  _Gc, _Elem **  _Pf, _Elem **  _Pn, int *  _Pc  )

inlineprotected

        {   // initialize buffer parameters as specified
        _IGfirst = _Gf;
        _IPfirst = _Pf;
        _IGnext = _Gn;
        _IPnext = _Pn;
        _IGcount = _Gc;
        _IPcount = _Pc;
        }

template<class _Elem, class _Traits>

virtual void __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::_Lock ( )

inlinevirtual

Reimplemented in basic_filebuf< _Elem, _Traits >.

        {   // set the thread lock (overridden by basic_filebuf)
        }

template<class _Elem, class _Traits>

streamsize __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::_Pnavail ( ) const

inlineprotected

        {   // count number of available positions in write buffer
        return (*_IPnext != 0 ? *_IPcount : 0);
        }

template<class _Elem, class _Traits>

_Elem* __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::_Pninc ( )

inlineprotected

        {   // increment current position in write buffer
        --*_IPcount;
        return ((*_IPnext)++);
        }

template<class _Elem, class _Traits>

virtual void __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::_Unlock ( )

inlinevirtual

Reimplemented in basic_filebuf< _Elem, _Traits >.

        {   // clear the thread lock (overridden by basic_filebuf)
        }

template<class _Elem, class _Traits>

_Elem* __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::eback ( ) const

inlineprotected

        {   // return beginning of read buffer
        return (*_IGfirst);
        }

template<class _Elem, class _Traits>

_Elem* __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::egptr ( ) const

inlineprotected

        {   // return end of read buffer
        return (*_IGnext + *_IGcount);
        }

template<class _Elem, class _Traits>

_Elem* __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::epptr ( ) const

inlineprotected

        {   // return end of write buffer
        return (*_IPnext + *_IPcount);
        }

template<class _Elem, class _Traits>

void __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::gbump ( int  _Off )

inlineprotected

        {   // alter current position in read buffer by _Off
        *_IGcount -= _Off;
        *_IGnext += _Off;
        }

template<class _Elem, class _Traits>

locale __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::getloc ( ) const

inline

        {   // get locale
        return (*_Plocale);
        }

template<class _Elem, class _Traits>

_Elem* __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::gptr ( ) const

inlineprotected

        {   // return current position in read buffer
        return (*_IGnext);
        }

template<class _Elem, class _Traits>

virtual void __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::imbue ( const locale &  )

inlineprotectedvirtual

Reimplemented in basic_filebuf< _Elem, _Traits >.

        {   // set locale to argument (do nothing)
        }

template<class _Elem, class _Traits>

streamsize __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::in_avail ( )

inline

        {   // return count of buffered input characters
        streamsize _Res = _Gnavail();
        return (0 < _Res ? _Res : showmanyc());
        }

template<class _Elem, class _Traits>

_Myt& __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::operator= ( const _Myt &  _Right )

inlineprotected

        {   // assign from _Right
        if (this != &_Right)
            {   // different, worth copying
            setp(_Right.pbase(), _Right.pptr(), _Right.epptr());
            setg(_Right.eback(), _Right.gptr(), _Right.egptr());
            pubimbue(_Right.getloc());
            }
        return (*this);
        }

template<class _Elem, class _Traits>

virtual int_type __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::overflow ( int_type  = _Traits::eof() )

inlineprotectedvirtual

Reimplemented in basic_filebuf< _Elem, _Traits >, wbuffer_convert< _Codecvt, _Elem, _Traits >, and basic_stringbuf< _Elem, _Traits, _Alloc >.

        {   // put a character to stream (always fail)
        return (_Traits::eof());
        }

template<class _Elem, class _Traits>

virtual int_type __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::pbackfail ( int_type  = _Traits::eof() )

inlineprotectedvirtual

Reimplemented in basic_filebuf< _Elem, _Traits >, basic_stringbuf< _Elem, _Traits, _Alloc >, and wbuffer_convert< _Codecvt, _Elem, _Traits >.

        {   // put a character back to stream (always fail)
        return (_Traits::eof());
        }

template<class _Elem, class _Traits>

_Elem* __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::pbase ( ) const

inlineprotected

        {   // return beginning of write buffer
        return (*_IPfirst);
        }

template<class _Elem, class _Traits>

void __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::pbump ( int  _Off )

inlineprotected

        {   // alter current position in write buffer by _Off
        *_IPcount -= _Off;
        *_IPnext += _Off;
        }

template<class _Elem, class _Traits>

_Elem* __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::pptr ( ) const

inlineprotected

        {   // return current position in write buffer
        return (*_IPnext);
        }

template<class _Elem, class _Traits>

locale __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::pubimbue ( const locale &  _Newlocale )

inline

        {   // set locale to argument
        locale _Oldlocale = *_Plocale;
        imbue(_Newlocale);
        *_Plocale = _Newlocale;
        return (_Oldlocale);
        }

template<class _Elem, class _Traits>

pos_type __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::pubseekoff ( off_type  _Off, ios_base::seekdir  _Way, ios_base::openmode  _Mode = ios_base::in | ios_base::out  )

inline

        {   // change position by _Off, according to _Way, _Mode
        return (seekoff(_Off, _Way, _Mode));
        }

template<class _Elem, class _Traits>

pos_type __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::pubseekoff ( off_type  _Off, ios_base::seek_dir  _Way, ios_base::open_mode  _Mode  )

inline

        {   // change position by _Off, according to _Way, _Mode (old style)
        return (pubseekoff(_Off, (ios_base::seekdir)_Way,
            (ios_base::openmode)_Mode));
        }

template<class _Elem, class _Traits>

pos_type __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::pubseekpos ( pos_type  _Pos, ios_base::openmode  _Mode = ios_base::in | ios_base::out  )

inline

        {   // change position to _Pos, according to _Mode
        return (seekpos(_Pos, _Mode));
        }

template<class _Elem, class _Traits>

pos_type __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::pubseekpos ( pos_type  _Pos, ios_base::open_mode  _Mode  )

inline

        {   // change position to _Pos, according to _Mode (old style)
        return (seekpos(_Pos, (ios_base::openmode)_Mode));
        }

template<class _Elem, class _Traits>

_Myt* __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::pubsetbuf ( _Elem *  _Buffer, streamsize  _Count  )

inline

        {   // offer _Buffer to external agent
        return (setbuf(_Buffer, _Count));
        }

template<class _Elem, class _Traits>

int __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::pubsync ( )

inline

        {   // synchronize with external agent
        return (sync());
        }

template<class _Elem, class _Traits>

int_type __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::sbumpc ( )

inline

        {   // get a character and point past it
        return (0 < _Gnavail()
            ? _Traits::to_int_type(*_Gninc()) : uflow());
        }

template<class _Elem, class _Traits>

virtual pos_type __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::seekoff ( off_type  , ios_base::seekdir  , ios_base::openmode  = ios_base::in | ios_base::out  )

inlineprotectedvirtual

Reimplemented in basic_filebuf< _Elem, _Traits >, and basic_stringbuf< _Elem, _Traits, _Alloc >.

        {   // change position by offset, according to way and mode
        return (streampos(_BADOFF));
        }

template<class _Elem, class _Traits>

virtual pos_type __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::seekpos ( pos_type  , ios_base::openmode  = ios_base::in | ios_base::out  )

inlineprotectedvirtual

Reimplemented in basic_filebuf< _Elem, _Traits >, and basic_stringbuf< _Elem, _Traits, _Alloc >.

        {   // change to specified position, according to mode
        return (streampos(_BADOFF));
        }

template<class _Elem, class _Traits>

virtual _Myt* __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::setbuf ( _Elem *  , streamsize    )

inlineprotectedvirtual

Reimplemented in basic_filebuf< _Elem, _Traits >.

        {   // offer buffer to external agent (do nothing)
        return (this);
        }

template<class _Elem, class _Traits>

void __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::setg ( _Elem *  _First, _Elem *  _Next, _Elem *  _Last  )

inlineprotected

        {   // set pointers for read buffer
        *_IGfirst = _First;
        *_IGnext = _Next;
        *_IGcount = (int)(_Last - _Next);
        }

template<class _Elem, class _Traits>

void __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::setp ( _Elem *  _First, _Elem *  _Last  )

inlineprotected

        {   // set pointers for write buffer
        *_IPfirst = _First;
        *_IPnext = _First;
        *_IPcount = (int)(_Last - _First);
        }

template<class _Elem, class _Traits>

void __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::setp ( _Elem *  _First, _Elem *  _Next, _Elem *  _Last  )

inlineprotected

        {   // set pointers for write buffer, extended version
        *_IPfirst = _First;
        *_IPnext = _Next;
        *_IPcount = (int)(_Last - _Next);
        }

template<class _Elem, class _Traits>

int_type __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::sgetc ( )

inline

        {   // get a character and don't point past it
        return (0 < _Gnavail()
            ? _Traits::to_int_type(*gptr()) : underflow());
        }

template<class _Elem, class _Traits>

streamsize __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::sgetn ( _Elem *  _Ptr, streamsize  _Count  )

inline

        {   // get up to _Count characters into array beginning at _Ptr
        return (xsgetn(_Ptr, _Count));
        }

template<class _Elem, class _Traits>

virtual streamsize __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::showmanyc ( )

inlineprotectedvirtual

        {   // return count of input characters
        return (0);
        }

template<class _Elem, class _Traits>

int_type __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::snextc ( )

inline

        {   // point to next character and return it
        return (1 < _Gnavail()
            ? _Traits::to_int_type(*_Gnpreinc())
            : _Traits::eq_int_type(_Traits::eof(), sbumpc())
                ? _Traits::eof() : sgetc());
        }

template<class _Elem, class _Traits>

int_type __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::sputbackc ( _Elem  _Ch )

inline

        {   // put back _Ch
        return (gptr() != 0 && eback() < gptr()
            && _Traits::eq(_Ch, gptr()[-1])
            ? _Traits::to_int_type(*_Gndec())
            : pbackfail(_Traits::to_int_type(_Ch)));
        }

template<class _Elem, class _Traits>

int_type __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::sputc ( _Elem  _Ch )

inline

        {   // put a character
        return (0 < _Pnavail()
            ? _Traits::to_int_type(*_Pninc() = _Ch)
            : overflow(_Traits::to_int_type(_Ch)));
        }

template<class _Elem, class _Traits>

streamsize __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::sputn ( const _Elem *  _Ptr, streamsize  _Count  )

inline

        {   // put _Count characters from array beginning at _Ptr
        return (xsputn(_Ptr, _Count));
        }

template<class _Elem, class _Traits>

void __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::stossc ( )

inline

        {   // point past a character
        if (0 < _Gnavail())
            _Gninc();
        else
            uflow();
        }

template<class _Elem, class _Traits>

int_type __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::sungetc ( )

inline

        {   // back up one position
        return (gptr() != 0 && eback() < gptr()
            ? _Traits::to_int_type(*_Gndec()) : pbackfail());
        }

template<class _Elem, class _Traits>

void __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::swap ( _Myt &  _Right )

inlineprotected

        {   // swap with _Right
        if (this != &_Right)
            {   // different, worth swapping
            _Elem *_Pfirst = pbase();
            _Elem *_Pnext = pptr();
            _Elem *_Pend = epptr();
            _Elem *_Gfirst = eback();
            _Elem *_Gnext = gptr();
            _Elem *_Gend = egptr();

            setp(_Right.pbase(), _Right.pptr(), _Right.epptr());
            _Right.setp(_Pfirst, _Pnext, _Pend);

            setg(_Right.eback(), _Right.gptr(), _Right.egptr());
            _Right.setg(_Gfirst, _Gnext, _Gend);

            _STD swap(_Plocale, _Right._Plocale);
            }
        }

template<class _Elem, class _Traits>

virtual int __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::sync ( )

inlineprotectedvirtual

Reimplemented in basic_filebuf< _Elem, _Traits >.

        {   // synchronize with external agent (do nothing)
        return (0);
        }

template<class _Elem, class _Traits>

virtual int_type __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::uflow ( )

inlineprotectedvirtual

Reimplemented in basic_filebuf< _Elem, _Traits >, and wbuffer_convert< _Codecvt, _Elem, _Traits >.

        {   // get a character from stream, point past it
        return (_Traits::eq_int_type(_Traits::eof(), underflow())
            ? _Traits::eof() : _Traits::to_int_type(*_Gninc()));
        }

template<class _Elem, class _Traits>

virtual int_type __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::underflow ( )

inlineprotectedvirtual

Reimplemented in basic_filebuf< _Elem, _Traits >, strstreambuf, basic_stringbuf< _Elem, _Traits, _Alloc >, and wbuffer_convert< _Codecvt, _Elem, _Traits >.

        {   // get a character from stream, but don't point past it
        return (_Traits::eof());
        }

template<class _Elem, class _Traits>

virtual streamsize __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::xsgetn ( _Elem *  _Ptr, streamsize  _Count  )

inlineprotectedvirtual

        {   // get _Count characters from stream
        int_type _Meta;
        streamsize _Size, _Copied;

        for (_Copied = 0; 0 < _Count; )
            if (0 < (_Size = _Gnavail()))
                {   // copy from read buffer
                if (_Count < _Size)
                    _Size = _Count;
                _Traits::copy(_Ptr, gptr(), (size_t)_Size);
                _Ptr += _Size;
                _Copied += _Size;
                _Count -= _Size;
                gbump((int)_Size);
                }
            else if (_Traits::eq_int_type(_Traits::eof(), _Meta = uflow()))
                break;  // end of file, quit
            else
                {   // get a single character
                *_Ptr++ = _Traits::to_char_type(_Meta);
                ++_Copied;
                --_Count;
                }

        return (_Copied);
        }

template<class _Elem, class _Traits>

virtual streamsize __CLR_OR_THIS_CALL basic_streambuf< _Elem, _Traits >::xsputn ( const _Elem *  _Ptr, streamsize  _Count  )

inlineprotectedvirtual

        {   // put _Count characters to stream
        streamsize _Size, _Copied;

        for (_Copied = 0; 0 < _Count; )
            if (0 < (_Size = _Pnavail()))
                {   // copy to write buffer
                if (_Count < _Size)
                    _Size = _Count;
                _Traits::copy(pptr(), _Ptr, (size_t)_Size);
                _Ptr += _Size;
                _Copied += _Size;
                _Count -= _Size;
                pbump((int)_Size);
                }
            else if (_Traits::eq_int_type(_Traits::eof(),
                overflow(_Traits::to_int_type(*_Ptr))))
                break;  // single character put failed, quit
            else
                {   // count character successfully put
                ++_Ptr;
                ++_Copied;
                --_Count;
                }

        return (_Copied);
        }

Member Data Documentation

template<class _Elem, class _Traits>

int basic_streambuf< _Elem, _Traits >::_Gcount

private

template<class _Elem, class _Traits>

_Elem* basic_streambuf< _Elem, _Traits >::_Gfirst

private

template<class _Elem, class _Traits>

_Elem* basic_streambuf< _Elem, _Traits >::_Gnext

private

template<class _Elem, class _Traits>

int* basic_streambuf< _Elem, _Traits >::_IGcount

private

template<class _Elem, class _Traits>

_Elem** basic_streambuf< _Elem, _Traits >::_IGfirst

private

template<class _Elem, class _Traits>

_Elem** basic_streambuf< _Elem, _Traits >::_IGnext

private

template<class _Elem, class _Traits>

int* basic_streambuf< _Elem, _Traits >::_IPcount

private

template<class _Elem, class _Traits>

_Elem** basic_streambuf< _Elem, _Traits >::_IPfirst

private

template<class _Elem, class _Traits>

_Elem** basic_streambuf< _Elem, _Traits >::_IPnext

private

template<class _Elem, class _Traits>

int basic_streambuf< _Elem, _Traits >::_Pcount

private

template<class _Elem, class _Traits>

_Elem* basic_streambuf< _Elem, _Traits >::_Pfirst

private

template<class _Elem, class _Traits>

locale* basic_streambuf< _Elem, _Traits >::_Plocale

protected

template<class _Elem, class _Traits>

_Elem* basic_streambuf< _Elem, _Traits >::_Pnext

private

---

The documentation for this class was generated from the following files:

• VS2013/inc/iosfwd
• VS2013/inc/streambuf