strstreambuf Class Reference

Inheritance diagram for strstreambuf:

Public Types
enum	{ _Allocated = 1, _Constant = 2, _Dynamic = 4, _Frozen = 8 }
typedef strstreambuf	_Myt
typedef streambuf	_Mysb
typedef int	_Strstate
Public Types inherited from basic_streambuf< _Elem, _Traits >
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
__CLR_OR_THIS_CALL	strstreambuf (streamsize _Count=0)
__CLR_OR_THIS_CALL	strstreambuf (void *(__CLRCALL_OR_CDECL *_Allocfunc)(size_t), void(__CLRCALL_OR_CDECL *_Freefunc)(void *))
__CLR_OR_THIS_CALL	strstreambuf (_In_opt_z_ char *_Getptr, streamsize _Count, _In_opt_z_ char *_Putptr=0)
__CLR_OR_THIS_CALL	strstreambuf (_In_z_ const char *_Getptr, streamsize _Count)
__CLR_OR_THIS_CALL	strstreambuf (_In_opt_z_ unsigned char *_Getptr, streamsize _Count, _In_opt_z_ unsigned char *_Putptr=0)
__CLR_OR_THIS_CALL	strstreambuf (_In_opt_z_ const unsigned char *_Getptr, streamsize _Count)
__CLR_OR_THIS_CALL	strstreambuf (_Myt &&_Right)
_Myt &__CLR_OR_THIS_CALL	operator= (_Myt &&_Right)
void __CLR_OR_THIS_CALL	_Assign_rv (_Myt &&_Right)
void __CLR_OR_THIS_CALL	swap (_Myt &_Right)
virtual __CLR_OR_THIS_CALL	~strstreambuf () _NOEXCEPT
void __CLR_OR_THIS_CALL	freeze (bool _Freezeit=true)
char *__CLR_OR_THIS_CALL	str ()
streamsize __CLR_OR_THIS_CALL	pcount () const
__CLR_OR_THIS_CALL	strstreambuf (_In_opt_z_ signed char *_Getptr, streamsize _Count, _In_opt_z_ signed char *_Putptr=0)
__CLR_OR_THIS_CALL	strstreambuf (const signed char *_Getptr, streamsize _Count)
void	clear ()
Public Member Functions inherited from basic_streambuf< _Elem, _Traits >
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	pubseekpos (pos_type _Pos, ios_base::openmode _Mode=ios_base::in|ios_base::out)
_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)
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
virtual int __CLR_OR_THIS_CALL	overflow (int _Meta=EOF)
virtual int __CLR_OR_THIS_CALL	pbackfail (int _Meta=EOF)
virtual int __CLR_OR_THIS_CALL	underflow ()
virtual streampos __CLR_OR_THIS_CALL	seekoff (streamoff _Off_arg, ios_base::seekdir _Way, ios_base::openmode _Which=ios_base::in|ios_base::out)
virtual streampos __CLR_OR_THIS_CALL	seekpos (streampos _Sp, ios_base::openmode _Which=ios_base::in|ios_base::out)
void __CLR_OR_THIS_CALL	_Init (streamsize _Count=0, char *_Gp=0, char *_Pp=0, _Strstate _Mode=(_Strstate) 0)
void __CLR_OR_THIS_CALL	_Tidy ()
Protected Member Functions inherited from basic_streambuf< _Elem, _Traits >
__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	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 &)

Private Types
enum	{ _MINSIZE = 32 }

Private Member Functions
void *__CLRCALL_OR_CDECL *	_Palloc (size_t)
	void (__CLRCALL_OR_CDECL *_Pfree)(void *)

Private Attributes
int	_Minsize
char *	_Pendsave
char *	_Seekhigh
_Strstate	_Strmode

Additional Inherited Members
Protected Attributes inherited from basic_streambuf< _Elem, _Traits >
locale *	_Plocale

Member Typedef Documentation

