stdext::cvt::wbuffer_convert< _Codecvt, _Elem, _Traits > Class Template Reference

Inheritance diagram for stdext::cvt::wbuffer_convert< _Codecvt, _Elem, _Traits >:

Public Types
typedef wbuffer_convert< _Codecvt, _Elem, _Traits >	_Myt
typedef _STD streambuf	_Mysb
typedef _STD char_traits< char >	_Byte_traits
typedef _Traits::int_type	int_type
typedef _Traits::pos_type	pos_type
typedef _Traits::off_type	off_type
typedef _Traits::state_type	state_type

Public Member Functions
	wbuffer_convert (_Mysb *_Strbuf=0)
	wbuffer_convert (_Mysb *_Strbuf, _Codecvt *_Pcvt_arg)
	wbuffer_convert (_Mysb *_Strbuf, _Codecvt *_Pcvt_arg, state_type _State_arg)
virtual	~wbuffer_convert () _NOEXCEPT
_Mysb *	rdbuf () const
_Mysb *	rdbuf (_Mysb *_Strbuf)
state_type	state () const
	wbuffer_convert (const _Myt &)=delete
_Myt &	operator= (const _Myt &)=delete

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 int_type	uflow ()
virtual pos_type	seekoff (off_type, _STD ios::seekdir, _STD ios::openmode=(_STD ios::openmode)(_STD ios::in|_STD ios::out))
virtual pos_type	seekpos (pos_type, _STD ios::openmode=(_STD ios::openmode)(_STD ios::in|_STD ios::out))

Private Types
enum	_Mode {   _Unused, _Wrote, _Need, _Got,   _Eof }
enum	{ _STRING_INC = 8 }

Private Member Functions
int_type	_Get_elem ()

Private Attributes
state_type	_State
_Codecvt *	_Pcvt
_Mysb *	_Mystrbuf
_Mode	_Status
size_t	_Nback
_Elem	_Myback [8]
_STD string	_Str
_STD locale	_Loc

Member Typedef Documentation

template<class _Codecvt, class _Elem = wchar_t, class _Traits = _STD char_traits<_Elem>>

typedef _STD char_traits<char> stdext::cvt::wbuffer_convert< _Codecvt, _Elem, _Traits >::_Byte_traits

template<class _Codecvt, class _Elem = wchar_t, class _Traits = _STD char_traits<_Elem>>

typedef _STD streambuf stdext::cvt::wbuffer_convert< _Codecvt, _Elem, _Traits >::_Mysb

template<class _Codecvt, class _Elem = wchar_t, class _Traits = _STD char_traits<_Elem>>

typedef wbuffer_convert<_Codecvt, _Elem, _Traits> stdext::cvt::wbuffer_convert< _Codecvt, _Elem, _Traits >::_Myt

template<class _Codecvt, class _Elem = wchar_t, class _Traits = _STD char_traits<_Elem>>

typedef _Traits::int_type stdext::cvt::wbuffer_convert< _Codecvt, _Elem, _Traits >::int_type

template<class _Codecvt, class _Elem = wchar_t, class _Traits = _STD char_traits<_Elem>>

typedef _Traits::off_type stdext::cvt::wbuffer_convert< _Codecvt, _Elem, _Traits >::off_type

template<class _Codecvt, class _Elem = wchar_t, class _Traits = _STD char_traits<_Elem>>

typedef _Traits::pos_type stdext::cvt::wbuffer_convert< _Codecvt, _Elem, _Traits >::pos_type

template<class _Codecvt, class _Elem = wchar_t, class _Traits = _STD char_traits<_Elem>>

typedef _Traits::state_type stdext::cvt::wbuffer_convert< _Codecvt, _Elem, _Traits >::state_type

Member Enumeration Documentation

template<class _Codecvt, class _Elem = wchar_t, class _Traits = _STD char_traits<_Elem>>

anonymous enum

private

Enumerator
_STRING_INC

{_STRING_INC = 8};

template<class _Codecvt, class _Elem = wchar_t, class _Traits = _STD char_traits<_Elem>>

enum stdext::cvt::wbuffer_convert::_Mode

private

Enumerator
_Unused
_Wrote
_Need
_Got
_Eof

{_Unused, _Wrote, _Need, _Got, _Eof};

Constructor & Destructor Documentation

template<class _Codecvt, class _Elem = wchar_t, class _Traits = _STD char_traits<_Elem>>

stdext::cvt::wbuffer_convert< _Codecvt, _Elem, _Traits >::wbuffer_convert ( _Mysb *  _Strbuf = 0 )

