stdext::cvt::wstring_convert< _Codecvt, _Elem > Class Template Reference

Public Types
typedef _STD basic_string< char >	byte_string
typedef _STD basic_string< _Elem >	wide_string
typedef _Codecvt::state_type	state_type
typedef wide_string::traits_type::int_type	int_type

Public Member Functions
	wstring_convert ()
	wstring_convert (_Codecvt *_Pcvt_arg)
	wstring_convert (_Codecvt *_Pcvt_arg, state_type _State_arg)
	wstring_convert (const byte_string &_Berr_arg)
	wstring_convert (const byte_string &_Berr_arg, const wide_string &_Werr_arg)
virtual	~wstring_convert () _NOEXCEPT
size_t	converted () const
state_type	state () const
wide_string	from_bytes (char _Byte)
wide_string	from_bytes (const char *_Ptr)
wide_string	from_bytes (const byte_string &_Bstr)
wide_string	from_bytes (const char *_First, const char *_Last)
byte_string	to_bytes (_Elem _Char)
byte_string	to_bytes (const _Elem *_Wptr)
byte_string	to_bytes (const wide_string &_Wstr)
byte_string	to_bytes (const _Elem *_First, const _Elem *_Last)

Private Types
enum	{ _BUF_INC = 8, _BUF_MAX = 16 }

Private Member Functions
void	_Init (_Codecvt *_Pcvt_arg=new _Codecvt)

Private Attributes
_Codecvt *	_Pcvt
_STD locale	_Loc
byte_string	_Berr
wide_string	_Werr
state_type	_State
bool	_Has_state
bool	_Has_berr
bool	_Has_werr
size_t	_Nconv

Member Typedef Documentation

template<class _Codecvt , class _Elem = wchar_t>

typedef _STD basic_string<char> stdext::cvt::wstring_convert< _Codecvt, _Elem >::byte_string

template<class _Codecvt , class _Elem = wchar_t>

typedef wide_string::traits_type::int_type stdext::cvt::wstring_convert< _Codecvt, _Elem >::int_type

template<class _Codecvt , class _Elem = wchar_t>

typedef _Codecvt::state_type stdext::cvt::wstring_convert< _Codecvt, _Elem >::state_type

template<class _Codecvt , class _Elem = wchar_t>

typedef _STD basic_string<_Elem> stdext::cvt::wstring_convert< _Codecvt, _Elem >::wide_string

Member Enumeration Documentation

template<class _Codecvt , class _Elem = wchar_t>

anonymous enum

private

Enumerator
_BUF_INC
_BUF_MAX

{_BUF_INC = 8, _BUF_MAX = 16};

Constructor & Destructor Documentation

template<class _Codecvt , class _Elem = wchar_t>

stdext::cvt::wstring_convert< _Codecvt, _Elem >::wstring_convert ( )

inline

        : _Has_berr(false), _Has_werr(false), _Has_state(false)
        {   // construct with no error strings
        _Init();
        }

template<class _Codecvt , class _Elem = wchar_t>

stdext::cvt::wstring_convert< _Codecvt, _Elem >::wstring_convert ( _Codecvt *  _Pcvt_arg )

inline

        : _Has_berr(false), _Has_werr(false), _Has_state(false)
        {   // construct with no error strings and codecvt
        _Init(_Pcvt_arg);
        }

template<class _Codecvt , class _Elem = wchar_t>

stdext::cvt::wstring_convert< _Codecvt, _Elem >::wstring_convert ( _Codecvt *  _Pcvt_arg, state_type  _State_arg  )

inline

        : _Has_berr(false), _Has_werr(false), _Has_state(true)
        {   // construct with no error strings, codecvt, and state
        _Init(_Pcvt_arg);
        _State = _State_arg;
        }

template<class _Codecvt , class _Elem = wchar_t>

stdext::cvt::wstring_convert< _Codecvt, _Elem >::wstring_convert ( const byte_string &  _Berr_arg )

inline

        : _Has_berr(true), _Has_werr(false), _Has_state(false),
            _Berr(_Berr_arg)
        {   // construct with byte error string
        _Init();
        }

template<class _Codecvt , class _Elem = wchar_t>

