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

	wstring_convert (const wstring_convert &)=delete

wstring_convert &	operator= (const wstring_convert &)=delete

size_t	converted () const _NOEXCEPT

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

24 {_BUF_INC = 8, _BUF_MAX = 16};

stdext::cvt::wstring_convert::_BUF_MAX

Definition: wstring:24

stdext::cvt::wstring_convert::_BUF_INC

Definition: wstring:24

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 )

inlineexplicit

         : _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 )

inlineexplicit

         : _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

74 { // destroy the object

75 }

template<class _Codecvt , class _Elem = wchar_t>

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

delete

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 + _CSTD 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>

wstring_convert& stdext::cvt::wstring_convert< _Codecvt, _Elem >::operator= ( const wstring_convert< _Codecvt, _Elem > & )

delete

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);
         }