inlineexplicit

        : _Pcvt(new _Codecvt),
            _Mystrbuf(_Strbuf), _Status(_Unused), _Nback(0)
        {   // construct with byte stream buffer pointer
        static state_type _State0;

        _State = _State0;
        _Loc = _STD _ADDFAC(_Loc, _Pcvt);
        }

template<class _Codecvt, class _Elem = wchar_t, class _Traits = _STD char_traits<_Elem>>

stdext::cvt::wbuffer_convert< _Codecvt, _Elem, _Traits >::wbuffer_convert ( _Mysb *  _Strbuf, _Codecvt *  _Pcvt_arg  )

inline

        : _Pcvt(_Pcvt_arg),
            _Mystrbuf(_Strbuf), _Status(_Unused), _Nback(0)
        {   // construct with byte stream buffer pointer and codecvt
        static state_type _State0;

        _State = _State0;
        _Loc = _STD _ADDFAC(_Loc, _Pcvt);
        }

template<class _Codecvt, class _Elem = wchar_t, class _Traits = _STD char_traits<_Elem>>

stdext::cvt::wbuffer_convert< _Codecvt, _Elem, _Traits >::wbuffer_convert ( _Mysb *  _Strbuf, _Codecvt *  _Pcvt_arg, state_type  _State_arg  )

inline

        : _Pcvt(_Pcvt_arg),
            _Mystrbuf(_Strbuf), _Status(_Unused), _Nback(0)
        {   // construct with byte stream buffer pointer, codecvt, and state
        _State = _State_arg;
        _Loc = _STD _ADDFAC(_Loc, _Pcvt);
        }

template<class _Codecvt, class _Elem = wchar_t, class _Traits = _STD char_traits<_Elem>>

virtual stdext::cvt::wbuffer_convert< _Codecvt, _Elem, _Traits >::~wbuffer_convert ( )

inlinevirtual

        {   // destroy the object
        char *_Buf = (char *)_Str.c_str();

        for (; _Status == _Wrote ; )
            {   // put any trailing homing shift
            char *_Dest;

            if (_Str.size() < _STRING_INC)
                _Str.assign(_STRING_INC, '\0');
            switch (_Pcvt->unshift(_State,
                _Buf, _Buf + _Str.size(), _Dest))
                {   // test result of homing conversion
            case _Codecvt::ok:
                _Status = _Unused;  // homed successfully

            case _Codecvt::partial: // fall through
                {   // put any generated bytes
                size_t _Count = _Dest - _Buf;
                if (0 < _Count
                    && _Byte_traits::eq_int_type(
                        _Byte_traits::eof(),
                        (typename _Traits::int_type)_Mystrbuf->sputn(
                            _Buf,
                            (_STD streamsize)_Count)))
                    return; // write failed

                if (_Status == _Wrote && _Count == 0)
                    _Str.append(_STRING_INC, '\0'); // try with more space
                break;
                }

            case _Codecvt::noconv:
                return; // nothing to do

            default:
                return; // conversion failed
                }
            }

        }

template<class _Codecvt, class _Elem = wchar_t, class _Traits = _STD char_traits<_Elem>>

stdext::cvt::wbuffer_convert< _Codecvt, _Elem, _Traits >::wbuffer_convert ( const _Myt &  )

delete

Member Function Documentation

template<class _Codecvt, class _Elem = wchar_t, class _Traits = _STD char_traits<_Elem>>

int_type stdext::cvt::wbuffer_convert< _Codecvt, _Elem, _Traits >::_Get_elem ( )

inlineprivate

        {   // compose an element from byte stream buffer
        if (_Mystrbuf != 0 && _Status != _Wrote)
            {   // got buffer, haven't written, try to compose an element
            if (_Status == _Eof)
                ;
            else if (_Str.size() == 0)
                _Status = _Need;
            else
                _Status = _Got;

            for (; _Status != _Eof; )
                {   // get using codecvt facet
                char *_Buf = (char *)_Str.c_str();
                _Elem _Ch, *_Dest;
                const char *_Src;
                int _Meta;

                if (_Status != _Need)
                    ;
                else if (_Byte_traits::eq_int_type(_Byte_traits::eof(),
                    _Meta = _Mystrbuf->sbumpc()))
                    _Status = _Eof;
                else
                    _Str.append(1, _Byte_traits::to_char_type(_Meta));

                switch (_Pcvt->in(_State,
                    _Buf, _Buf + _Str.size(), _Src,
                    &_Ch, &_Ch + 1, _Dest))
                    {   // test result of converting one element
                case _Codecvt::partial:
                case _Codecvt::ok:
                    _Str.erase((size_t)0,   // discard any used input
                        (size_t)(_Src - _Buf));
                    if (_Dest != &_Ch)
                        return (_Traits::to_int_type(_Ch));
                    break;

                case _Codecvt::noconv:
                    if (_Str.size() < sizeof (_Elem))
                        break;  // no conversion, but need more chars
                    _CSTD memcpy(&_Ch, _Buf,
                        sizeof (_Elem));    // copy raw bytes to element
                    _Str.erase((size_t)0, sizeof (_Elem));
                    return (_Traits::to_int_type(_Ch)); // return result

                default:
                    _Status = _Eof; // conversion failed
                    }
                }
            }

        return (_Traits::eof());
        }