stdext::cvt::wstring_convert< _Codecvt, _Elem >::wstring_convert ( const byte_string &  _Berr_arg, const wide_string &  _Werr_arg  )

inline

        : _Has_berr(true), _Has_werr(true), _Has_state(false),
            _Berr(_Berr_arg), _Werr(_Werr_arg)
        {   // construct with byte and wide error strings
        _Init();
        }

template<class _Codecvt , class _Elem = wchar_t>

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

inlinevirtual

        {   // destroy the object
        }

Member Function Documentation

template<class _Codecvt , class _Elem = wchar_t>

void stdext::cvt::wstring_convert< _Codecvt, _Elem >::_Init ( _Codecvt *  _Pcvt_arg = new _Codecvt )

inlineprivate

        {   // initialize the object
        _Pcvt = _Pcvt_arg;
        _Loc = _STD _ADDFAC(_Loc, _Pcvt);
        _Nconv = 0;
        }

template<class _Codecvt , class _Elem = wchar_t>

size_t stdext::cvt::wstring_convert< _Codecvt, _Elem >::converted ( ) const

inline

        {   // get conversion count
        return (_Nconv);
        }

template<class _Codecvt , class _Elem = wchar_t>

wide_string stdext::cvt::wstring_convert< _Codecvt, _Elem >::from_bytes ( char  _Byte )

inline

        {   // convert a byte to a wide string
        return (from_bytes(&_Byte, &_Byte + 1));
        }

template<class _Codecvt , class _Elem = wchar_t>

wide_string stdext::cvt::wstring_convert< _Codecvt, _Elem >::from_bytes ( const char *  _Ptr )

inline

        {   // convert a NTBS to a wide string
        return (from_bytes(_Ptr, _Ptr + strlen(_Ptr)));
        }

template<class _Codecvt , class _Elem = wchar_t>

wide_string stdext::cvt::wstring_convert< _Codecvt, _Elem >::from_bytes ( const byte_string &  _Bstr )

inline

        {   // convert a byte string to a wide string
        const char *_Ptr = _Bstr.c_str();
        return (from_bytes(_Ptr, _Ptr + _Bstr.size()));
        }

template<class _Codecvt , class _Elem = wchar_t>

wide_string stdext::cvt::wstring_convert< _Codecvt, _Elem >::from_bytes ( const char *  _First, const char *  _Last  )

inline

        {   // convert byte sequence [_First, _Last) to a wide string
        static state_type _State0;
        wide_string _Wbuf, _Wstr;
        const char *_First_sav = _First;

        if (!_Has_state)
            _State = _State0;   // reset state if not remembered
        _Wbuf.append((_CSTD size_t)_BUF_INC, (_Elem)'\0');
        for (_Nconv = 0; _First != _Last; _Nconv = _First - _First_sav)
            {   // convert one or more bytes
            _Elem *_Dest = &*_Wbuf.begin();
            _Elem *_Dnext;

            switch (_Pcvt->in(_State,
                _First, _Last, _First,
                _Dest, _Dest + _Wbuf.size(), _Dnext))
                {   // test result of converting one or more bytes
            case _Codecvt::partial:
            case _Codecvt::ok:
                if (_Dest < _Dnext)
                    _Wstr.append(_Dest, (_CSTD size_t)(_Dnext - _Dest));
                else if (_Wbuf.size() < _BUF_MAX)
                    _Wbuf.append((_CSTD size_t)_BUF_INC, '\0');
                else if (_Has_werr)
                    return (_Werr);
                else
                    _THROW(_STD range_error, "bad conversion");
                break;

            case _Codecvt::noconv:
                for (; _First != _Last; ++_First)
                    _Wstr.append((_CSTD size_t)1,
                        (_Elem)(unsigned char)*_First);
                break;  // no conversion, just copy code values

            default:
                if (_Has_werr)
                    return (_Werr);
                else
                    _THROW(_STD range_error, "bad conversion");
                }
            }
        return (_Wstr);
        }

template<class _Codecvt , class _Elem = wchar_t>

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

inline

        {   // get state
        return (_State);
        }

template<class _Codecvt , class _Elem = wchar_t>

byte_string stdext::cvt::wstring_convert< _Codecvt, _Elem >::to_bytes ( _Elem  _Char )

