codecvt_utf16< _Elem, _Mymax, _Mymode > Class Template Reference

Inheritance diagram for codecvt_utf16< _Elem, _Mymax, _Mymode >:

Public Types
typedef codecvt< _Elem, char, _Statype >	_Mybase
typedef _Mybase::result	result
typedef char	_Byte
typedef _Elem	intern_type
typedef _Byte	extern_type
typedef _Statype	state_type
Public Types inherited from codecvt< _Elem, char, _Statype >
typedef _Elem	intern_type
typedef char	extern_type
typedef _Statype	state_type
Public Types inherited from codecvt_base
enum	{ ok, partial, error, noconv }
typedef int	result

Public Member Functions
	codecvt_utf16 (size_t _Refs=0)
virtual	~codecvt_utf16 () _NOEXCEPT
Public Member Functions inherited from codecvt< _Elem, char, _Statype >
result __CLR_OR_THIS_CALL	in (_Statype &_State, const char *_First1, const char *_Last1, const char *&_Mid1, _Elem *_First2, _Elem *_Last2, _Elem *&_Mid2) const
result __CLR_OR_THIS_CALL	out (_Statype &_State, const _Elem *_First1, const _Elem *_Last1, const _Elem *&_Mid1, char *_First2, char *_Last2, char *&_Mid2) const
result __CLR_OR_THIS_CALL	unshift (_Statype &_State, char *_First2, char *_Last2, char *&_Mid2) const
int __CLR_OR_THIS_CALL	length (_Statype &_State, const char *_First1, const char *_Last1, size_t _Count) const
__CLR_OR_THIS_CALL	codecvt (size_t _Refs=0)
__CLR_OR_THIS_CALL	codecvt (const _Locinfo &_Lobj, size_t _Refs=0)
Public Member Functions inherited from codecvt_base
__CLR_OR_THIS_CALL	codecvt_base (size_t _Refs=0)
bool __CLR_OR_THIS_CALL	always_noconv () const _THROW0()
int __CLR_OR_THIS_CALL	max_length () const _THROW0()
int __CLR_OR_THIS_CALL	encoding () const _THROW0()
__CLR_OR_THIS_CALL	~codecvt_base () _NOEXCEPT
Public Member Functions inherited from locale::facet
virtual void __CLR_OR_THIS_CALL	_Incref ()
virtual _Facet_base *__CLR_OR_THIS_CALL	_Decref ()
__CLR_OR_THIS_CALL	facet (const facet &)=delete
facet &__CLR_OR_THIS_CALL	operator= (const facet &)=delete
Public Member Functions inherited from _Facet_base
virtual __CLR_OR_THIS_CALL	~_Facet_base () _NOEXCEPT

Protected Member Functions
virtual result	do_in (_Statype &_State, const _Byte *_First1, const _Byte *_Last1, const _Byte *&_Mid1, _Elem *_First2, _Elem *_Last2, _Elem *&_Mid2) const
virtual result	do_out (_Statype &_State, const _Elem *_First1, const _Elem *_Last1, const _Elem *&_Mid1, _Byte *_First2, _Byte *_Last2, _Byte *&_Mid2) const
virtual result	do_unshift (_Statype &, _Byte *_First2, _Byte *, _Byte *&_Mid2) const
virtual int	do_length (_Statype &_State, const _Byte *_First1, const _Byte *_Last1, size_t _Count) const _THROW0()
virtual bool	do_always_noconv () const _THROW0()
virtual int	do_max_length () const _THROW0()
virtual int	do_encoding () const _THROW0()
Protected Member Functions inherited from codecvt< _Elem, char, _Statype >
virtual __CLR_OR_THIS_CALL	~codecvt () _NOEXCEPT
void __CLR_OR_THIS_CALL	_Init (const _Locinfo &)
Protected Member Functions inherited from locale::facet
__CLR_OR_THIS_CALL	facet (size_t _Initrefs=0)
virtual __CLR_OR_THIS_CALL	~facet () _NOEXCEPT

Private Types
enum	{ _Bytes_per_word = 2 }

Additional Inherited Members
Static Public Member Functions inherited from codecvt< _Elem, char, _Statype >
static size_t __CLRCALL_OR_CDECL	_Getcat (const locale::facet **_Ppf=0, const locale *_Ploc=0)
Static Public Member Functions inherited from locale::facet
static size_t __CLRCALL_OR_CDECL	_Getcat (const facet **=0, const locale *=0)
Static Public Attributes inherited from codecvt< _Elem, char, _Statype >
static __PURE_APPDOMAIN_GLOBAL locale::id	id