template<class _Codecvt, class _Elem = wchar_t, class _Traits = _STD char_traits<_Elem>>

_Myt& stdext::cvt::wbuffer_convert< _Codecvt, _Elem, _Traits >::operator= ( const _Myt &  )

delete

template<class _Codecvt, class _Elem = wchar_t, class _Traits = _STD char_traits<_Elem>>

virtual int_type stdext::cvt::wbuffer_convert< _Codecvt, _Elem, _Traits >::overflow ( int_type  _Meta = _Traits::eof() )

inlineprotectedvirtual

        {   // put an element to stream
        if (_Traits::eq_int_type(_Traits::eof(), _Meta))
            return (_Traits::not_eof(_Meta));   // EOF, return success code
        else if (_Mystrbuf == 0 || 0 < _Nback
            || (_Status != _Unused && _Status != _Wrote))
            return (_Traits::eof());    // no buffer or reading, fail
        else
            {   // put using codecvt facet
            char *_Buf = (char *)_Str.c_str();
            const _Elem _Ch = _Traits::to_char_type(_Meta);
            const _Elem *_Src;
            char *_Dest;

            if (_Str.size() < _STRING_INC)
                _Str.assign(_STRING_INC, '\0');
            for (_Status = _Wrote; ; )
                switch (_Pcvt->out(_State,
                    &_Ch, &_Ch + 1, _Src,
                    _Buf, _Buf + _Str.size(), _Dest))
                {   // test result of converting one element
                case _Codecvt::partial:
                case _Codecvt::ok:
                    {   // converted something, try to put it out
                    size_t _Count = _Dest - _Buf;
                    if (0 < _Count
                        && _Byte_traits::eq_int_type(
                            _Byte_traits::eof(),
                            (typename _Traits::int_type)_Mystrbuf->sputn(
                                _Buf,
                                (_STD streamsize)_Count)))
                        return (_Traits::eof());    // write failed

                    if (_Src != &_Ch)
                        return (_Meta); // converted whole element

                    if (0 < _Count)
                        ;
                    else if (_Str.size() < 4 * _STRING_INC)
                        _Str.append(_STRING_INC, '\0'); // try with more space
                    else
                        return (_Traits::eof());    // conversion failed
                    break;
                    }

                case _Codecvt::noconv:
                    if (_Traits::eq_int_type(
                        _Traits::eof(),
                        (typename _Traits::int_type)_Mystrbuf->sputn(
                            (char *)&_Ch,
                            (_STD streamsize)sizeof (_Elem))))
                        return (_Traits::eof());
                    else
                        return (_Meta); // put native byte order

                default:
                    return (_Traits::eof());    // conversion failed
                }
            }
        }

template<class _Codecvt, class _Elem = wchar_t, class _Traits = _STD char_traits<_Elem>>

virtual int_type stdext::cvt::wbuffer_convert< _Codecvt, _Elem, _Traits >::pbackfail ( int_type  _Meta = _Traits::eof() )

inlineprotectedvirtual

        {   // put an element back to stream
        if (sizeof (_Myback) / sizeof (_Myback[0]) <= _Nback
            || _Status == _Wrote)
            return (_Traits::eof());    // nowhere to put back
        else
            {   // enough room, put it back
             if (!_Traits::eq_int_type(_Traits::eof(), _Meta))
                _Myback[_Nback] = _Traits::to_char_type(_Meta);
            ++_Nback;
            if (_Status == _Unused)
                _Status = _Got;
            return (_Meta);
            }
        }

template<class _Codecvt, class _Elem = wchar_t, class _Traits = _STD char_traits<_Elem>>

_Mysb* stdext::cvt::wbuffer_convert< _Codecvt, _Elem, _Traits >::rdbuf ( ) const

inline

        {   // return byte stream buffer pointer
        return (_Mystrbuf);
        }

template<class _Codecvt, class _Elem = wchar_t, class _Traits = _STD char_traits<_Elem>>

_Mysb* stdext::cvt::wbuffer_convert< _Codecvt, _Elem, _Traits >::rdbuf ( _Mysb *  _Strbuf )