typedef streambuf strstreambuf::_Mysb

typedef strstreambuf strstreambuf::_Myt

typedef int strstreambuf::_Strstate

Member Enumeration Documentation

anonymous enum

Enumerator
_Allocated
_Constant
_Dynamic
_Frozen

        {   // constants for bits in stream state
        _Allocated = 1, // set if character array storage has been allocated
        _Constant = 2,  // set if character array nonmutable
        _Dynamic = 4,   // set if character array length grows on demand
        _Frozen = 8};   // set if character array ownership given away

anonymous enum

private

Enumerator
_MINSIZE

        {   // constant for default minimum buffer size
        _MINSIZE = 32};

Constructor & Destructor Documentation

__CLR_OR_THIS_CALL strstreambuf::strstreambuf ( streamsize  _Count = 0 )

inlineexplicit

        {   // construct with empty character array, suggested initial size
        _Init(_Count);
        }

__CLR_OR_THIS_CALL strstreambuf::strstreambuf ( void *  __CLRCALL_OR_CDECL *_Allocfunc)(size_t, void(__CLRCALL_OR_CDECL *_Freefunc)(void *)    )

inline

        {   // construct with empty character array, allocation functions
        _Init();
        _Palloc = _Allocfunc;
        _Pfree = _Freefunc;
        }

__CLR_OR_THIS_CALL strstreambuf::strstreambuf ( _In_opt_z_ char *  _Getptr, streamsize  _Count, _In_opt_z_ char *  _Putptr = 0  )

inline

        {   // construct with [_Getptr, _Getptr + _Count), possibly mutable
        _Init(_Count, _Getptr, _Putptr);
        }

__CLR_OR_THIS_CALL strstreambuf::strstreambuf ( _In_z_ const char *  _Getptr, streamsize  _Count  )

inline

        {   // construct with [_Getptr, _Getptr + _Count), nonmutable
        _Init(_Count, (char *)_Getptr, 0, _Constant);
        }

__CLR_OR_THIS_CALL strstreambuf::strstreambuf ( _In_opt_z_ unsigned char *  _Getptr, streamsize  _Count, _In_opt_z_ unsigned char *  _Putptr = 0  )

inline

        {   // construct with [_Getptr, _Getptr + _Count), possibly mutable
        _Init(_Count, (char *)_Getptr, (char *)_Putptr);
        }

__CLR_OR_THIS_CALL strstreambuf::strstreambuf ( _In_opt_z_ const unsigned char *  _Getptr, streamsize  _Count  )

inline

        {   // construct with [_Getptr, _Getptr + _Count), nonmutable
        _Init(_Count, (char *)_Getptr, 0, _Constant);
        }

__CLR_OR_THIS_CALL strstreambuf::strstreambuf ( _Myt &&  _Right )

inline

        {   // construct by moving _Right
        _Init();
        _Assign_rv(_STD forward<_Myt>(_Right));
        }

virtual __CLR_OR_THIS_CALL strstreambuf::~strstreambuf ( )

inlinevirtual

        {   // destroy a strstreambuf
        _Tidy();
        }

__CLR_OR_THIS_CALL strstreambuf::strstreambuf ( _In_opt_z_ signed char *  _Getptr, streamsize  _Count, _In_opt_z_ signed char *  _Putptr = 0  )

inline

        {   // construct with [_Getptr, _Getptr + _Count), possibly mutable
        _Init(_Count, (char *)_Getptr, (char *)_Putptr);
        }

__CLR_OR_THIS_CALL strstreambuf::strstreambuf ( const signed char *  _Getptr, streamsize  _Count  )

inline

        {   // construct with [_Getptr, _Getptr + _Count), nonmutable
        _Init(_Count, (char *)_Getptr, 0, _Constant);
        }

Member Function Documentation

void __CLR_OR_THIS_CALL strstreambuf::_Assign_rv ( _Myt &&  _Right )