Member Typedef Documentation

template<class _Elem , unsigned long _Mymax = 0x10ffff, codecvt_mode _Mymode = (codecvt_mode)0>

typedef char codecvt_utf16< _Elem, _Mymax, _Mymode >::_Byte

template<class _Elem , unsigned long _Mymax = 0x10ffff, codecvt_mode _Mymode = (codecvt_mode)0>

typedef codecvt<_Elem, char, _Statype> codecvt_utf16< _Elem, _Mymax, _Mymode >::_Mybase

template<class _Elem , unsigned long _Mymax = 0x10ffff, codecvt_mode _Mymode = (codecvt_mode)0>

typedef _Byte codecvt_utf16< _Elem, _Mymax, _Mymode >::extern_type

template<class _Elem , unsigned long _Mymax = 0x10ffff, codecvt_mode _Mymode = (codecvt_mode)0>

typedef _Elem codecvt_utf16< _Elem, _Mymax, _Mymode >::intern_type

template<class _Elem , unsigned long _Mymax = 0x10ffff, codecvt_mode _Mymode = (codecvt_mode)0>

typedef _Mybase::result codecvt_utf16< _Elem, _Mymax, _Mymode >::result

template<class _Elem , unsigned long _Mymax = 0x10ffff, codecvt_mode _Mymode = (codecvt_mode)0>

typedef _Statype codecvt_utf16< _Elem, _Mymax, _Mymode >::state_type

Member Enumeration Documentation

template<class _Elem , unsigned long _Mymax = 0x10ffff, codecvt_mode _Mymode = (codecvt_mode)0>

anonymous enum

private

Enumerator
_Bytes_per_word

{_Bytes_per_word = 2};

Constructor & Destructor Documentation

template<class _Elem , unsigned long _Mymax = 0x10ffff, codecvt_mode _Mymode = (codecvt_mode)0>

codecvt_utf16< _Elem, _Mymax, _Mymode >::codecvt_utf16 ( size_t  _Refs = 0 )

inlineexplicit

        : _Mybase(_Refs)
        {   // construct with ref count
        }

template<class _Elem , unsigned long _Mymax = 0x10ffff, codecvt_mode _Mymode = (codecvt_mode)0>

virtual codecvt_utf16< _Elem, _Mymax, _Mymode >::~codecvt_utf16 ( )

inlinevirtual

        {   // destroy the object
        }

Member Function Documentation

template<class _Elem , unsigned long _Mymax = 0x10ffff, codecvt_mode _Mymode = (codecvt_mode)0>

virtual bool codecvt_utf16< _Elem, _Mymax, _Mymode >::do_always_noconv ( ) const

inlineprotectedvirtual

Reimplemented from codecvt< _Elem, char, _Statype >.

        {   // return true if conversions never change input
        return (false);
        }

template<class _Elem , unsigned long _Mymax = 0x10ffff, codecvt_mode _Mymode = (codecvt_mode)0>

virtual int codecvt_utf16< _Elem, _Mymax, _Mymode >::do_encoding ( ) const

inlineprotectedvirtual

Reimplemented from codecvt_base.

        {   // return length of code sequence (from codecvt)
        return ((_Mymode & (consume_header | generate_header)) != 0
            ? -1 : 0);  // -1 => state dependent, 0 => varying length
        }

template<class _Elem , unsigned long _Mymax = 0x10ffff, codecvt_mode _Mymode = (codecvt_mode)0>

virtual result codecvt_utf16< _Elem, _Mymax, _Mymode >::do_in ( _Statype &  _State, const _Byte *  _First1, const _Byte *  _Last1, const _Byte *&  _Mid1, _Elem *  _First2, _Elem *  _Last2, _Elem *&  _Mid2  ) const

inlineprotectedvirtual

