codecvt_utf8_utf16< _Elem, _Mymax, _Mymode > Class Template Reference

Inheritance diagram for codecvt_utf8_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_utf8_utf16 (size_t _Refs=0)
virtual __CLR_OR_THIS_CALL	~codecvt_utf8_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 __CLR_OR_THIS_CALL	do_in (_Statype &_State, const _Byte *_First1, const _Byte *_Last1, const _Byte *&_Mid1, _Elem *_First2, _Elem *_Last2, _Elem *&_Mid2) const
virtual result __CLR_OR_THIS_CALL	do_out (_Statype &_State, const _Elem *_First1, const _Elem *_Last1, const _Elem *&_Mid1, _Byte *_First2, _Byte *_Last2, _Byte *&_Mid2) const
virtual result __CLR_OR_THIS_CALL	do_unshift (_Statype &_State, _Byte *_First2, _Byte *, _Byte *&_Mid2) const
virtual int __CLR_OR_THIS_CALL	do_length (_Statype &_State, const _Byte *_First1, const _Byte *_Last1, size_t _Count) const _THROW0()
virtual bool __CLR_OR_THIS_CALL	do_always_noconv () const _THROW0()
virtual int __CLR_OR_THIS_CALL	do_max_length () const _THROW0()
virtual int __CLR_OR_THIS_CALL	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

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_utf8_utf16< _Elem, _Mymax, _Mymode >::_Byte

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

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

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

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

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

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

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

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

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

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

Constructor & Destructor Documentation

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

codecvt_utf8_utf16< _Elem, _Mymax, _Mymode >::codecvt_utf8_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 __CLR_OR_THIS_CALL codecvt_utf8_utf16< _Elem, _Mymax, _Mymode >::~codecvt_utf8_utf16 ( )

inlinevirtual

        {   // destroy the object
        }

Member Function Documentation

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

virtual bool __CLR_OR_THIS_CALL codecvt_utf8_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 __CLR_OR_THIS_CALL codecvt_utf8_utf16< _Elem, _Mymax, _Mymode >::do_encoding ( ) const

inlineprotectedvirtual

Reimplemented from codecvt_base.

        {   // return length of code sequence (from codecvt)
        return (0); // 0 => varying length
        }

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

