basic_stringbuf< _Elem, _Traits, _Alloc > Class Template Reference

Inheritance diagram for basic_stringbuf< _Elem, _Traits, _Alloc >:

Public Types
enum	{   _Allocated = 1, _Constant = 2, _Noread = 4, _Append = 8,   _Atend = 16 }
typedef basic_stringbuf< _Elem, _Traits, _Alloc >	_Myt
typedef _Alloc	allocator_type
typedef basic_streambuf< _Elem, _Traits >	_Mysb
typedef basic_string< _Elem, _Traits, _Alloc >	_Mystr
typedef int	_Strstate
typedef _Traits::int_type	int_type
typedef _Traits::pos_type	pos_type
typedef _Traits::off_type	off_type
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
	basic_stringbuf (ios_base::openmode _Mode=ios_base::in|ios_base::out)
	basic_stringbuf (const _Mystr &_Str, ios_base::openmode _Mode=ios_base::in|ios_base::out)
	basic_stringbuf (_Myt &&_Right)
_Myt &	operator= (_Myt &&_Right)
void	_Assign_rv (_Myt &&_Right)
void	swap (_Myt &_Right)
	basic_stringbuf (const _Myt &)=delete
_Myt &	operator= (const _Myt &)=delete
virtual	~basic_stringbuf () _NOEXCEPT
_Mystr	str () const
void	str (const _Mystr &_Newstr)
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_type	overflow (int_type _Meta=_Traits::eof())
virtual int_type	pbackfail (int_type _Meta=_Traits::eof())
virtual int_type	underflow ()
virtual pos_type	seekoff (off_type _Off, ios_base::seekdir _Way, ios_base::openmode _Which=ios_base::in|ios_base::out)
virtual pos_type	seekpos (pos_type _Ptr, ios_base::openmode _Mode=ios_base::in|ios_base::out)
void	_Init (const _Elem *_Ptr, size_t _Count, _Strstate _State)
void	_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 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 _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
_Strstate	_Getstate (ios_base::openmode _Mode)

Private Attributes
_Elem *	_Seekhigh
_Strstate	_Mystate
allocator_type	_Al

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

Member Typedef Documentation

template<class _Elem, class _Traits, class _Alloc>

typedef basic_streambuf<_Elem, _Traits> basic_stringbuf< _Elem, _Traits, _Alloc >::_Mysb

template<class _Elem, class _Traits, class _Alloc>

typedef basic_string<_Elem, _Traits, _Alloc> basic_stringbuf< _Elem, _Traits, _Alloc >::_Mystr

template<class _Elem, class _Traits, class _Alloc>

typedef basic_stringbuf<_Elem, _Traits, _Alloc> basic_stringbuf< _Elem, _Traits, _Alloc >::_Myt

template<class _Elem, class _Traits, class _Alloc>

typedef int basic_stringbuf< _Elem, _Traits, _Alloc >::_Strstate

template<class _Elem, class _Traits, class _Alloc>

typedef _Alloc basic_stringbuf< _Elem, _Traits, _Alloc >::allocator_type

template<class _Elem, class _Traits, class _Alloc>

typedef _Traits::int_type basic_stringbuf< _Elem, _Traits, _Alloc >::int_type

template<class _Elem, class _Traits, class _Alloc>

typedef _Traits::off_type basic_stringbuf< _Elem, _Traits, _Alloc >::off_type

template<class _Elem, class _Traits, class _Alloc>

typedef _Traits::pos_type basic_stringbuf< _Elem, _Traits, _Alloc >::pos_type

Member Enumeration Documentation

template<class _Elem, class _Traits, class _Alloc>

anonymous enum

Enumerator
_Allocated
_Constant
_Noread
_Append
_Atend

        {   // constants for bits in stream state
        _Allocated = 1, // set if character array storage has been allocated
        _Constant = 2,  // set if character array nonmutable
        _Noread = 4,    // set if character array cannot be read
        _Append = 8,    // set if all writes are appends
        _Atend = 16};   // set if initial writes are appends

template<class _Elem, class _Traits, class _Alloc>