inline

        {   // assign by moving _Right
        if (this != &_Right)
            {   // different, worth moving
            _Tidy();
            this->swap(_Right);
            }
        }

void __CLR_OR_THIS_CALL strstreambuf::_Init ( streamsize  _Count = 0, char *  _Gp = 0, char *  _Pp = 0, _Strstate  _Mode = (_Strstate)0  )

inlineprotected

        {   // initialize with possibly static buffer
        streambuf::_Init();
        _Minsize = _MINSIZE;
        _Pendsave = 0;
        _Seekhigh = 0;
        _Palloc = 0;
        _Pfree = 0;
        _Strmode = _Mode;

        if (_Gp == 0)
            {   // make dynamic
            _Strmode |= _Dynamic;
            if (_Minsize < _Count)
                _Minsize = (int)_Count;
            }
        else
            {   // make static
            size_t _Size = _Count < 0 ? INT_MAX
                : _Count == 0 ? _CSTD strlen(_Gp)
                : (size_t)_Count;
            _Seekhigh = _Gp + _Size;

            if (_Pp == 0)
                setg(_Gp, _Gp, _Gp + _Size);    // set read pointers only
            else
                {   // make writable too
                if (_Pp < _Gp)
                    _Pp = _Gp;
                else if (_Gp + _Size < _Pp)
                    _Pp = _Gp + _Size;
                setp(_Pp, _Gp + _Size);
                setg(_Gp, _Gp, _Pp);
                }
            }
        }

void* __CLRCALL_OR_CDECL* strstreambuf::_Palloc ( size_t  )

private

void __CLR_OR_THIS_CALL strstreambuf::_Tidy ( )

inlineprotected

        {   // free any allocated storage
        if ((_Strmode & (_Allocated | _Frozen)) != _Allocated)
            ;   // no buffer to free
        else if (_Pfree != 0)
            (*_Pfree)(eback()); // free with function call
        else
            _CSTD free(eback());    // free by deleting array

        _Seekhigh = 0;
        _Strmode &= ~(_Allocated | _Frozen);
        }

void strstreambuf::clear ( )

inline

        {   // free any allocated storage
        _Tidy();
        }

void __CLR_OR_THIS_CALL strstreambuf::freeze ( bool  _Freezeit = true )

inline

        {   // freeze or unfreeze writing
        if (_Freezeit && !(_Strmode & _Frozen))
            {   // disable writing
            _Strmode |= _Frozen;
            _Pendsave = epptr();
            setp(pbase(), pptr(), eback());
            }
        else if (!_Freezeit && _Strmode & _Frozen)
            {   // re-enable writing
            _Strmode &= ~_Frozen;
            setp(pbase(), pptr(), _Pendsave);
            }
        }

_Myt& __CLR_OR_THIS_CALL strstreambuf::operator= ( _Myt &&  _Right )

inline

        {   // assign by moving _Right
        _Assign_rv(_STD forward<_Myt>(_Right));
        return (*this);
        }

virtual int __CLR_OR_THIS_CALL strstreambuf::overflow ( int  _Meta = EOF )