Reimplemented from codecvt< _Elem, char, _Statype >.

        {   // convert bytes [_First1, _Last1) to [_First2, _Last)
        char *_Pstate = (char *)&_State;
        _Mid1 = _First1;
        _Mid2 = _First2;

        for (; _Bytes_per_word <= _Last1 - _Mid1 && _Mid2 != _Last2; )
            {   // convert a multibyte sequence
            unsigned char *_Ptr = (unsigned char *)_Mid1;
            unsigned long _Ch;
            unsigned short _Ch0, _Ch1;

            if (*_Pstate == _LITTLE_FIRST)
                _Ch0 = (unsigned short)(_Ptr[1] << 8 | _Ptr[0]);
            else if (*_Pstate == _BIG_FIRST)
                _Ch0 = (unsigned short)(_Ptr[0] << 8 | _Ptr[1]);
            else
                {   // no header seen yet, try preferred mode
                unsigned char _Default_endian = (_Mymode & little_endian) != 0
                    ? _LITTLE_FIRST : _BIG_FIRST;

                 if ((_Mymode & little_endian) != 0)
                    _Ch0 = (unsigned short)(_Ptr[1] << 8 | _Ptr[0]);
                else
                    _Ch0 = (unsigned short)(_Ptr[0] << 8 | _Ptr[1]);
                if ((_Mymode & consume_header) == 0
                    || (_Ch0 != 0xfeff && _Ch0 != 0xfffe))
                    *_Pstate = _Default_endian;
                else
                    {   // consume header, fixate on endianness, and retry
                    _Mid1 += _Bytes_per_word;
                    *_Pstate = (char)(_Ch0 == 0xfeff
                        ? _Default_endian
                        : (unsigned char)(3 - _Default_endian));
                    result _Ans = do_in(_State, _Mid1, _Last1, _Mid1,
                        _First2, _Last2, _Mid2);

                    if (_Ans == _Mybase::partial)
                        {   // not enough bytes, roll back header
                        *_Pstate = 0;
                        _Mid1 = _First1;
                        }
                    return (_Ans);
                    }
                }

            if (_Ch0 < 0xd800 || 0xdc00 <= _Ch0)
                {   // one word, consume bytes
                _Mid1 += _Bytes_per_word;
                _Ch = _Ch0;
                }
            else if (_Last1 - _Mid1 < 2 * _Bytes_per_word)
                break;
            else
                {   // get second word
                if (*_Pstate == _LITTLE_FIRST)
                    _Ch1 = (unsigned short)(_Ptr[3] << 8 | _Ptr[2]);
                else
                    _Ch1 = (unsigned short)(_Ptr[2] << 8 | _Ptr[3]);

                if (_Ch1 < 0xdc00 || 0xe000 <= _Ch1)
                    return (_Mybase::error);

                _Mid1 += 2 * _Bytes_per_word;
                _Ch = (unsigned long)(_Ch0 - 0xd800 + 0x0040) << 10
                    | (_Ch1 - 0xdc00);
                }

            if (_Mymax < _Ch)
                return (_Mybase::error);    // code too large
            *_Mid2++ = (_Elem)_Ch;
            }

        return (_First1 == _Mid1 ? _Mybase::partial : _Mybase::ok);
        }

template<class _Elem , unsigned long _Mymax = 0x10ffff, codecvt_mode _Mymode = (codecvt_mode)0>

virtual int codecvt_utf16< _Elem, _Mymax, _Mymode >::do_length ( _Statype &  _State, const _Byte *  _First1, const _Byte *  _Last1, size_t  _Count  ) const

inlineprotectedvirtual

Reimplemented from codecvt< _Elem, char, _Statype >.

        {   // return min(_Count, converted length of bytes [_First1, _Last1))
        size_t _Wchars = 0;
        _Statype _Mystate = _State;

        for (; _Wchars < _Count && _First1 != _Last1; )
            {   // convert another wide char
            const _Byte *_Mid1;
            _Elem *_Mid2;
            _Elem _Ch;

            switch (do_in(_Mystate, _First1, _Last1, _Mid1,
                &_Ch, &_Ch + 1, _Mid2))
                {   // test result of single wide-char conversion
            case _Mybase::noconv:
                return ((int)(_Wchars + (_Last1 - _First1)));

            case  _Mybase::ok:
                if (_Mid2 == &_Ch + 1)
                    ++_Wchars;  // replacement do_in might not convert one
                _First1 = _Mid1;
                break;

            default:
                return ((int)_Wchars);  // error or partial
                }
            }

        return ((int)_Wchars);
        }

template<class _Elem , unsigned long _Mymax = 0x10ffff, codecvt_mode _Mymode = (codecvt_mode)0>

virtual int codecvt_utf16< _Elem, _Mymax, _Mymode >::do_max_length ( ) const

inlineprotectedvirtual

Reimplemented from codecvt_base.

        {   // return maximum length required for a conversion
        return ((_Mymode & (consume_header | generate_header)) != 0
            ? 3 * _Bytes_per_word : 6 * _Bytes_per_word);
        }

template<class _Elem , unsigned long _Mymax = 0x10ffff, codecvt_mode _Mymode = (codecvt_mode)0>