anonymous enum

private

Enumerator
_MINSIZE

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

Constructor & Destructor Documentation

template<class _Elem, class _Traits, class _Alloc>

basic_stringbuf< _Elem, _Traits, _Alloc >::basic_stringbuf ( ios_base::openmode  _Mode = ios_base::in | ios_base::out )

inlineexplicit

        {   // construct empty character buffer from mode
        _Init(0, 0, _Getstate(_Mode));
        }

template<class _Elem, class _Traits, class _Alloc>

basic_stringbuf< _Elem, _Traits, _Alloc >::basic_stringbuf ( const _Mystr &  _Str, ios_base::openmode  _Mode = ios_base::in | ios_base::out  )

inlineexplicit

        {   // construct character buffer from string, mode
        _Init(_Str.c_str(), _Str.size(), _Getstate(_Mode));
        }

template<class _Elem, class _Traits, class _Alloc>

basic_stringbuf< _Elem, _Traits, _Alloc >::basic_stringbuf ( _Myt &&  _Right )

inline

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

template<class _Elem, class _Traits, class _Alloc>

basic_stringbuf< _Elem, _Traits, _Alloc >::basic_stringbuf ( const _Myt &  )

delete

template<class _Elem, class _Traits, class _Alloc>

virtual basic_stringbuf< _Elem, _Traits, _Alloc >::~basic_stringbuf ( )

inlinevirtual

        {   // destroy the object
        _Tidy();
        }

Member Function Documentation

template<class _Elem, class _Traits, class _Alloc>

void basic_stringbuf< _Elem, _Traits, _Alloc >::_Assign_rv ( _Myt &&  _Right )

inline

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

template<class _Elem, class _Traits, class _Alloc>

_Strstate basic_stringbuf< _Elem, _Traits, _Alloc >::_Getstate ( ios_base::openmode  _Mode )

inlineprivate

        {   // convert open mode to stream state bits
        _Strstate _State = (_Strstate)0;
        if (!(_Mode & ios_base::in))
            _State |= _Noread;
        if (!(_Mode & ios_base::out))
            _State |= _Constant;
        if (_Mode & ios_base::app)
            _State |= _Append;
        if (_Mode & ios_base::ate)
            _State |= _Atend;
        return (_State);
        }

template<class _Elem, class _Traits, class _Alloc>

void basic_stringbuf< _Elem, _Traits, _Alloc >::_Init ( const _Elem *  _Ptr, size_t  _Count, _Strstate  _State  )

inlineprotected

        {   // initialize buffer to [_Ptr, _Ptr + _Count), set state
        _Seekhigh = 0;
        _Mystate = _State;

        if (_Count != 0
            && (_Mystate & (_Noread | _Constant)) != (_Noread | _Constant))
            {   // finite buffer that can be read or written, set it up
            _Elem *_Pnew = _Al.allocate(_Count);
            _Traits::copy(_Pnew, _Ptr, _Count);
            _Seekhigh = _Pnew + _Count;

            if (!(_Mystate & _Noread))
                _Mysb::setg(_Pnew, _Pnew,
                    _Pnew + _Count);    // setup read buffer
            if (!(_Mystate & _Constant))
                {   // setup write buffer, and maybe read buffer
                _Mysb::setp(_Pnew,
                    (_Mystate & (_Atend | _Append)) ? _Pnew + _Count : _Pnew,
                    _Pnew + _Count);
                if (_Mysb::gptr() == 0)
                    _Mysb::setg(_Pnew, 0, _Pnew);
                }
            _Mystate |= _Allocated;
            }
        }

template<class _Elem, class _Traits, class _Alloc>

void basic_stringbuf< _Elem, _Traits, _Alloc >::_Tidy ( )

inlineprotected

        {   // discard any allocated buffer and clear pointers
        if (_Mystate & _Allocated)
            _Al.deallocate(_Mysb::eback(),
                (_Mysb::pptr() != 0 ? _Mysb::epptr()
                    : _Mysb::egptr()) - _Mysb::eback());
        _Mysb::setg(0, 0, 0);
        _Mysb::setp(0, 0);
        _Seekhigh = 0;
        _Mystate &= ~_Allocated;
        }