inlineprotectedvirtual

        {   // try to extend write area
        if (_Meta == EOF)
            return (0); // nothing to write
        else if (pptr() != 0 && pptr() < epptr())
            return ((unsigned char)(*_Pninc() = (char)_Meta));
        else if (!(_Strmode & _Dynamic)
            || _Strmode & (_Constant | _Frozen))
            return (EOF);   // can't extend
        else
            {   // okay to extend
            int _Oldsize = gptr() == 0 ? 0 : (int)(epptr() - eback());
            int _Newsize = _Oldsize;
            int _Inc = _Newsize / 2 < _Minsize
                ? _Minsize : _Newsize / 2;  // grow by 50 per cent if possible
            _Minsize = _MINSIZE;    // back to default for future growth
            char *_Ptr = 0;

            while (0 < _Inc && INT_MAX - _Inc < _Newsize)
                _Inc /= 2;  // reduce growth increment if too big
            if (0 < _Inc)
                {   // room to grow, increase size
                _Newsize += _Inc;

                _Ptr = _Palloc != 0 ? (char *)(*_Palloc)(_Newsize)
                    : (char *)_malloc_dbg(_Newsize, _CRT_BLOCK,
                        __FILE__, __LINE__);
                }
            if (_Ptr == 0)
                return (EOF);   // couldn't grow, return failure

            if (0 < _Oldsize)
                _CSTD memcpy(_Ptr, eback(), _Oldsize);  // copy existing
            if (!(_Strmode & _Allocated))
                ;   // no buffer to free
            else if (_Pfree != 0)
                (*_Pfree)(eback()); // free with function call
            else
                _CSTD free(eback());    // free by deleting array
            _Strmode |= _Allocated;
            if (_Oldsize == 0)
                {   // set up new buffer
                _Seekhigh = _Ptr;
                setp(_Ptr, _Ptr + _Newsize);
                setg(_Ptr, _Ptr, _Ptr);
                }
            else
                {   // revise old pointers
                _Seekhigh = _Seekhigh - eback() + _Ptr;
                setp(pbase() - eback() + _Ptr, pptr() - eback() + _Ptr,
                    _Ptr + _Newsize);
                setg(_Ptr, gptr() - eback() + _Ptr, pptr() + 1);
                }

            return ((unsigned char)(*_Pninc() = (char)_Meta));
            }
        }

virtual int __CLR_OR_THIS_CALL strstreambuf::pbackfail ( int  _Meta = EOF )

inlineprotectedvirtual

        {   // try to putback a character
        if (gptr() == 0 || gptr() <= eback() || (_Meta != EOF
                && (unsigned char)_Meta != (unsigned char)gptr()[-1]
                && _Strmode & _Constant))
            return (EOF);   // can't put it back
        else
            {   // safe to back up
            gbump(-1);
            if (_Meta != EOF && *gptr() != (char)_Meta)
                *gptr() = (char)_Meta;
            return (_Meta == EOF ? 0 : (unsigned char)_Meta);
            }
        }

streamsize __CLR_OR_THIS_CALL strstreambuf::pcount ( ) const

inline

        {   // return size of writable character array
        return (pptr() == 0 ? 0 : (streamsize)(pptr() - pbase()));
        }

virtual streampos __CLR_OR_THIS_CALL strstreambuf::seekoff ( streamoff  _Off_arg, ios_base::seekdir  _Way, ios_base::openmode  _Which = ios_base::in | ios_base::out  )

inlineprotectedvirtual

        {   // seek by specified offset
        int _Off = (int)_Off_arg;

        if (pptr() != 0 && (int)(_Seekhigh - pptr()) < 0)   // sic
            _Seekhigh = pptr(); // update high water mark

        if (_Which & ios_base::in && gptr() != 0)
            {   // set input (and maybe output) pointer
            if (_Way == ios_base::end)
                _Off += (int)(_Seekhigh - eback()); // seek from end
            else if (_Way == ios_base::cur
                && !(_Which & ios_base::out))
                _Off += (int)(gptr() - eback());    // seek from current
            else if (_Way != ios_base::beg || _Off == (int)_BADOFF)
                _Off = (int)_BADOFF;    // invalid seek
            if (0 <= _Off && _Off <= (int)(_Seekhigh - eback()))
                {   // seek from beginning, set one or two pointers
                gbump(_Off - (int)(gptr() - eback()));
                if (_Which & ios_base::out && pptr() != 0)
                    setp(pbase(), gptr(), epptr());
                }
            else
                _Off = (int)_BADOFF;    // invalid seek from beginning
            }
        else if (_Which & ios_base::out && pptr() != 0)
            {   // set only output pointer
            if (_Way == ios_base::end)
                _Off += (int)(_Seekhigh - eback()); // seek from end
            else if (_Way == ios_base::cur)
                _Off += (int)(pptr() - eback());    // seek from current
            else if (_Way != ios_base::beg || _Off == (int)_BADOFF)
                _Off = (int)_BADOFF;    // invalid seek
            if (0 <= _Off && _Off <= (int)(_Seekhigh - eback()))
                pbump(_Off - (int)(pptr() - eback()));  // seek from beginning
            else
                _Off = (int)_BADOFF;    // invalid seek from beginning
            }
        else
            _Off = (int)_BADOFF;    // nothing to set
        return (streampos((streamoff)_Off));
        }

