wbuffer_convert< _Codecvt, _Elem, _Traits > Class Template Reference

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

Public Types
typedef wbuffer_convert< _Codecvt, _Elem, _Traits >	_Myt
typedef streambuf	_Mysb
typedef char_traits< char >	_Byte_traits
typedef _Traits::int_type	int_type
typedef _Traits::pos_type	pos_type
typedef _Traits::off_type	off_type
typedef _Codecvt::state_type	state_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
	wbuffer_convert (_Mysb *_Strbuf=0)
	wbuffer_convert (_Mysb *_Strbuf, const _Codecvt *_Pcvt_arg)
	wbuffer_convert (_Mysb *_Strbuf, const _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 wbuffer_convert &)=delete
wbuffer_convert &	operator= (const wbuffer_convert &)=delete
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	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
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, ios::seekdir, ios::openmode=(ios::openmode)(ios::in|ios::out))
virtual pos_type	seekpos (pos_type, ios::openmode=(ios::openmode)(ios::in|ios::out))
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 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	_Mode {   _Unused, _Wrote, _Need, _Got,   _Eof }
enum	{ _STRING_INC = 8 }

Private Member Functions
int_type	_Get_elem ()

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

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

Member Typedef Documentation

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

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

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

typedef streambuf wbuffer_convert< _Codecvt, _Elem, _Traits >::_Mysb

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

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

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

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

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

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

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

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

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

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

Member Enumeration Documentation

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

anonymous enum

private

Enumerator
_STRING_INC

{_STRING_INC = 8};

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

enum 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 = char_traits<_Elem>>

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

inline

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

        _State = _State0;
        _Loc = locale(_Loc, _Pcvt);
        }

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

wbuffer_convert< _Codecvt, _Elem, _Traits >::wbuffer_convert ( _Mysb *  _Strbuf, const _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 = locale(_Loc, _Pcvt);
        }

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

wbuffer_convert< _Codecvt, _Elem, _Traits >::wbuffer_convert ( _Mysb *  _Strbuf, const _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 = locale(_Loc, _Pcvt);
        }

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

virtual 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
                int _Count = (int)(_Dest - _Buf);
                if (0 < _Count
                    && _Byte_traits::eq_int_type(
                        _Byte_traits::eof(),
                        (_Byte_traits::int_type)_Mystrbuf->sputn(_Buf,
                        _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 = char_traits<_Elem>>

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

delete

Member Function Documentation

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

int_type 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 = char_traits<_Elem>>

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

delete

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

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

inlineprotectedvirtual

Reimplemented from basic_streambuf< _Elem, _Traits >.

        {   // 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
                    int _Count = (int)(_Dest - _Buf);
                    if (0 < _Count
                        && _Byte_traits::eq_int_type(
                            _Byte_traits::eof(),
                            (_Byte_traits::int_type)_Mystrbuf->sputn(_Buf,
                            _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,
                            (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 = char_traits<_Elem>>

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

inlineprotectedvirtual

Reimplemented from basic_streambuf< _Elem, _Traits >.

        {   // 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 = char_traits<_Elem>>

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

inline

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

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

_Mysb* 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 = char_traits<_Elem>>

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

inlineprotectedvirtual

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

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

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

inlineprotectedvirtual

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

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

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

inline

        {   // get state
        return (_State);
        }

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

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

inlineprotectedvirtual

Reimplemented from basic_streambuf< _Elem, _Traits >.

        {   // 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 = char_traits<_Elem>>

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

inlineprotectedvirtual

Reimplemented from basic_streambuf< _Elem, _Traits >.

        {   // 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 = char_traits<_Elem>>

locale wbuffer_convert< _Codecvt, _Elem, _Traits >::_Loc

private

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

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

private

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

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

private

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

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

private

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

const _Codecvt* wbuffer_convert< _Codecvt, _Elem, _Traits >::_Pcvt

private

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

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

private

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

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

private

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

string wbuffer_convert< _Codecvt, _Elem, _Traits >::_Str

private

---

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

• VS2013/inc/xlocbuf