template<class _Elem, class _Traits, class _Alloc>

_Myt& basic_stringbuf< _Elem, _Traits, _Alloc >::operator= ( _Myt &&  _Right )

inline

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

template<class _Elem, class _Traits, class _Alloc>

_Myt& basic_stringbuf< _Elem, _Traits, _Alloc >::operator= ( const _Myt &  )

delete

template<class _Elem, class _Traits, class _Alloc>

virtual int_type basic_stringbuf< _Elem, _Traits, _Alloc >::overflow ( int_type  _Meta = _Traits::eof() )

inlineprotectedvirtual

Reimplemented from basic_streambuf< _Elem, _Traits >.

        {   // put an element to stream
        if (_Mystate & _Constant)
            return (_Traits::eof());    // array nonmutable, fail
        else if (_Traits::eq_int_type(_Traits::eof(), _Meta))
            return (_Traits::not_eof(_Meta));   // EOF, return success code

        if (_Mystate & _Append
            && _Mysb::pptr() != 0 && _Mysb::pptr() < _Seekhigh)
            _Mysb::setp(_Mysb::pbase(), _Seekhigh, _Mysb::epptr());

        if (_Mysb::pptr() != 0
            && _Mysb::pptr() < _Mysb::epptr())
            {   // room in buffer, store it
            *_Mysb::_Pninc() = _Traits::to_char_type(_Meta);
            return (_Meta);
            }
        else
            {   // grow buffer and store element
            size_t _Oldsize = _Mysb::pptr() == 0
                ? 0 : _Mysb::epptr() - _Mysb::eback();
            size_t _Newsize = _Oldsize;
            size_t _Inc = _Newsize / 2 < _MINSIZE
                ? _MINSIZE : _Newsize / 2;  // grow by 50 per cent

            while (0 < _Inc && INT_MAX - _Inc < _Newsize)
                _Inc /= 2;  // increment causes overflow, halve it
            if (_Inc == 0)
                return (_Traits::eof());    // buffer can't grow, fail

            _Newsize += _Inc;

            _Elem *_Newptr = _Al.allocate(_Newsize);
            _Elem *_Oldptr = _Mysb::eback();

            if (0 < _Oldsize)
                _Traits::copy(_Newptr, _Oldptr, _Oldsize);

            if (_Oldsize == 0)
                {   // first growth, set up pointers
                _Seekhigh = _Newptr;
                _Mysb::setp(_Newptr, _Newptr + _Newsize);
                if (_Mystate & _Noread)
                    _Mysb::setg(_Newptr, 0, _Newptr);
                else
                    _Mysb::setg(_Newptr, _Newptr, _Newptr + 1);
                }
            else
                {   // not first growth, adjust pointers
                _Seekhigh = _Newptr + (_Seekhigh - _Oldptr);
                _Mysb::setp(_Newptr + (_Mysb::pbase() - _Oldptr),
                    _Newptr + (_Mysb::pptr() - _Oldptr),
                    _Newptr + _Newsize);
                if (_Mystate & _Noread)
                    _Mysb::setg(_Newptr, 0, _Newptr);
                else
                    _Mysb::setg(_Newptr,
                        _Newptr + (_Mysb::gptr() - _Oldptr),
                        _Mysb::pptr() + 1);
                }

            if (_Mystate & _Allocated)
                _Al.deallocate(_Oldptr, _Oldsize);
            _Mystate |= _Allocated;

            *_Mysb::_Pninc() = _Traits::to_char_type(_Meta);
            return (_Meta);
            }
        }

template<class _Elem, class _Traits, class _Alloc>

virtual int_type basic_stringbuf< _Elem, _Traits, _Alloc >::pbackfail ( int_type  _Meta = _Traits::eof() )

inlineprotectedvirtual