virtual streampos __CLR_OR_THIS_CALL strstreambuf::seekpos ( streampos  _Sp, ios_base::openmode  _Which = ios_base::in | ios_base::out  )

inlineprotectedvirtual

        {   // seek to memorized position
        int _Off = (int)(streamoff)_Sp;

        if (pptr() != 0 && (int)(_Seekhigh - pptr()) < 0)   // sic
            _Seekhigh = pptr(); // update high water mark

        if (_Off == (int)_BADOFF)
            ;   // invalid seek
        else if (_Which & ios_base::in && gptr() != 0)
            {   // set input (and maybe output) pointer
            if (0 <= _Off && _Off <= (int)(_Seekhigh - eback()))
                {   // set valid offset
                gbump(_Off - (int)(gptr() - eback()));
                if (_Which & ios_base::out && pptr() != 0)
                    setp(pbase(), gptr(), epptr());
                }
            else
                _Off = (int)_BADOFF;    // offset invalid, don't seek
            }
        else if (_Which & ios_base::out && pptr() != 0)
            {   // set output pointer
            if (0 <= _Off && _Off <= (int)(_Seekhigh - eback()))
                pbump(_Off - (int)(pptr() - eback()));  // seek from beginning
            else
                _Off = (int)_BADOFF;    // offset invalid, don't seek
            }
        else
            _Off = (int)_BADOFF;    // nothing to set
        return (streampos((streamoff)_Off));
        }

char* __CLR_OR_THIS_CALL strstreambuf::str ( )

inline

        {   // freeze and return pointer to character array
        freeze();
        return (gptr());
        }

void __CLR_OR_THIS_CALL strstreambuf::swap ( _Myt &  _Right )

inline

        {   // swap with _Right
        if (this != &_Right)
            {   // different, worth swapping
            _Mysb::swap(_Right);
            _STD swap(_Minsize, _Right._Minsize);
            _STD swap(_Pendsave, _Right._Pendsave);
            _STD swap(_Seekhigh, _Right._Seekhigh);
            _STD swap(_Strmode, _Right._Strmode);
            _STD swap(_Palloc, _Right._Palloc);
            _STD swap(_Pfree, _Right._Pfree);
            }
        }

virtual int __CLR_OR_THIS_CALL strstreambuf::underflow ( )

inlineprotectedvirtual

Reimplemented from basic_streambuf< _Elem, _Traits >.

        {   // read if read position available
        if (gptr() == 0)
            return (EOF);   // no read buffer
        else if (gptr() < egptr())
            return ((unsigned char)*gptr());    // char in buffer, read it
        else if (pptr() == 0 || (pptr() <= gptr() && _Seekhigh <= gptr()))
            return (EOF);   // no write buffer to read
        else
            {   // update _Seekhigh and expand read region
            if (_Seekhigh < pptr())
                _Seekhigh = pptr();
            setg(eback(), gptr(), _Seekhigh);
            return ((unsigned char)*gptr());
            }
        }

strstreambuf::void ( __CLRCALL_OR_CDECL *  _Pfree )

private

Member Data Documentation

int strstreambuf::_Minsize

private

char* strstreambuf::_Pendsave

private

char* strstreambuf::_Seekhigh

private

_Strstate strstreambuf::_Strmode

private

---

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

• VS2015/inc/strstream