virtual result codecvt_utf16< _Elem, _Mymax, _Mymode >::do_out ( _Statype &  _State, const _Elem *  _First1, const _Elem *  _Last1, const _Elem *&  _Mid1, _Byte *  _First2, _Byte *  _Last2, _Byte *&  _Mid2  ) const

inlineprotectedvirtual

Reimplemented from codecvt< _Elem, char, _Statype >.

        {   // convert [_First1, _Last1) to bytes [_First2, _Last)
        char *_Pstate = (char *)&_State;
        _Mid1 = _First1;
        _Mid2 = _First2;

        if (*_Pstate == 0)
            {   // determine endianness once, maybe generate header
            *_Pstate = (_Mymode & little_endian) != 0
                ? _LITTLE_FIRST : _BIG_FIRST;
            if ((_Mymode & generate_header) == 0)
                ;
            else if (_Last2 - _Mid2 < 3 * _Bytes_per_word)
                return (_Mybase::partial);  // not enough room for all
            else if (*_Pstate == _LITTLE_FIRST)
                {   // put header LS byte first
                *_Mid2++ = (_Byte)(unsigned char)0xff;
                *_Mid2++ = (_Byte)(unsigned char)0xfe;
                }
            else
                {   // put header MS byte first
                *_Mid2++ = (_Byte)(unsigned char)0xfe;
                *_Mid2++ = (_Byte)(unsigned char)0xff;
                }
            }

        for (; _Mid1 != _Last1 && _Bytes_per_word <= _Last2 - _Mid2; )
            {   // convert and put a wide char
            bool _Extra = false;
            unsigned long _Ch = (unsigned long)*_Mid1++;

            if ((_Mymax < 0x10ffff ? _Mymax : 0x10ffff) < _Ch)
                return (_Mybase::error);    // value too large
            else if (_Ch <= 0xffff)
                {   // one word, can't be code for first of two
                if (0xd800 <= _Ch && _Ch < 0xdc00)
                    return (_Mybase::error);
                }
            else if (_Last2 - _Mid2 < 2 * _Bytes_per_word)
                {   // not enough room for two-word output, back up
                --_Mid1;
                return (_Mybase::partial);
                }
            else
                _Extra = true;

            if (*_Pstate == _LITTLE_FIRST)
                if (!_Extra)
                    {   // put a single word LS byte first
                    *_Mid2++ = (_Byte)_Ch;
                    *_Mid2++ = (_Byte)(_Ch >> 8);
                    }
                else
                    {   // put a pair of words LS byte first
                    unsigned short _Ch0 = (unsigned short)(0xd800
                        | (unsigned short)(_Ch >> 10) - 0x0040);
                    *_Mid2++ = (_Byte)_Ch0;
                    *_Mid2++ = (_Byte)(_Ch0 >> 8);

                    _Ch0 = (unsigned short)(0xdc00
                        | ((unsigned short)_Ch & 0x03ff));
                    *_Mid2++ = (_Byte)_Ch0;
                    *_Mid2++ = (_Byte)(_Ch0 >> 8);
                    }
            else
                if (!_Extra)
                    {   // put a single word MS byte first
                    *_Mid2++ = (_Byte)(_Ch >> 8);
                    *_Mid2++ = (_Byte)_Ch;
                    }
                else
                    {   // put a pair of words MS byte first
                    unsigned short _Ch0 = (unsigned short)(0xd800
                        | (unsigned short)(_Ch >> 10) - 0x0040);
                    *_Mid2++ = (_Byte)(_Ch0 >> 8);
                    *_Mid2++ = (_Byte)_Ch0;

                    _Ch0 = (unsigned short)(0xdc00
                        | ((unsigned short)_Ch & 0x03ff));
                    *_Mid2++ = (_Byte)(_Ch0 >> 8);
                    *_Mid2++ = (_Byte)_Ch0;
                    }
            }

        return (_First1 == _Mid1 ? _Mybase::partial : _Mybase::ok);
        }

template<class _Elem , unsigned long _Mymax = 0x10ffff, codecvt_mode _Mymode = (codecvt_mode)0>

virtual result codecvt_utf16< _Elem, _Mymax, _Mymode >::do_unshift ( _Statype &  , _Byte *  _First2, _Byte *  , _Byte *&  _Mid2  ) const

inlineprotectedvirtual

Reimplemented from codecvt< _Elem, char, _Statype >.

        {   // generate bytes to return to default shift state
        _Mid2 = _First2;
        return (_Mybase::ok);
        }

---

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

• VS2013/inc/codecvt