Reimplemented from basic_streambuf< _Elem, _Traits >.

        {   // put an element back to stream
        if (_Mysb::gptr() == 0
            || _Mysb::gptr() <= _Mysb::eback()
            || (!_Traits::eq_int_type(_Traits::eof(), _Meta)
            && !_Traits::eq(_Traits::to_char_type(_Meta), _Mysb::gptr()[-1])
            && _Mystate & _Constant))
            return (_Traits::eof());    // can't put back, fail
        else
            {   // back up one position and store put-back character
            _Mysb::gbump(-1);
            if (!_Traits::eq_int_type(_Traits::eof(), _Meta))
                *_Mysb::gptr() = _Traits::to_char_type(_Meta);
            return (_Traits::not_eof(_Meta));
            }
        }

template<class _Elem, class _Traits, class _Alloc>

virtual pos_type basic_stringbuf< _Elem, _Traits, _Alloc >::seekoff ( off_type  _Off, ios_base::seekdir  _Way, ios_base::openmode  _Which = ios_base::in | ios_base::out  )

inlineprotectedvirtual

Reimplemented from basic_streambuf< _Elem, _Traits >.

        {   // change position by _Off, according to _Way, _Mode
        if (_Mysb::pptr() != 0 && _Seekhigh < _Mysb::pptr())
            _Seekhigh = _Mysb::pptr();  // update high-water pointer

        if (_Which & ios_base::in && _Mysb::gptr() != 0)
            {   // position within read buffer
            if (_Way == ios_base::end)
                _Off += (off_type)(_Seekhigh - _Mysb::eback());
            else if (_Way == ios_base::cur
                && (_Which & ios_base::out) == 0)
                _Off += (off_type)(_Mysb::gptr() - _Mysb::eback());
            else if (_Way != ios_base::beg)
                _Off = _BADOFF;

            if (0 <= _Off && _Off <= _Seekhigh - _Mysb::eback())
                {   // change read position
                _Mysb::gbump((int)(_Mysb::eback() - _Mysb::gptr() + _Off));
                if (_Which & ios_base::out && _Mysb::pptr() != 0)
                    _Mysb::setp(_Mysb::pbase(), _Mysb::gptr(),
                        _Mysb::epptr());    // change write position to match
                }
            else
                _Off = _BADOFF;
            }
        else if (_Which & ios_base::out && _Mysb::pptr() != 0)
            {   // position within write buffer
            if (_Way == ios_base::end)
                _Off += (off_type)(_Seekhigh - _Mysb::eback());
            else if (_Way == ios_base::cur)
                _Off += (off_type)(_Mysb::pptr() - _Mysb::eback());
            else if (_Way != ios_base::beg)
                _Off = _BADOFF;

            if (0 <= _Off && _Off <= _Seekhigh - _Mysb::eback())
                _Mysb::pbump((int)(_Mysb::eback()
                    - _Mysb::pptr() + _Off));   // change write position
            else
                _Off = _BADOFF;
            }

        else if (_Off != 0)


            _Off = _BADOFF; // neither read nor write buffer selected, fail
        return (pos_type(_Off));
        }

template<class _Elem, class _Traits, class _Alloc>

virtual pos_type basic_stringbuf< _Elem, _Traits, _Alloc >::seekpos ( pos_type  _Ptr, ios_base::openmode  _Mode = ios_base::in | ios_base::out  )

inlineprotectedvirtual

Reimplemented from basic_streambuf< _Elem, _Traits >.

        {   // change position to _Pos, according to _Mode
        streamoff _Off = (streamoff)_Ptr;
        if (_Mysb::pptr() != 0 && _Seekhigh < _Mysb::pptr())
            _Seekhigh = _Mysb::pptr();  // update high-water pointer

        if (_Off == _BADOFF)
            ;
        else if (_Mode & ios_base::in && _Mysb::gptr() != 0)
            {   // position within read buffer
            if (0 <= _Off && _Off <= _Seekhigh - _Mysb::eback())
                {   // change read position
                _Mysb::gbump((int)(_Mysb::eback() - _Mysb::gptr() + _Off));
                if (_Mode & ios_base::out && _Mysb::pptr() != 0)
                    _Mysb::setp(_Mysb::pbase(), _Mysb::gptr(),
                        _Mysb::epptr());    // change write position to match
                }
            else
                _Off = _BADOFF;
            }
        else if (_Mode & ios_base::out && _Mysb::pptr() != 0)
            {   // position within write buffer
            if (0 <= _Off && _Off <= _Seekhigh - _Mysb::eback())
                _Mysb::pbump((int)(_Mysb::eback()
                    - _Mysb::pptr() + _Off));   // change write position
            else
                _Off = _BADOFF;
            }
        else
            _Off = _BADOFF; // neither read nor write buffer selected, fail
        return (streampos(_Off));
        }