virtual result __CLR_OR_THIS_CALL codecvt_utf8_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, _Last2)
        unsigned short *_Pstate = (unsigned short *)&_State;
        _Mid1 = _First1;
        _Mid2 = _First2;

        for (; _Mid1 != _Last1 && _Mid2 != _Last2; )
            {   // convert a multibyte sequence
            unsigned char _By = (unsigned char)*_Mid1;
            unsigned long _Ch;
            int _Nextra, _Nskip;

            if (*_Pstate <= 1)
                ;   // no leftover word
            else if (_By < 0x80 || 0xc0 <= _By)
                return (_Mybase::error);    // not continuation byte
            else
                {   // deliver second half of two-word value
                ++_Mid1;
                *_Mid2++ = (_Elem)(*_Pstate | (_By & 0x3f));
                *_Pstate = 1;
                continue;
                }

            if (_By < 0x80)
                _Ch = _By, _Nextra = 0;
            else if (_By < 0xc0)
                {   // 0x80-0xdf not first byte
                ++_Mid1;
                return (_Mybase::error);
                }
            else if (_By < 0xe0)
                _Ch = _By & 0x1f, _Nextra = 1;
            else if (_By < 0xf0)
                _Ch = _By & 0x0f, _Nextra = 2;
            else if (_By < 0xf8)
                _Ch = _By & 0x07, _Nextra = 3;
            else
                _Ch = _By & 0x03, _Nextra = _By < 0xfc ? 4 : 5;

            _Nskip = _Nextra < 3 ? 0 : 1;   // leave a byte for 2nd word
            _First1 = _Mid1;    // roll back point

            if (_Nextra == 0)
                ++_Mid1;
            else if (_Last1 - _Mid1 < _Nextra + 1 - _Nskip)
                break;  // not enough input
            else
                for (++_Mid1; _Nskip < _Nextra; --_Nextra, ++_Mid1)
                    if ((_By = (unsigned char)*_Mid1) < 0x80 || 0xc0 <= _By)
                        return (_Mybase::error);    // not continuation byte
                    else
                        _Ch = _Ch << 6 | (_By & 0x3f);
            if (0 < _Nskip)
                _Ch <<= 6;  // get last byte on next call

            if ((_Mymax < 0x10ffff ? _Mymax : 0x10ffff) < _Ch)
                return (_Mybase::error);    // value too large
            else if (0xffff < _Ch)
                {   // deliver first half of two-word value, save second word
                unsigned short _Ch0 =
                    (unsigned short)(0xd800 | (_Ch >> 10) - 0x0040);

                *_Mid2++ = (_Elem)_Ch0;
                *_Pstate = (unsigned short)(0xdc00 | (_Ch & 0x03ff));
                continue;
                }

            if (_Nskip == 0)
                ;
            else if (_Mid1 == _Last1)
                {   // not enough bytes, noncanonical value
                _Mid1 = _First1;
                break;
                }
            else if ((_By = (unsigned char)*_Mid1++) < 0x80 || 0xc0 <= _By)
                return (_Mybase::error);    // not continuation byte
            else
                _Ch |= _By & 0x3f;  // complete noncanonical value

            if (*_Pstate == 0)
                {   // first time, maybe look for and consume header
                *_Pstate = 1;

                if ((_Mymode & consume_header) != 0 && _Ch == 0xfeff)
                    {   // drop header and retry
                    result _Ans = do_in(_State, _Mid1, _Last1, _Mid1,
                        _First2, _Last2, _Mid2);

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

            *_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 __CLR_OR_THIS_CALL codecvt_utf8_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 character
            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 __CLR_OR_THIS_CALL codecvt_utf8_utf16< _Elem, _Mymax, _Mymode >::do_max_length ( ) const

inlineprotectedvirtual

Reimplemented from codecvt_base.

        {   // return maximum length required for a conversion
        return ((_Mymode & consume_header) != 0 ? 9 // header + max input
            : (_Mymode & generate_header) != 0 ? 7  // header + max output
            : 6);   // 6-byte max input sequence, no 3-byte header
        }

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

virtual result __CLR_OR_THIS_CALL codecvt_utf8_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)
        unsigned short *_Pstate = (unsigned short *)&_State;
        _Mid1 = _First1;
        _Mid2 = _First2;

        for (; _Mid1 != _Last1 && _Mid2 != _Last2; )
            {   // convert and put a wide char
            unsigned long _Ch;
            unsigned short _Ch1 = (unsigned short)*_Mid1;
            bool _Save = false;

            if (1 < *_Pstate)
                {   // get saved MS 11 bits from *_Pstate
                if (_Ch1 < 0xdc00 || 0xe000 <= _Ch1)
                    return (_Mybase::error);    // bad second word
                _Ch = (*_Pstate << 10) | (_Ch1 - 0xdc00);
                }
            else if (0xd800 <= _Ch1 && _Ch1 < 0xdc00)
                {   // get new first word
                _Ch = (_Ch1 - 0xd800 + 0x0040) << 10;
                _Save = true;   // put only first byte, rest with second word
                }
            else
                _Ch = _Ch1; // not first word, just put it

            _Byte _By;
            int _Nextra;

            if (_Ch < 0x0080)
                _By = (_Byte)_Ch, _Nextra = 0;
            else if (_Ch < 0x0800)
                _By = (_Byte)(0xc0 | _Ch >> 6), _Nextra = 1;
            else if (_Ch < 0x10000)
                _By = (_Byte)(0xe0 | _Ch >> 12), _Nextra = 2;
            else
                _By = (_Byte)(0xf0 | _Ch >> 18), _Nextra = 3;

            int _Nput = _Nextra < 3 ? _Nextra + 1 : _Save ? 1 : 3;

            if (_Last2 - _Mid2 < _Nput)
                break;  // not enough room, even without header
            else if (*_Pstate != 0 || (_Mymode & generate_header) == 0)
                ;   // no header to put
            else if (_Last2 - _Mid2 < 3 + _Nput)
                break;  // not enough room for header + output
            else
                {   // prepend header
                *_Mid2++ = (_Byte)(unsigned char)0xef;
                *_Mid2++ = (_Byte)(unsigned char)0xbb;
                *_Mid2++ = (_Byte)(unsigned char)0xbf;
                }

            ++_Mid1;
            if (_Save || _Nextra < 3)
                {   // put first byte of sequence, if not already put
                *_Mid2++ = _By;
                --_Nput;
                }
            for (; 0 < _Nput; --_Nput)
                *_Mid2++ = (_Byte)((_Ch >> 6 * --_Nextra & 0x3f) | 0x80);

            *_Pstate = (unsigned short)(_Save ? _Ch >> 10 : 1);
            }

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

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

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

inlineprotectedvirtual

Reimplemented from codecvt< _Elem, char, _Statype >.

        {   // generate bytes to return to default shift state
        unsigned short *_Pstate = (unsigned short *)&_State;
        _Mid2 = _First2;

        return (1 < *_Pstate
            ? _Mybase::error : _Mybase::ok);    // fail if trailing first word
        }

---

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

• VS2017/inc/codecvt