inline

        {   // set byte stream buffer pointer
        _Mysb *_Oldstrbuf = _Mystrbuf;
        _Mystrbuf = _Strbuf;
        return (_Oldstrbuf);
        }

template<class _Codecvt, class _Elem = wchar_t, class _Traits = _STD char_traits<_Elem>>

virtual pos_type stdext::cvt::wbuffer_convert< _Codecvt, _Elem, _Traits >::seekoff ( off_type  , _STD ios::seekdir  , _STD ios::openmode  = (_STD ios::openmode)(_STD ios::in | _STD ios::out)  )

inlineprotectedvirtual

        {   // change position by _Off
        return (pos_type(-1));  // always fail
        }

template<class _Codecvt, class _Elem = wchar_t, class _Traits = _STD char_traits<_Elem>>

virtual pos_type stdext::cvt::wbuffer_convert< _Codecvt, _Elem, _Traits >::seekpos ( pos_type  , _STD ios::openmode  = (_STD ios::openmode)(_STD ios::in | _STD ios::out)  )

inlineprotectedvirtual

        {   // change position to _Pos
        return (pos_type(-1));  // always fail
        }

template<class _Codecvt, class _Elem = wchar_t, class _Traits = _STD char_traits<_Elem>>

state_type stdext::cvt::wbuffer_convert< _Codecvt, _Elem, _Traits >::state ( ) const

inline

        {   // get state
        return (_State);
        }

template<class _Codecvt, class _Elem = wchar_t, class _Traits = _STD char_traits<_Elem>>

virtual int_type stdext::cvt::wbuffer_convert< _Codecvt, _Elem, _Traits >::uflow ( )

inlineprotectedvirtual

        {   // get an element from stream, point past it
        int_type _Meta;

        if (0 < _Nback)
            ;
        else if (_Traits::eq_int_type(_Traits::eof(), _Meta = _Get_elem()))
            return (_Meta); // _Get_elem failed, return EOF
        else
            _Myback[_Nback++] = _Traits::to_char_type(_Meta);
        return (_Traits::to_int_type(_Myback[--_Nback]));
        }

template<class _Codecvt, class _Elem = wchar_t, class _Traits = _STD char_traits<_Elem>>

virtual int_type stdext::cvt::wbuffer_convert< _Codecvt, _Elem, _Traits >::underflow ( )

inlineprotectedvirtual

        {   // get an element from stream, but don't point past it
        int_type _Meta;

        if (0 < _Nback)
            ;
        else if (_Traits::eq_int_type(_Traits::eof(), _Meta = _Get_elem()))
            return (_Meta); // _Get_elem failed, return EOF
        else
            _Myback[_Nback++] = _Traits::to_char_type(_Meta);
        return (_Traits::to_int_type(_Myback[_Nback - 1]));
        }

Member Data Documentation

template<class _Codecvt, class _Elem = wchar_t, class _Traits = _STD char_traits<_Elem>>

_STD locale stdext::cvt::wbuffer_convert< _Codecvt, _Elem, _Traits >::_Loc

private

template<class _Codecvt, class _Elem = wchar_t, class _Traits = _STD char_traits<_Elem>>

_Elem stdext::cvt::wbuffer_convert< _Codecvt, _Elem, _Traits >::_Myback[8]

private

template<class _Codecvt, class _Elem = wchar_t, class _Traits = _STD char_traits<_Elem>>

_Mysb* stdext::cvt::wbuffer_convert< _Codecvt, _Elem, _Traits >::_Mystrbuf

private

template<class _Codecvt, class _Elem = wchar_t, class _Traits = _STD char_traits<_Elem>>

size_t stdext::cvt::wbuffer_convert< _Codecvt, _Elem, _Traits >::_Nback

private

template<class _Codecvt, class _Elem = wchar_t, class _Traits = _STD char_traits<_Elem>>

_Codecvt* stdext::cvt::wbuffer_convert< _Codecvt, _Elem, _Traits >::_Pcvt

private

template<class _Codecvt, class _Elem = wchar_t, class _Traits = _STD char_traits<_Elem>>

state_type stdext::cvt::wbuffer_convert< _Codecvt, _Elem, _Traits >::_State

private

template<class _Codecvt, class _Elem = wchar_t, class _Traits = _STD char_traits<_Elem>>

_Mode stdext::cvt::wbuffer_convert< _Codecvt, _Elem, _Traits >::_Status

private

template<class _Codecvt, class _Elem = wchar_t, class _Traits = _STD char_traits<_Elem>>

_STD string stdext::cvt::wbuffer_convert< _Codecvt, _Elem, _Traits >::_Str

private

---

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

• VS2015/inc/cvt/wbuffer