template<class _Elem, class _Traits, class _Alloc>

_Mystr basic_stringbuf< _Elem, _Traits, _Alloc >::str ( ) const

inline

        {   // return string copy of character array
        if (!(_Mystate & _Constant) && _Mysb::pptr() != 0)
            {   // writable, make string from write buffer
            _Mystr _Str(_Mysb::pbase(), (_Seekhigh < _Mysb::pptr()
                ? _Mysb::pptr() : _Seekhigh) - _Mysb::pbase());
            return (_Str);
            }
        else if (!(_Mystate & _Noread) && _Mysb::gptr() != 0)
            {   // readable, make string from read buffer
            _Mystr _Str(_Mysb::eback(), _Mysb::egptr() - _Mysb::eback());
            return (_Str);
            }
        else
            {   // inaccessible, return empty string
            _Mystr _Nul;
            return (_Nul);
            }
        }

template<class _Elem, class _Traits, class _Alloc>

void basic_stringbuf< _Elem, _Traits, _Alloc >::str ( const _Mystr &  _Newstr )

inline

        {   // replace character array from string
        _Tidy();
        _Init(_Newstr.c_str(), _Newstr.size(), _Mystate);
        }

template<class _Elem, class _Traits, class _Alloc>

void basic_stringbuf< _Elem, _Traits, _Alloc >::swap ( _Myt &  _Right )

inline

        {   // swap with _Right
        if (this != &_Right)
            {   // different, worth swapping
            _Mysb::swap(_Right);
            _STD swap(_Seekhigh, _Right._Seekhigh);
            _STD swap(_Mystate, _Right._Mystate);
            _Swap_adl(_Al, _Right._Al);
            }
        }

template<class _Elem, class _Traits, class _Alloc>

virtual int_type basic_stringbuf< _Elem, _Traits, _Alloc >::underflow ( )

inlineprotectedvirtual

Reimplemented from basic_streambuf< _Elem, _Traits >.

        {   // get an element from stream, but don't point past it
        if (_Mysb::gptr() == 0)
            return (_Traits::eof());    // no character buffer, fail
        else if (_Mysb::gptr() < _Mysb::egptr())
            return (_Traits::to_int_type(*_Mysb::gptr()));  // return buffered
        else if (_Mystate & _Noread || _Mysb::pptr() == 0
            || (_Mysb::pptr() <= _Mysb::gptr() && _Seekhigh <= _Mysb::gptr()))
            return (_Traits::eof());    // can't read, fail
        else
            {   // extend read buffer into written area, then return buffered
            if (_Seekhigh < _Mysb::pptr())
                _Seekhigh = _Mysb::pptr();
            _Mysb::setg(_Mysb::eback(), _Mysb::gptr(), _Seekhigh);
            return (_Traits::to_int_type(*_Mysb::gptr()));
            }
        }

Member Data Documentation

template<class _Elem, class _Traits, class _Alloc>

allocator_type basic_stringbuf< _Elem, _Traits, _Alloc >::_Al

private

template<class _Elem, class _Traits, class _Alloc>

_Strstate basic_stringbuf< _Elem, _Traits, _Alloc >::_Mystate

private

template<class _Elem, class _Traits, class _Alloc>

_Elem* basic_stringbuf< _Elem, _Traits, _Alloc >::_Seekhigh

private

---

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

• VS2015/inc/iosfwd
• VS2015/inc/sstream