inline

        {   // convert a wide char to a byte string
        return (to_bytes(&_Char, &_Char + 1));
        }

template<class _Codecvt , class _Elem = wchar_t>

byte_string stdext::cvt::wstring_convert< _Codecvt, _Elem >::to_bytes ( const _Elem *  _Wptr )

inline

        {   // convert a NTWCS to a byte string
        const _Elem *_Next = _Wptr;
        for (; (int_type)*_Next != 0; ++_Next)
            ;
        return (to_bytes(_Wptr, _Next));
        }

template<class _Codecvt , class _Elem = wchar_t>

byte_string stdext::cvt::wstring_convert< _Codecvt, _Elem >::to_bytes ( const wide_string &  _Wstr )

inline

        {   // convert a wide string to a byte string
        const _Elem *_Wptr = _Wstr.c_str();
        return (to_bytes(_Wptr, _Wptr + _Wstr.size()));
        }

template<class _Codecvt , class _Elem = wchar_t>

byte_string stdext::cvt::wstring_convert< _Codecvt, _Elem >::to_bytes ( const _Elem *  _First, const _Elem *  _Last  )

inline

        {   // convert wide sequence [_First, _Last) to a byte string
        static state_type _State0;
        byte_string _Bbuf, _Bstr;
        const _Elem *_First_sav = _First;

        if (!_Has_state)
            _State = _State0;   // reset state if not remembered
        _Bbuf.append((_CSTD size_t)_BUF_INC, '\0');
        for (_Nconv = 0; _First != _Last; _Nconv = _First - _First_sav)
            {   // convert one or more wide chars
            char *_Dest = &*_Bbuf.begin();
            char *_Dnext;

            switch (_Pcvt->out(_State,
                _First, _Last, _First,
                _Dest, _Dest + _Bbuf.size(), _Dnext))
                {   // test result of converting one or more wide chars
            case _Codecvt::partial:
            case _Codecvt::ok:
                if (_Dest < _Dnext)
                    _Bstr.append(_Dest, (_CSTD size_t)(_Dnext - _Dest));
                else if (_Bbuf.size() < _BUF_MAX)
                    _Bbuf.append((_CSTD size_t)_BUF_INC, '\0');
                else if (_Has_berr)
                    return (_Berr);
                else
                    _THROW(_STD range_error, "bad conversion");
                break;

            case _Codecvt::noconv:
                for (; _First != _Last; ++_First)
                    _Bstr.append((_CSTD size_t)1,
                        (char)(int_type)*_First);
                break;  // no conversion, just copy code values

            default:
                if (_Has_berr)
                    return (_Berr);
                else
                    _THROW(_STD range_error, "bad conversion");
                }
            }
        return (_Bstr);
        }

Member Data Documentation

template<class _Codecvt , class _Elem = wchar_t>

byte_string stdext::cvt::wstring_convert< _Codecvt, _Elem >::_Berr

private

template<class _Codecvt , class _Elem = wchar_t>

bool stdext::cvt::wstring_convert< _Codecvt, _Elem >::_Has_berr

private

template<class _Codecvt , class _Elem = wchar_t>

bool stdext::cvt::wstring_convert< _Codecvt, _Elem >::_Has_state

private

template<class _Codecvt , class _Elem = wchar_t>

bool stdext::cvt::wstring_convert< _Codecvt, _Elem >::_Has_werr

private

template<class _Codecvt , class _Elem = wchar_t>

_STD locale stdext::cvt::wstring_convert< _Codecvt, _Elem >::_Loc

private

template<class _Codecvt , class _Elem = wchar_t>

size_t stdext::cvt::wstring_convert< _Codecvt, _Elem >::_Nconv

private

template<class _Codecvt , class _Elem = wchar_t>

_Codecvt* stdext::cvt::wstring_convert< _Codecvt, _Elem >::_Pcvt

private

template<class _Codecvt , class _Elem = wchar_t>

state_type stdext::cvt::wstring_convert< _Codecvt, _Elem >::_State

private

template<class _Codecvt , class _Elem = wchar_t>

wide_string stdext::cvt::wstring_convert< _Codecvt, _Elem >::_Werr

private

---

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

• VS2013/inc/cvt/wstring