irr::core::ustring16< TAlloc > Class Template Reference

UTF-16 string class. More...

#include <irrUString.h>

Classes
class	_ustring16_const_iterator
	Iterator to iterate through a UTF-16 string. More...
class	_ustring16_iterator
	Iterator to iterate through a UTF-16 string. More...
class	_ustring16_iterator_access
	Access an element in a unicode string, allowing one to change it. More...

Public Types
typedef ustring16< TAlloc >::_ustring16_iterator_access	access
typedef ustring16< TAlloc >::_ustring16_iterator	iterator
typedef ustring16< TAlloc >::_ustring16_const_iterator	const_iterator

Public Member Functions
	ustring16 ()
	Default constructor. More...
	ustring16 (const ustring16< TAlloc > &other)
	Constructor. More...
template<class B , class A >
	ustring16 (const string< B, A > &other)
	Constructor from other string types. More...
	ustring16 (const char *const c)
	Constructor for copying a character string from a pointer. More...
	ustring16 (const char *const c, size_t length)
	Constructor for copying a character string from a pointer with a given length. More...
	ustring16 (const uchar8_t *const c)
	Constructor for copying a UTF-8 string from a pointer. More...
	ustring16 (const char c)
	Constructor for copying a UTF-8 string from a single char. More...
	ustring16 (const uchar8_t *const c, size_t length)
	Constructor for copying a UTF-8 string from a pointer with a given length. More...
	ustring16 (const uchar16_t *const c)
	Constructor for copying a UTF-16 string from a pointer. More...
	ustring16 (const uchar16_t *const c, size_t length)
	Constructor for copying a UTF-16 string from a pointer with a given length. More...
	ustring16 (const uchar32_t *const c)
	Constructor for copying a UTF-32 string from a pointer. More...
	ustring16 (const uchar32_t *const c, size_t length)
	Constructor for copying a UTF-32 from a pointer with a given length. More...
	ustring16 (const wchar_t *const c)
	Constructor for copying a wchar_t string from a pointer. More...
	ustring16 (const wchar_t *const c, size_t length)
	Constructor for copying a wchar_t string from a pointer with a given length. More...
	~ustring16 ()
	Destructor. More...
ustring16 &	operator= (const ustring16< TAlloc > &other)
	Assignment operator. More...
template<class B , class A >
ustring16< TAlloc > &	operator= (const string< B, A > &other)
	Assignment operator for other string types. More...
ustring16< TAlloc > &	operator= (const uchar8_t *const c)
	Assignment operator for UTF-8 strings. More...
ustring16< TAlloc > &	operator= (const uchar16_t *const c)
	Assignment operator for UTF-16 strings. More...
ustring16< TAlloc > &	operator= (const uchar32_t *const c)
	Assignment operator for UTF-32 strings. More...
ustring16< TAlloc > &	operator= (const wchar_t *const c)
	Assignment operator for wchar_t strings. More...
template<class B >
ustring16< TAlloc > &	operator= (const B *const c)
	Assignment operator for other strings. More...
access	operator [] (const size_t index)
	Direct access operator. More...
const access	operator [] (const size_t index) const
	Direct access operator. More...
bool	operator== (const uchar16_t *const str) const
	Equality operator. More...
bool	operator== (const ustring16< TAlloc > &other) const
	Equality operator. More...
bool	operator< (const ustring16< TAlloc > &other) const
	Is smaller comparator. More...
bool	operator != (const uchar16_t *const str) const
	Inequality operator. More...
bool	operator != (const ustring16< TAlloc > &other) const
	Inequality operator. More...
size_t	size () const
bool	empty () const
const uchar16_t *	c_str () const
bool	equalsn (const ustring16< TAlloc > &other, size_t n) const
bool	equalsn (const uchar16_t *const str, size_t n) const
ustring16< TAlloc > &	append (uchar32_t character)
ustring16< TAlloc > &	append (const uchar8_t *const other, size_t length=0xffffffff)
ustring16< TAlloc > &	append (const uchar16_t *const other, size_t length=0xffffffff)
ustring16< TAlloc > &	append (const uchar32_t *const other, size_t length=0xffffffff)
ustring16< TAlloc > &	append (const ustring16< TAlloc > &other)
ustring16< TAlloc > &	append (const ustring16< TAlloc > &other, size_t length)
void	reserve (size_t count)
size_t	findFirst (uchar32_t c) const
size_t	findFirstChar (const uchar32_t *const c, size_t count=1) const
size_t	findFirstCharNotInList (const uchar32_t *const c, size_t count=1) const
size_t	findLastCharNotInList (const uchar32_t *const c, size_t count=1) const
size_t	findNext (uchar32_t c, size_t startPos) const
size_t	findLast (uchar32_t c, size_t start=ustring16< TAlloc >::npos) const
size_t	findLastChar (const uchar32_t *const c, size_t count=1) const
size_t	find (const ustring16< TAlloc > &str, const size_t start=0) const
size_t	find_raw (const ustring16< TAlloc > &str, const size_t start=0) const
ustring16< TAlloc >	subString (size_t begin, size_t length) const
ustring16< TAlloc > &	operator+= (char c)
ustring16< TAlloc > &	operator+= (uchar32_t c)
ustring16< TAlloc > &	operator+= (short c)
ustring16< TAlloc > &	operator+= (unsigned short c)
ustring16< TAlloc > &	operator+= (long c)
ustring16< TAlloc > &	operator+= (unsigned long c)
ustring16< TAlloc > &	operator+= (double c)
ustring16< TAlloc > &	operator+= (const uchar16_t *const c)
ustring16< TAlloc > &	operator+= (const ustring16< TAlloc > &other)
ustring16< TAlloc > &	replace (uchar32_t toReplace, uchar32_t replaceWith)
ustring16< TAlloc > &	replace (const ustring16< TAlloc > &toReplace, const ustring16< TAlloc > &replaceWith)
ustring16< TAlloc > &	remove (uchar32_t c)
ustring16< TAlloc > &	remove (const ustring16< TAlloc > &toRemove)
ustring16< TAlloc > &	removeChars (const ustring16< TAlloc > &characters)
ustring16< TAlloc > &	trim (const ustring16< TAlloc > &whitespace=" \t\n\r")
ustring16< TAlloc > &	erase (size_t index)
ustring16< TAlloc > &	validate ()
uchar32_t	lastChar () const
template<class container >
size_t	split (container &ret, const uchar32_t *const c, size_t count=1, bool ignoreEmptyTokens=true, bool keepSeparators=false) const
	Split the ustring16 into parts. More...
template<class container >
size_t	split (container &ret, const ustring16< TAlloc > &c, bool ignoreEmptyTokens=true, bool keepSeparators=false) const
	Split the ustring16 into parts. More...
size_t	capacity () const
size_t	size_raw () const
ustring16< TAlloc > &	insert (uchar32_t c, size_t pos)
ustring16< TAlloc > &	insert (const ustring16< TAlloc > &c, size_t pos)
ustring16< TAlloc > &	insert_raw (uchar16_t c, size_t pos)
ustring16< TAlloc > &	erase_raw (size_t pos)
ustring16< TAlloc > &	replace_raw (uchar16_t c, size_t pos)
iterator	begin ()
const_iterator	begin () const
const_iterator	cbegin () const
iterator	end ()
const_iterator	end () const
const_iterator	cend () const
core::string< uchar8_t >	toUTF8_s (const bool addBOM=false) const
core::array< uchar8_t >	toUTF8 (const bool addBOM=false) const
core::array< uchar16_t >	toUTF16 (const unicode::EUTF_ENDIAN endian=unicode::EUTFEE_NATIVE, const bool addBOM=false) const
core::array< uchar32_t >	toUTF32 (const unicode::EUTF_ENDIAN endian=unicode::EUTFEE_NATIVE, const bool addBOM=false) const
core::string< wchar_t >	toWCHAR_s (const unicode::EUTF_ENDIAN endian=unicode::EUTFEE_NATIVE, const bool addBOM=false) const
	Converts the string to a wchar_t encoded string. More...
core::array< wchar_t >	toWCHAR (const unicode::EUTF_ENDIAN endian=unicode::EUTFEE_NATIVE, const bool addBOM=false) const
	Converts the string to a wchar_t encoded string array. More...
io::path	toPATH_s (const unicode::EUTF_ENDIAN endian=unicode::EUTFEE_NATIVE, const bool addBOM=false) const
ustring16< TAlloc > &	loadDataStream (const char *data, size_t data_size)
const unicode::EUTF_ENCODE	getEncoding () const
const unicode::EUTF_ENDIAN	getEndianness () const

Static Public Attributes
static const size_t	npos = -1

Detailed Description

template<typename TAlloc = irrAllocator<uchar16_t>>
class irr::core::ustring16< TAlloc >

UTF-16 string class.

Definition at line 236 of file irrUString.h.

Member Typedef Documentation

access

template<typename TAlloc = irrAllocator<uchar16_t>>

typedef ustring16<TAlloc>::_ustring16_iterator_access irr::core::ustring16< TAlloc >::access

Definition at line 435 of file irrUString.h.

const_iterator

template<typename TAlloc = irrAllocator<uchar16_t>>

typedef ustring16<TAlloc>::_ustring16_const_iterator irr::core::ustring16< TAlloc >::const_iterator

Definition at line 798 of file irrUString.h.

iterator

template<typename TAlloc = irrAllocator<uchar16_t>>

typedef ustring16<TAlloc>::_ustring16_iterator irr::core::ustring16< TAlloc >::iterator

Definition at line 797 of file irrUString.h.

Constructor & Destructor Documentation

ustring16() [1/14]

template<typename TAlloc = irrAllocator<uchar16_t>>

irr::core::ustring16< TAlloc >::ustring16 ( )

inline

Default constructor.

Definition at line 812 of file irrUString.h.

        : array(0), allocated(1), used(0)
        {
#if __BIG_ENDIAN__
                encoding = unicode::EUTFE_UTF16_BE;
#else
                encoding = unicode::EUTFE_UTF16_LE;
#endif
                array = allocator.allocate(1); // new u16[1];
                array[0] = 0x0;
        }

ustring16() [2/14]

template<typename TAlloc = irrAllocator<uchar16_t>>

irr::core::ustring16< TAlloc >::ustring16 ( const ustring16< TAlloc > &  other )

inline

Constructor.

Definition at line 826 of file irrUString.h.

        : array(0), allocated(0), used(0)
        {
#if __BIG_ENDIAN__
                encoding = unicode::EUTFE_UTF16_BE;
#else
                encoding = unicode::EUTFE_UTF16_LE;
#endif
                *this = other;
        }

ustring16() [3/14]

template<typename TAlloc = irrAllocator<uchar16_t>>

template<class B , class A >

irr::core::ustring16< TAlloc >::ustring16 ( const string< B, A > &  other )

inline

Constructor from other string types.

Definition at line 840 of file irrUString.h.

        : array(0), allocated(0), used(0)
        {
#if __BIG_ENDIAN__
                encoding = unicode::EUTFE_UTF16_BE;
#else
                encoding = unicode::EUTFE_UTF16_LE;
#endif
                *this = other;
        }

ustring16() [4/14]

template<typename TAlloc = irrAllocator<uchar16_t>>

irr::core::ustring16< TAlloc >::ustring16 ( const char *const  c )

inline

Constructor for copying a character string from a pointer.

Definition at line 888 of file irrUString.h.

        : array(0), allocated(0), used(0)
        {
#if __BIG_ENDIAN__
                encoding = unicode::EUTFE_UTF16_BE;
#else
                encoding = unicode::EUTFE_UTF16_LE;
#endif

                loadDataStream(c, strlen(c));
                //append((uchar8_t*)c);
        }

ustring16() [5/14]

template<typename TAlloc = irrAllocator<uchar16_t>>

irr::core::ustring16< TAlloc >::ustring16 ( const char *const  c, size_t  length  )

inline

Constructor for copying a character string from a pointer with a given length.

Definition at line 903 of file irrUString.h.

        : array(0), allocated(0), used(0)
        {
#if __BIG_ENDIAN__
                encoding = unicode::EUTFE_UTF16_BE;
#else
                encoding = unicode::EUTFE_UTF16_LE;
#endif

                loadDataStream(c, length);
        }

ustring16() [6/14]

template<typename TAlloc = irrAllocator<uchar16_t>>

irr::core::ustring16< TAlloc >::ustring16 ( const uchar8_t *const  c )

inline

Constructor for copying a UTF-8 string from a pointer.

Definition at line 918 of file irrUString.h.

        : array(0), allocated(0), used(0)
        {
#if __BIG_ENDIAN__
                encoding = unicode::EUTFE_UTF16_BE;
#else
                encoding = unicode::EUTFE_UTF16_LE;
#endif

                append(c);
        }

ustring16() [7/14]

template<typename TAlloc = irrAllocator<uchar16_t>>

irr::core::ustring16< TAlloc >::ustring16 ( const char  c )

inline

Constructor for copying a UTF-8 string from a single char.

Definition at line 932 of file irrUString.h.

        : array(0), allocated(0), used(0)
        {
#if __BIG_ENDIAN__
                encoding = unicode::EUTFE_UTF16_BE;
#else
                encoding = unicode::EUTFE_UTF16_LE;
#endif

                append((uchar32_t)c);
        }

ustring16() [8/14]

template<typename TAlloc = irrAllocator<uchar16_t>>

irr::core::ustring16< TAlloc >::ustring16 ( const uchar8_t *const  c, size_t  length  )

inline

Constructor for copying a UTF-8 string from a pointer with a given length.

Definition at line 946 of file irrUString.h.

        : array(0), allocated(0), used(0)
        {
#if __BIG_ENDIAN__
                encoding = unicode::EUTFE_UTF16_BE;
#else
                encoding = unicode::EUTFE_UTF16_LE;
#endif

                append(c, length);
        }

ustring16() [9/14]

template<typename TAlloc = irrAllocator<uchar16_t>>

irr::core::ustring16< TAlloc >::ustring16 ( const uchar16_t *const  c )

inline

Constructor for copying a UTF-16 string from a pointer.

Definition at line 960 of file irrUString.h.

        : array(0), allocated(0), used(0)
        {
#if __BIG_ENDIAN__
                encoding = unicode::EUTFE_UTF16_BE;
#else
                encoding = unicode::EUTFE_UTF16_LE;
#endif

                append(c);
        }

ustring16() [10/14]

template<typename TAlloc = irrAllocator<uchar16_t>>

irr::core::ustring16< TAlloc >::ustring16 ( const uchar16_t *const  c, size_t  length  )

inline

Constructor for copying a UTF-16 string from a pointer with a given length.

Definition at line 974 of file irrUString.h.

        : array(0), allocated(0), used(0)
        {
#if __BIG_ENDIAN__
                encoding = unicode::EUTFE_UTF16_BE;
#else
                encoding = unicode::EUTFE_UTF16_LE;
#endif

                append(c, length);
        }

ustring16() [11/14]

template<typename TAlloc = irrAllocator<uchar16_t>>

irr::core::ustring16< TAlloc >::ustring16 ( const uchar32_t *const  c )

inline

Constructor for copying a UTF-32 string from a pointer.

Definition at line 988 of file irrUString.h.

        : array(0), allocated(0), used(0)
        {
#if __BIG_ENDIAN__
                encoding = unicode::EUTFE_UTF16_BE;
#else
                encoding = unicode::EUTFE_UTF16_LE;
#endif

                append(c);
        }

ustring16() [12/14]

template<typename TAlloc = irrAllocator<uchar16_t>>

irr::core::ustring16< TAlloc >::ustring16 ( const uchar32_t *const  c, size_t  length  )

inline

Constructor for copying a UTF-32 from a pointer with a given length.

Definition at line 1002 of file irrUString.h.

        : array(0), allocated(0), used(0)
        {
#if __BIG_ENDIAN__
                encoding = unicode::EUTFE_UTF16_BE;
#else
                encoding = unicode::EUTFE_UTF16_LE;
#endif

                append(c, length);
        }

ustring16() [13/14]

template<typename TAlloc = irrAllocator<uchar16_t>>

irr::core::ustring16< TAlloc >::ustring16 ( const wchar_t *const  c )

inline

Constructor for copying a wchar_t string from a pointer.

Definition at line 1016 of file irrUString.h.

        : array(0), allocated(0), used(0)
        {
#if __BIG_ENDIAN__
                encoding = unicode::EUTFE_UTF16_BE;
#else
                encoding = unicode::EUTFE_UTF16_LE;
#endif

                if (sizeof(wchar_t) == 4)
                        append(reinterpret_cast<const uchar32_t* const>(c));
                else if (sizeof(wchar_t) == 2)
                        append(reinterpret_cast<const uchar16_t* const>(c));
                else if (sizeof(wchar_t) == 1)
                        append(reinterpret_cast<const uchar8_t* const>(c));
        }

ustring16() [14/14]

template<typename TAlloc = irrAllocator<uchar16_t>>

irr::core::ustring16< TAlloc >::ustring16 ( const wchar_t *const  c, size_t  length  )

inline

Constructor for copying a wchar_t string from a pointer with a given length.

Definition at line 1035 of file irrUString.h.

        : array(0), allocated(0), used(0)
        {
#if __BIG_ENDIAN__
                encoding = unicode::EUTFE_UTF16_BE;
#else
                encoding = unicode::EUTFE_UTF16_LE;
#endif

                if (sizeof(wchar_t) == 4)
                        append(reinterpret_cast<const uchar32_t* const>(c), length);
                else if (sizeof(wchar_t) == 2)
                        append(reinterpret_cast<const uchar16_t* const>(c), length);
                else if (sizeof(wchar_t) == 1)
                        append(reinterpret_cast<const uchar8_t* const>(c), length);
        }

~ustring16()

template<typename TAlloc = irrAllocator<uchar16_t>>

irr::core::ustring16< TAlloc >::~ustring16 ( )

inline

Destructor.

Definition at line 1067 of file irrUString.h.

        {
                allocator.deallocate(array); // delete [] array;
        }

Member Function Documentation

append() [1/6]

template<typename TAlloc = irrAllocator<uchar16_t>>

ustring16<TAlloc>& irr::core::ustring16< TAlloc >::append ( uchar32_t  character )

inline

Appends a character to this ustring16

Parameters

character

The character to append.

Returns

A reference to our current string.

Definition at line 1360 of file irrUString.h.

        {
                if (used + 2 >= allocated)
                        reallocate(used + 2);

                if (character > 0xFFFF)
                {
                        used += 2;

                        // character will be multibyte, so split it up into a surrogate pair.
                        uchar16_t x = static_cast<uchar16_t>(character);
                        uchar16_t vh = UTF16_HI_SURROGATE | ((((character >> 16) & ((1 << 5) - 1)) - 1) << 6) | (x >> 10);
                        uchar16_t vl = UTF16_LO_SURROGATE | (x & ((1 << 10) - 1));
                        array[used-2] = vh;
                        array[used-1] = vl;
                }
                else
                {
                        ++used;
                        array[used-1] = character;
                }
                array[used] = 0;

                return *this;
        }

append() [2/6]

template<typename TAlloc = irrAllocator<uchar16_t>>

ustring16<TAlloc>& irr::core::ustring16< TAlloc >::append ( const uchar8_t *const  other, size_t  length = 0xffffffff  )

inline

Appends a UTF-8 string to this ustring16

Parameters

other	The UTF-8 string to append.
length	The length of the string to append.

Returns

A reference to our current string.

Definition at line 1391 of file irrUString.h.

        {
                if (!other)
                        return *this;

                // Determine if the string is long enough for a BOM.
                size_t len = 0;
                const uchar8_t* p = other;
                do
                {
                        ++len;
                } while (*p++ && len < unicode::BOM_ENCODE_UTF8_LEN);

                // Check for BOM.
                unicode::EUTF_ENCODE c_bom = unicode::EUTFE_NONE;
                if (len == unicode::BOM_ENCODE_UTF8_LEN)
                {
                        if (memcmp(other, unicode::BOM_ENCODE_UTF8, unicode::BOM_ENCODE_UTF8_LEN) == 0)
                                c_bom = unicode::EUTFE_UTF8;
                }

                // If a BOM was found, don't include it in the string.
                const uchar8_t* c2 = other;
                if (c_bom != unicode::EUTFE_NONE)
                {
                        c2 = other + unicode::BOM_UTF8_LEN;
                        length -= unicode::BOM_UTF8_LEN;
                }

                // Calculate the size of the string to read in.
                len = 0;
                p = c2;
                do
                {
                        ++len;
                } while(*p++ && len < length);
                if (len > length)
                        len = length;

                // If we need to grow the array, do it now.
                if (used + len >= allocated)
                        reallocate(used + (len * 2));
                size_t start = used;

                // Convert UTF-8 to UTF-16.
                size_t pos = start;
                for (size_t l = 0; l<len;)
                {
                        ++used;
                        if (((c2[l] >> 6) & 0x03) == 0x02)
                        {       // Invalid continuation byte.
                                array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
                                ++l;
                        }
                        else if (c2[l] == 0xC0 || c2[l] == 0xC1)
                        {       // Invalid byte - overlong encoding.
                                array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
                                ++l;
                        }
                        else if ((c2[l] & 0xF8) == 0xF0)
                        {       // 4 bytes UTF-8, 2 bytes UTF-16.
                                // Check for a full string.
                                if ((l + 3) >= len)
                                {
                                        array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
                                        l += 3;
                                        break;
                                }

                                // Validate.
                                bool valid = true;
                                u8 l2 = 0;
                                if (valid && (((c2[l+1] >> 6) & 0x03) == 0x02)) ++l2; else valid = false;
                                if (valid && (((c2[l+2] >> 6) & 0x03) == 0x02)) ++l2; else valid = false;
                                if (valid && (((c2[l+3] >> 6) & 0x03) == 0x02)) ++l2; else valid = false;
                                if (!valid)
                                {
                                        array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
                                        l += l2;
                                        continue;
                                }

                                // Decode.
                                uchar8_t b1 = ((c2[l] & 0x7) << 2) | ((c2[l+1] >> 4) & 0x3);
                                uchar8_t b2 = ((c2[l+1] & 0xF) << 4) | ((c2[l+2] >> 2) & 0xF);
                                uchar8_t b3 = ((c2[l+2] & 0x3) << 6) | (c2[l+3] & 0x3F);
                                uchar32_t v = b3 | ((uchar32_t)b2 << 8) | ((uchar32_t)b1 << 16);

                                // Split v up into a surrogate pair.
                                uchar16_t x = static_cast<uchar16_t>(v);
                                uchar16_t vh = UTF16_HI_SURROGATE | ((((v >> 16) & ((1 << 5) - 1)) - 1) << 6) | (x >> 10);
                                uchar16_t vl = UTF16_LO_SURROGATE | (x & ((1 << 10) - 1));

                                array[pos++] = vh;
                                array[pos++] = vl;
                                l += 4;
                                ++used;         // Using two shorts this time, so increase used by 1.
                        }
                        else if ((c2[l] & 0xF0) == 0xE0)
                        {       // 3 bytes UTF-8, 1 byte UTF-16.
                                // Check for a full string.
                                if ((l + 2) >= len)
                                {
                                        array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
                                        l += 2;
                                        break;
                                }

                                // Validate.
                                bool valid = true;
                                u8 l2 = 0;
                                if (valid && (((c2[l+1] >> 6) & 0x03) == 0x02)) ++l2; else valid = false;
                                if (valid && (((c2[l+2] >> 6) & 0x03) == 0x02)) ++l2; else valid = false;
                                if (!valid)
                                {
                                        array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
                                        l += l2;
                                        continue;
                                }

                                // Decode.
                                uchar8_t b1 = ((c2[l] & 0xF) << 4) | ((c2[l+1] >> 2) & 0xF);
                                uchar8_t b2 = ((c2[l+1] & 0x3) << 6) | (c2[l+2] & 0x3F);
                                uchar16_t ch = b2 | ((uchar16_t)b1 << 8);
                                array[pos++] = ch;
                                l += 3;
                        }
                        else if ((c2[l] & 0xE0) == 0xC0)
                        {       // 2 bytes UTF-8, 1 byte UTF-16.
                                // Check for a full string.
                                if ((l + 1) >= len)
                                {
                                        array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
                                        l += 1;
                                        break;
                                }

                                // Validate.
                                if (((c2[l+1] >> 6) & 0x03) != 0x02)
                                {
                                        array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
                                        ++l;
                                        continue;
                                }

                                // Decode.
                                uchar8_t b1 = (c2[l] >> 2) & 0x7;
                                uchar8_t b2 = ((c2[l] & 0x3) << 6) | (c2[l+1] & 0x3F);
                                uchar16_t ch = b2 | ((uchar16_t)b1 << 8);
                                array[pos++] = ch;
                                l += 2;
                        }
                        else
                        {       // 1 byte UTF-8, 1 byte UTF-16.
                                // Validate.
                                if (c2[l] > 0x7F)
                                {       // Values above 0xF4 are restricted and aren't used.  By now, anything above 0x7F is invalid.
                                        array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
                                }
                                else array[pos++] = static_cast<uchar16_t>(c2[l]);
                                ++l;
                        }
                }
                array[used] = 0;

                // Validate our new UTF-16 string.
                validate();

                return *this;
        }

append() [3/6]

template<typename TAlloc = irrAllocator<uchar16_t>>

ustring16<TAlloc>& irr::core::ustring16< TAlloc >::append ( const uchar16_t *const  other, size_t  length = 0xffffffff  )

inline

Appends a UTF-16 string to this ustring16

Parameters

other	The UTF-16 string to append.
length	The length of the string to append.

Returns

A reference to our current string.

Definition at line 1567 of file irrUString.h.

        {
                if (!other)
                        return *this;

                // Determine if the string is long enough for a BOM.
                size_t len = 0;
                const uchar16_t* p = other;
                do
                {
                        ++len;
                } while (*p++ && len < unicode::BOM_ENCODE_UTF16_LEN);

                // Check for the BOM to determine the string's endianness.
                unicode::EUTF_ENDIAN c_end = unicode::EUTFEE_NATIVE;
                if (memcmp(other, unicode::BOM_ENCODE_UTF16_LE, unicode::BOM_ENCODE_UTF16_LEN) == 0)
                        c_end = unicode::EUTFEE_LITTLE;
                else if (memcmp(other, unicode::BOM_ENCODE_UTF16_BE, unicode::BOM_ENCODE_UTF16_LEN) == 0)
                        c_end = unicode::EUTFEE_BIG;

                // If a BOM was found, don't include it in the string.
                const uchar16_t* c2 = other;
                if (c_end != unicode::EUTFEE_NATIVE)
                {
                        c2 = other + unicode::BOM_UTF16_LEN;
                        length -= unicode::BOM_UTF16_LEN;
                }

                // Calculate the size of the string to read in.
                len = 0;
                p = c2;
                do
                {
                        ++len;
                } while(*p++ && len < length);
                if (len > length)
                        len = length;

                // If we need to grow the size of the array, do it now.
                if (used + len >= allocated)
                        reallocate(used + (len * 2));
                size_t start = used;
                used += len;

                // Copy the string now.
                unicode::EUTF_ENDIAN m_end = getEndianness();
                for (size_t l = start; l < start + len; ++l)
                {
                        array[l] = (uchar16_t)c2[l];
                        if (c_end != unicode::EUTFEE_NATIVE && c_end != m_end)
                                array[l] = unicode::swapEndian16(array[l]);
                }

                array[used] = 0;

                // Validate our new UTF-16 string.
                validate();
                return *this;
        }

append() [4/6]

template<typename TAlloc = irrAllocator<uchar16_t>>

ustring16<TAlloc>& irr::core::ustring16< TAlloc >::append ( const uchar32_t *const  other, size_t  length = 0xffffffff  )

inline

Appends a UTF-32 string to this ustring16

Parameters

other	The UTF-32 string to append.
length	The length of the string to append.

Returns

A reference to our current string.

Definition at line 1632 of file irrUString.h.

        {
                if (!other)
                        return *this;

                // Check for the BOM to determine the string's endianness.
                unicode::EUTF_ENDIAN c_end = unicode::EUTFEE_NATIVE;
                if (memcmp(other, unicode::BOM_ENCODE_UTF32_LE, unicode::BOM_ENCODE_UTF32_LEN) == 0)
                        c_end = unicode::EUTFEE_LITTLE;
                else if (memcmp(other, unicode::BOM_ENCODE_UTF32_BE, unicode::BOM_ENCODE_UTF32_LEN) == 0)
                        c_end = unicode::EUTFEE_BIG;

                // If a BOM was found, don't include it in the string.
                const uchar32_t* c2 = other;
                if (c_end != unicode::EUTFEE_NATIVE)
                {
                        c2 = other + unicode::BOM_UTF32_LEN;
                        length -= unicode::BOM_UTF32_LEN;
                }

                // Calculate the size of the string to read in.
                size_t len = 0;
                const uchar32_t* p = c2;
                do
                {
                        ++len;
                } while(*p++ && len < length);
                if (len > length)
                        len = length;

                // If we need to grow the size of the array, do it now.
                // In case all of the UTF-32 string is split into surrogate pairs, do len * 2.
                if (used + (len * 2) >= allocated)
                        reallocate(used + ((len * 2) * 2));
                size_t start = used;

                // Convert UTF-32 to UTF-16.
                unicode::EUTF_ENDIAN m_end = getEndianness();
                size_t pos = start;
                for (size_t l = 0; l<len; ++l)
                {
                        ++used;

                        uchar32_t ch = c2[l];
                        if (c_end != unicode::EUTFEE_NATIVE && c_end != m_end)
                                ch = unicode::swapEndian32(ch);

                        if (ch > 0xFFFF)
                        {
                                // Split ch up into a surrogate pair as it is over 16 bits long.
                                uchar16_t x = static_cast<uchar16_t>(ch);
                                uchar16_t vh = UTF16_HI_SURROGATE | ((((ch >> 16) & ((1 << 5) - 1)) - 1) << 6) | (x >> 10);
                                uchar16_t vl = UTF16_LO_SURROGATE | (x & ((1 << 10) - 1));
                                array[pos++] = vh;
                                array[pos++] = vl;
                                ++used;         // Using two shorts, so increased used again.
                        }
                        else if (ch >= 0xD800 && ch <= 0xDFFF)
                        {
                                // Between possible UTF-16 surrogates (invalid!)
                                array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
                        }
                        else array[pos++] = static_cast<uchar16_t>(ch);
                }
                array[used] = 0;

                // Validate our new UTF-16 string.
                validate();

                return *this;
        }

append() [5/6]

template<typename TAlloc = irrAllocator<uchar16_t>>

ustring16<TAlloc>& irr::core::ustring16< TAlloc >::append ( const ustring16< TAlloc > &  other )

inline

Appends a ustring16 to this ustring16

Parameters

other

The string to append to this one.

Returns

A reference to our current string.

Definition at line 1708 of file irrUString.h.

        {
                const uchar16_t* oa = other.c_str();

                size_t len = other.size_raw();

                if (used + len >= allocated)
                        reallocate(used + len);

                for (size_t l=0; l<len; ++l)
                        array[used+l] = oa[l];

                used += len;
                array[used] = 0;

                return *this;
        }

append() [6/6]

template<typename TAlloc = irrAllocator<uchar16_t>>

ustring16<TAlloc>& irr::core::ustring16< TAlloc >::append ( const ustring16< TAlloc > &  other, size_t  length  )

inline

Appends a certain amount of characters of a ustring16 to this ustring16.

Parameters

other	The string to append to this one.
length	How many characters of the other string to add to this one.

Returns

A reference to our current string.

Definition at line 1731 of file irrUString.h.

        {
                if (other.size() == 0)
                        return *this;

                if (other.size() < length)
                {
                        append(other);
                        return *this;
                }

                if (used + length * 2 >= allocated)
                        reallocate(used + length * 2);

                const_iterator iter(other, 0);
                size_t l = length;
                while (!iter.atEnd() && l)
                {
                        uchar32_t c = *iter;
                        append(c);
                        ++iter;
                        --l;
                }

                return *this;
        }

begin() [1/2]

template<typename TAlloc = irrAllocator<uchar16_t>>

iterator irr::core::ustring16< TAlloc >::begin ( )

inline

Returns an iterator to the beginning of the string.

Returns

An iterator to the beginning of the string.

Definition at line 2741 of file irrUString.h.

        {
                iterator i(*this, 0);
                return i;
        }

begin() [2/2]

template<typename TAlloc = irrAllocator<uchar16_t>>

const_iterator irr::core::ustring16< TAlloc >::begin ( ) const

inline

Returns an iterator to the beginning of the string.

Returns

An iterator to the beginning of the string.

Definition at line 2750 of file irrUString.h.

        {
                const_iterator i(*this, 0);
                return i;
        }

c_str()

template<typename TAlloc = irrAllocator<uchar16_t>>

const uchar16_t* irr::core::ustring16< TAlloc >::c_str ( ) const

inline

Returns a pointer to the raw UTF-16 string data.

Returns

pointer to C-style NUL terminated array of UTF-16 code points.

Definition at line 1314 of file irrUString.h.

        {
                return array;
        }

capacity()

template<typename TAlloc = irrAllocator<uchar16_t>>

size_t irr::core::ustring16< TAlloc >::capacity ( ) const

inline

Gets the size of the allocated memory buffer for the string.

Returns

The size of the allocated memory buffer.

Definition at line 2614 of file irrUString.h.

        {
                return allocated;
        }

cbegin()

template<typename TAlloc = irrAllocator<uchar16_t>>

const_iterator irr::core::ustring16< TAlloc >::cbegin ( ) const

inline

Returns an iterator to the beginning of the string.

Returns

An iterator to the beginning of the string.

Definition at line 2759 of file irrUString.h.

        {
                const_iterator i(*this, 0);
                return i;
        }

cend()

template<typename TAlloc = irrAllocator<uchar16_t>>

const_iterator irr::core::ustring16< TAlloc >::cend ( ) const

inline

Returns an iterator to the end of the string.

Returns

An iterator to the end of the string.

Definition at line 2788 of file irrUString.h.

        {
                const_iterator i(*this, 0);
                i.toEnd();
                return i;
        }

empty()

template<typename TAlloc = irrAllocator<uchar16_t>>

bool irr::core::ustring16< TAlloc >::empty ( ) const

inline

Informs if the ustring is empty or not.

Returns

True if the ustring is empty, false if not.

Definition at line 1306 of file irrUString.h.

        {
                return (size_raw() == 0);
        }

end() [1/2]

template<typename TAlloc = irrAllocator<uchar16_t>>

iterator irr::core::ustring16< TAlloc >::end ( )

inline

Returns an iterator to the end of the string.

Returns

An iterator to the end of the string.

Definition at line 2768 of file irrUString.h.

        {
                iterator i(*this, 0);
                i.toEnd();
                return i;
        }

end() [2/2]

template<typename TAlloc = irrAllocator<uchar16_t>>

const_iterator irr::core::ustring16< TAlloc >::end ( ) const

inline

Returns an iterator to the end of the string.

Returns

An iterator to the end of the string.

Definition at line 2778 of file irrUString.h.

        {
                const_iterator i(*this, 0);
                i.toEnd();
                return i;
        }

equalsn() [1/2]

template<typename TAlloc = irrAllocator<uchar16_t>>

bool irr::core::ustring16< TAlloc >::equalsn ( const ustring16< TAlloc > &  other, size_t  n  ) const

inline

Compares the first n characters of this string with another.

Parameters

other	Other string to compare to.
n	Number of characters to compare.

Returns

True if the n first characters of both strings are equal.

Definition at line 1324 of file irrUString.h.

        {
                size_t i;
                const uchar16_t* oa = other.c_str();
                for(i=0; array[i] && oa[i] && i < n; ++i)
                        if (array[i] != oa[i])
                                return false;

                // if one (or both) of the strings was smaller then they
                // are only equal if they have the same length
                return (i == n) || (used == other.used);
        }

equalsn() [2/2]

template<typename TAlloc = irrAllocator<uchar16_t>>

bool irr::core::ustring16< TAlloc >::equalsn ( const uchar16_t *const  str, size_t  n  ) const

inline

Compares the first n characters of this string with another.

Parameters

str	Other string to compare to.
n	Number of characters to compare.

Returns

True if the n first characters of both strings are equal.

Definition at line 1342 of file irrUString.h.

        {
                if (!str)
                        return false;
                size_t i;
                for(i=0; array[i] && str[i] && i < n; ++i)
                        if (array[i] != str[i])
                                return false;

                // if one (or both) of the strings was smaller then they
                // are only equal if they have the same length
                return (i == n) || (array[i] == 0 && str[i] == 0);
        }

erase()

template<typename TAlloc = irrAllocator<uchar16_t>>

ustring16<TAlloc>& irr::core::ustring16< TAlloc >::erase ( size_t  index )

inline

Erases a character from the ustring16. May be slow, because all elements following after the erased element have to be copied.

Parameters

index

Index of element to be erased.

Returns

A reference to our current string.

Definition at line 2447 of file irrUString.h.

        {
                _IRR_DEBUG_BREAK_IF(index>used) // access violation

                iterator i(*this, index);

                uchar32_t t = *i;
                size_t len = (t > 0xFFFF ? 2 : 1);

                for (size_t j = i.getPos() + len; j <= used; ++j)
                        array[j - len] = array[j];

                used -= len;
                array[used] = 0;

                return *this;
        }

erase_raw()

template<typename TAlloc = irrAllocator<uchar16_t>>

ustring16<TAlloc>& irr::core::ustring16< TAlloc >::erase_raw ( size_t  pos )

inline

Removes a character from string.

Parameters

pos	Position of the character to remove.

Returns

A reference to our current string.

Definition at line 2716 of file irrUString.h.

        {
                for (size_t i=pos; i<=used; ++i)
                {
                        array[i] = array[i + 1];
                }
                --used;
                array[used] = 0;
                return *this;
        }

find()

template<typename TAlloc = irrAllocator<uchar16_t>>

size_t irr::core::ustring16< TAlloc >::find ( const ustring16< TAlloc > &  str, const size_t  start = 0  ) const

inline

Finds another ustring16 in this ustring16.

Parameters

str	The string to find.
start	The start position of the search.

Returns

Positions where the ustring16 has been found, or ustring::npos if not found.

Definition at line 1956 of file irrUString.h.

        {
                size_t my_size = size();
                size_t their_size = str.size();

                if (their_size == 0 || my_size - start < their_size)
                        return ustring16<TAlloc>::npos;

                const_iterator i(*this, start);

                size_t pos = start;
                while (!i.atEnd())
                {
                        const_iterator i2(i);
                        const_iterator j(str, 0);
                        uchar32_t t1 = (uchar32_t)*i2;
                        uchar32_t t2 = (uchar32_t)*j;
                        while (t1 == t2)
                        {
                                ++i2;
                                ++j;
                                if (j.atEnd())
                                        return pos;
                                t1 = (uchar32_t)*i2;
                                t2 = (uchar32_t)*j;
                        }
                        ++i;
                        ++pos;
                }

                return ustring16<TAlloc>::npos;
        }

find_raw()

template<typename TAlloc = irrAllocator<uchar16_t>>

size_t irr::core::ustring16< TAlloc >::find_raw ( const ustring16< TAlloc > &  str, const size_t  start = 0  ) const

inline

Finds another ustring16 in this ustring16.

Parameters

str	The string to find.
start	The start position of the search.

Returns

Positions where the string has been found, or -1 if not found.

Definition at line 1994 of file irrUString.h.

        {
                const uchar16_t* data = str.c_str();
                if (data && *data)
                {
                        size_t len = 0;

                        while (data[len])
                                ++len;

                        if (len > used)
                                return ustring16<TAlloc>::npos;

                        for (size_t i = start; i <= used - len; ++i)
                        {
                                size_t j = 0;

                                while(data[j] && array[i+j] == data[j])
                                        ++j;

                                if (!data[j])
                                        return i;
                        }
                }

                return ustring16<TAlloc>::npos;
        }

findFirst()

template<typename TAlloc = irrAllocator<uchar16_t>>

size_t irr::core::ustring16< TAlloc >::findFirst ( uchar32_t  c ) const

inline

Finds first occurrence of character.

Parameters

c	The character to search for.

Returns

Position where the character has been found, or ustring::npos if not found.

Definition at line 1773 of file irrUString.h.

        {
                const_iterator i(*this, 0);

                size_t pos = 0;
                while (!i.atEnd())
                {
                        uchar32_t t = *i;
                        if (c == t)
                                return pos;
                        ++pos;
                        ++i;
                }

                return ustring16<TAlloc>::npos;
        }

findFirstChar()

template<typename TAlloc = irrAllocator<uchar16_t>>

size_t irr::core::ustring16< TAlloc >::findFirstChar ( const uchar32_t *const  c, size_t  count = 1  ) const

inline

Finds first occurrence of a character of a list.

Parameters

c	A list of characters to find. For example if the method should find the first occurrence of 'a' or 'b', this parameter should be "ab".
count	The amount of characters in the list. Usually, this should be strlen(c).

Returns

Position where one of the characters has been found, or ustring::npos if not found.

Definition at line 1794 of file irrUString.h.

        {
                if (!c || !count)
                        return ustring16<TAlloc>::npos;

                const_iterator i(*this, 0);

                size_t pos = 0;
                while (!i.atEnd())
                {
                        uchar32_t t = *i;
                        for (size_t j = 0; j < count; ++j)
                                if (t == c[j])
                                        return pos;
                        ++pos;
                        ++i;
                }

                return ustring16<TAlloc>::npos;
        }

findFirstCharNotInList()

template<typename TAlloc = irrAllocator<uchar16_t>>

size_t irr::core::ustring16< TAlloc >::findFirstCharNotInList ( const uchar32_t *const  c, size_t  count = 1  ) const

inline

Finds first position of a character not in a given list.

Parameters

c	A list of characters to NOT find. For example if the method should find the first occurrence of a character not 'a' or 'b', this parameter should be "ab".
count	The amount of characters in the list. Usually, this should be strlen(c).

Returns

Position where the character has been found, or ustring::npos if not found.

Definition at line 1820 of file irrUString.h.

        {
                if (!c || !count)
                        return ustring16<TAlloc>::npos;

                const_iterator i(*this, 0);

                size_t pos = 0;
                while (!i.atEnd())
                {
                        uchar32_t t = *i;
                        size_t j;
                        for (j = 0; j < count; ++j)
                                if (t == c[j])
                                        break;

                        if (j == count)
                                return pos;
                        ++pos;
                        ++i;
                }

                return ustring16<TAlloc>::npos;
        }

findLast()

template<typename TAlloc = irrAllocator<uchar16_t>>

size_t irr::core::ustring16< TAlloc >::findLast ( uchar32_t  c, size_t  start = ustring16<TAlloc>::npos  ) const

inline

Finds last occurrence of character.

Parameters

c	The character to search for.
start	The start position of the reverse search ( default = ustring::npos, on end ).

Returns

Position where the character has been found, or ustring::npos if not found.

Definition at line 1905 of file irrUString.h.

        {
                size_t s = size();
                if (start == ustring16<TAlloc>::npos)
                        start = s - 1;

                const_iterator i(*this, start);
                size_t pos = start;
                while (!i.atStart())
                {
                        uchar32_t t = *i;
                        if (t == c)
                                return pos;
                        --pos;
                        --i;
                }

                return ustring16<TAlloc>::npos;
        }

findLastChar()

template<typename TAlloc = irrAllocator<uchar16_t>>

size_t irr::core::ustring16< TAlloc >::findLastChar ( const uchar32_t *const  c, size_t  count = 1  ) const

inline

Finds last occurrence of a character in a list.

Parameters

c	A list of strings to find. For example if the method should find the last occurrence of 'a' or 'b', this parameter should be "ab".
count	The amount of characters in the list. Usually, this should be strlen(c).

Returns

Position where one of the characters has been found, or -1 if not found.

Definition at line 1929 of file irrUString.h.

        {
                if (!c || !count)
                        return ustring16<TAlloc>::npos;

                const_iterator i(end());
                --i;

                size_t pos = size();
                while (!i.atStart())
                {
                        uchar32_t t = *i;
                        for (size_t j = 0; j < count; ++j)
                                if (t == c[j])
                                        return pos;
                        --pos;
                        --i;
                }

                return ustring16<TAlloc>::npos;
        }

findLastCharNotInList()

template<typename TAlloc = irrAllocator<uchar16_t>>

size_t irr::core::ustring16< TAlloc >::findLastCharNotInList ( const uchar32_t *const  c, size_t  count = 1  ) const

inline

Finds last position of a character not in a given list.

Parameters

c	A list of characters to NOT find. For example if the method should find the first occurrence of a character not 'a' or 'b', this parameter should be "ab".
count	The amount of characters in the list. Usually, this should be strlen(c).

Returns

Position where the character has been found, or ustring::npos if not found.

Definition at line 1849 of file irrUString.h.

        {
                if (!c || !count)
                        return ustring16<TAlloc>::npos;

                const_iterator i(end());
                --i;

                size_t pos = size();
                if (pos == 0)
                        return ustring16<TAlloc>::npos;
                --pos;

                while (!i.atStart())
                {
                        uchar32_t t = *i;
                        size_t j;
                        for (j = 0; j < count; ++j)
                                if (t == c[j])
                                        break;

                        if (j == count)
                                return pos;
                        --pos;
                        --i;
                }

                return ustring16<TAlloc>::npos;
        }

findNext()

template<typename TAlloc = irrAllocator<uchar16_t>>

size_t irr::core::ustring16< TAlloc >::findNext ( uchar32_t  c, size_t  startPos  ) const

inline

Finds next occurrence of character.

Parameters

c	The character to search for.
startPos	The position in the string to start searching.

Returns

Position where the character has been found, or ustring::npos if not found.

Definition at line 1883 of file irrUString.h.

        {
                const_iterator i(*this, startPos);

                size_t pos = startPos;
                while (!i.atEnd())
                {
                        uchar32_t t = *i;
                        if (t == c)
                                return pos;
                        ++pos;
                        ++i;
                }

                return ustring16<TAlloc>::npos;
        }

getEncoding()

template<typename TAlloc = irrAllocator<uchar16_t>>

const unicode::EUTF_ENCODE irr::core::ustring16< TAlloc >::getEncoding ( ) const

inline

Gets the encoding of the Unicode string this class contains.

Returns

An enum describing the current encoding of this string.

Definition at line 3240 of file irrUString.h.

        {
                return encoding;
        }

getEndianness()

template<typename TAlloc = irrAllocator<uchar16_t>>

const unicode::EUTF_ENDIAN irr::core::ustring16< TAlloc >::getEndianness ( ) const

inline

Gets the endianness of the Unicode string this class contains.

Returns

An enum describing the endianness of this string.

Definition at line 3247 of file irrUString.h.

        {
                if (encoding == unicode::EUTFE_UTF16_LE ||
                        encoding == unicode::EUTFE_UTF32_LE)
                        return unicode::EUTFEE_LITTLE;
                else return unicode::EUTFEE_BIG;
        }

insert() [1/2]

template<typename TAlloc = irrAllocator<uchar16_t>>

ustring16<TAlloc>& irr::core::ustring16< TAlloc >::insert ( uchar32_t  c, size_t  pos  )

inline

Inserts a character into the string.

Parameters

c	The character to insert.
pos	The position to insert the character.

Returns

A reference to our current string.

Definition at line 2632 of file irrUString.h.

        {
                u8 len = (c > 0xFFFF ? 2 : 1);

                if (used + len >= allocated)
                        reallocate(used + len);

                used += len;

                iterator iter(*this, pos);
                for (size_t i = used - 2; i > iter.getPos(); --i)
                        array[i] = array[i - len];

                if (c > 0xFFFF)
                {
                        // c will be multibyte, so split it up into a surrogate pair.
                        uchar16_t x = static_cast<uchar16_t>(c);
                        uchar16_t vh = UTF16_HI_SURROGATE | ((((c >> 16) & ((1 << 5) - 1)) - 1) << 6) | (x >> 10);
                        uchar16_t vl = UTF16_LO_SURROGATE | (x & ((1 << 10) - 1));
                        array[iter.getPos()] = vh;
                        array[iter.getPos()+1] = vl;
                }
                else
                {
                        array[iter.getPos()] = static_cast<uchar16_t>(c);
                }
                array[used] = 0;
                return *this;
        }

insert() [2/2]

template<typename TAlloc = irrAllocator<uchar16_t>>

ustring16<TAlloc>& irr::core::ustring16< TAlloc >::insert ( const ustring16< TAlloc > &  c, size_t  pos  )

inline

Inserts a string into the string.

Parameters

c	The string to insert.
pos	The position to insert the string.

Returns

A reference to our current string.

Definition at line 2667 of file irrUString.h.

        {
                size_t len = c.size_raw();
                if (len == 0) return *this;

                if (used + len >= allocated)
                        reallocate(used + len);

                used += len;

                iterator iter(*this, pos);
                for (size_t i = used - 2; i > iter.getPos() + len; --i)
                        array[i] = array[i - len];

                const uchar16_t* s = c.c_str();
                for (size_t i = 0; i < len; ++i)
                {
                        array[pos++] = *s;
                        ++s;
                }

                array[used] = 0;
                return *this;
        }

insert_raw()

template<typename TAlloc = irrAllocator<uchar16_t>>

ustring16<TAlloc>& irr::core::ustring16< TAlloc >::insert_raw ( uchar16_t  c, size_t  pos  )

inline

Inserts a character into the string.

Parameters

c	The character to insert.
pos	The position to insert the character.

Returns

A reference to our current string.

Definition at line 2697 of file irrUString.h.

        {
                if (used + 1 >= allocated)
                        reallocate(used + 1);

                ++used;

                for (size_t i = used - 1; i > pos; --i)
                        array[i] = array[i - 1];

                array[pos] = c;
                array[used] = 0;
                return *this;
        }

lastChar()

template<typename TAlloc = irrAllocator<uchar16_t>>

uchar32_t irr::core::ustring16< TAlloc >::lastChar ( ) const

inline

Gets the last char of the ustring16, or 0.

Returns

The last char of the ustring16, or 0.

Definition at line 2504 of file irrUString.h.

        {
                if (used < 1)
                        return 0;

                if (UTF16_IS_SURROGATE_LO(array[used-1]))
                {
                        // Make sure we have a paired surrogate.
                        if (used < 2)
                                return 0;

                        // Check for an invalid surrogate.
                        if (!UTF16_IS_SURROGATE_HI(array[used-2]))
                                return 0;

                        // Convert the surrogate pair into a single UTF-32 character.
                        return unicode::toUTF32(array[used-2], array[used-1]);
                }
                else
                {
                        return array[used-1];
                }
        }

loadDataStream()

template<typename TAlloc = irrAllocator<uchar16_t>>

ustring16<TAlloc>& irr::core::ustring16< TAlloc >::loadDataStream ( const char *  data, size_t  data_size  )

inline

Loads an unknown stream of data. Will attempt to determine if the stream is unicode data. Useful for loading from files.

Parameters

data	The data stream to load from.
data_size	The length of the data string.

Returns

A reference to our current string.

Definition at line 3207 of file irrUString.h.

        {
                // Clear our string.
                *this = "";
                if (!data)
                        return *this;

                unicode::EUTF_ENCODE e = unicode::determineUnicodeBOM(data);
                switch (e)
                {
                        default:
                        case unicode::EUTFE_UTF8:
                                append((uchar8_t*)data, data_size);
                                break;

                        case unicode::EUTFE_UTF16:
                        case unicode::EUTFE_UTF16_BE:
                        case unicode::EUTFE_UTF16_LE:
                                append((uchar16_t*)data, data_size / 2);
                                break;

                        case unicode::EUTFE_UTF32:
                        case unicode::EUTFE_UTF32_BE:
                        case unicode::EUTFE_UTF32_LE:
                                append((uchar32_t*)data, data_size / 4);
                                break;
                }

                return *this;
        }

operator !=() [1/2]

template<typename TAlloc = irrAllocator<uchar16_t>>

bool irr::core::ustring16< TAlloc >::operator != ( const uchar16_t *const  str ) const

inline

Inequality operator.

Definition at line 1276 of file irrUString.h.

        {
                return !(*this == str);
        }

operator !=() [2/2]

template<typename TAlloc = irrAllocator<uchar16_t>>

bool irr::core::ustring16< TAlloc >::operator != ( const ustring16< TAlloc > &  other ) const

inline

Inequality operator.

Definition at line 1283 of file irrUString.h.

        {
                return !(*this == other);
        }

operator []() [1/2]

template<typename TAlloc = irrAllocator<uchar16_t>>

access irr::core::ustring16< TAlloc >::operator [] ( const size_t  index )

inline

Direct access operator.

Definition at line 1218 of file irrUString.h.

        {
                _IRR_DEBUG_BREAK_IF(index>=size()) // bad index
                iterator iter(*this, index);
                return iter.operator*();
        }

operator []() [2/2]

template<typename TAlloc = irrAllocator<uchar16_t>>

const access irr::core::ustring16< TAlloc >::operator [] ( const size_t  index ) const

inline

Direct access operator.

Definition at line 1227 of file irrUString.h.

        {
                _IRR_DEBUG_BREAK_IF(index>=size()) // bad index
                const_iterator iter(*this, index);
                return iter.operator*();
        }

operator+=() [1/9]

template<typename TAlloc = irrAllocator<uchar16_t>>

ustring16<TAlloc>& irr::core::ustring16< TAlloc >::operator+= ( char  c )

inline

Appends a character to this ustring16.

Parameters

c	Character to append.

Returns

A reference to our current string.

Definition at line 2064 of file irrUString.h.

        {
                append((uchar32_t)c);
                return *this;
        }

operator+=() [2/9]

template<typename TAlloc = irrAllocator<uchar16_t>>

ustring16<TAlloc>& irr::core::ustring16< TAlloc >::operator+= ( uchar32_t  c )

inline

Appends a character to this ustring16.

Parameters

c	Character to append.

Returns

A reference to our current string.

Definition at line 2074 of file irrUString.h.

        {
                append(c);
                return *this;
        }

operator+=() [3/9]

template<typename TAlloc = irrAllocator<uchar16_t>>

ustring16<TAlloc>& irr::core::ustring16< TAlloc >::operator+= ( short  c )

inline

Appends a number to this ustring16.

Parameters

c	Number to append.

Returns

A reference to our current string.

Definition at line 2084 of file irrUString.h.

        {
                append(core::stringc(c));
                return *this;
        }

operator+=() [4/9]

template<typename TAlloc = irrAllocator<uchar16_t>>

ustring16<TAlloc>& irr::core::ustring16< TAlloc >::operator+= ( unsigned short  c )

inline

Appends a number to this ustring16.

Parameters

c	Number to append.

Returns

A reference to our current string.

Definition at line 2094 of file irrUString.h.

        {
                append(core::stringc(c));
                return *this;
        }

operator+=() [5/9]

template<typename TAlloc = irrAllocator<uchar16_t>>

ustring16<TAlloc>& irr::core::ustring16< TAlloc >::operator+= ( long  c )

inline

Appends a number to this ustring16.

Parameters

c	Number to append.

Returns

A reference to our current string.

Definition at line 2126 of file irrUString.h.

        {
                append(core::stringc(c));
                return *this;
        }

operator+=() [6/9]

template<typename TAlloc = irrAllocator<uchar16_t>>

ustring16<TAlloc>& irr::core::ustring16< TAlloc >::operator+= ( unsigned long  c )

inline

Appends a number to this ustring16.

Parameters

c	Number to append.

Returns

A reference to our current string.

Definition at line 2136 of file irrUString.h.

        {
                append(core::stringc(c));
                return *this;
        }

operator+=() [7/9]

template<typename TAlloc = irrAllocator<uchar16_t>>

ustring16<TAlloc>& irr::core::ustring16< TAlloc >::operator+= ( double  c )

inline

Appends a number to this ustring16.

Parameters

c	Number to append.

Returns

A reference to our current string.

Definition at line 2146 of file irrUString.h.

        {
                append(core::stringc(c));
                return *this;
        }

operator+=() [8/9]

template<typename TAlloc = irrAllocator<uchar16_t>>

ustring16<TAlloc>& irr::core::ustring16< TAlloc >::operator+= ( const uchar16_t *const  c )

inline

Appends a char ustring16 to this ustring16.

Parameters

c	Char ustring16 to append.

Returns

A reference to our current string.

Definition at line 2156 of file irrUString.h.

        {
                append(c);
                return *this;
        }

operator+=() [9/9]

template<typename TAlloc = irrAllocator<uchar16_t>>

ustring16<TAlloc>& irr::core::ustring16< TAlloc >::operator+= ( const ustring16< TAlloc > &  other )

inline

Appends a ustring16 to this ustring16.

Parameters

other

ustring16 to append.

Returns

A reference to our current string.

Definition at line 2166 of file irrUString.h.

        {
                append(other);
                return *this;
        }

operator<()

template<typename TAlloc = irrAllocator<uchar16_t>>

bool irr::core::ustring16< TAlloc >::operator< ( const ustring16< TAlloc > &  other ) const

inline

Is smaller comparator.

Definition at line 1262 of file irrUString.h.

        {
                for (size_t i=0; array[i] && other.array[i]; ++i)
                {
                        if (array[i] == other.array[i])
                                continue;
                        return array[i] < other.array[i];
                }

                return used < other.used;
        }

operator=() [1/7]

template<typename TAlloc = irrAllocator<uchar16_t>>

ustring16& irr::core::ustring16< TAlloc >::operator= ( const ustring16< TAlloc > &  other )

inline

Assignment operator.

Definition at line 1074 of file irrUString.h.

        {
                if (this == &other)
                        return *this;

                used = other.size_raw();
                if (used >= allocated)
                {
                        allocator.deallocate(array); // delete [] array;
                        allocated = used + 1;
                        array = allocator.allocate(used + 1); //new u16[used];
                }

                const uchar16_t* p = other.c_str();
                for (size_t i=0; i<=used; ++i, ++p)
                        array[i] = *p;

                array[used] = 0;

                // Validate our new UTF-16 string.
                validate();

                return *this;
        }

operator=() [2/7]

template<typename TAlloc = irrAllocator<uchar16_t>>

template<class B , class A >

ustring16<TAlloc>& irr::core::ustring16< TAlloc >::operator= ( const string< B, A > &  other )

inline

Assignment operator for other string types.

Definition at line 1123 of file irrUString.h.

        {
                *this = other.c_str();
                return *this;
        }

operator=() [3/7]

template<typename TAlloc = irrAllocator<uchar16_t>>

ustring16<TAlloc>& irr::core::ustring16< TAlloc >::operator= ( const uchar8_t *const  c )

inline

Assignment operator for UTF-8 strings.

Append our string now.

Definition at line 1131 of file irrUString.h.

        {
                if (!array)
                {
                        array = allocator.allocate(1); //new u16[1];
                        allocated = 1;
                }
                used = 0;
                array[used] = 0x0;
                if (!c) return *this;

                append(c);
                return *this;
        }

operator=() [4/7]

template<typename TAlloc = irrAllocator<uchar16_t>>

ustring16<TAlloc>& irr::core::ustring16< TAlloc >::operator= ( const uchar16_t *const  c )

inline

Assignment operator for UTF-16 strings.

Append our string now.

Definition at line 1149 of file irrUString.h.

        {
                if (!array)
                {
                        array = allocator.allocate(1); //new u16[1];
                        allocated = 1;
                }
                used = 0;
                array[used] = 0x0;
                if (!c) return *this;

                append(c);
                return *this;
        }

operator=() [5/7]

template<typename TAlloc = irrAllocator<uchar16_t>>

ustring16<TAlloc>& irr::core::ustring16< TAlloc >::operator= ( const uchar32_t *const  c )

inline

Assignment operator for UTF-32 strings.

Append our string now.

Definition at line 1167 of file irrUString.h.

        {
                if (!array)
                {
                        array = allocator.allocate(1); //new u16[1];
                        allocated = 1;
                }
                used = 0;
                array[used] = 0x0;
                if (!c) return *this;

                append(c);
                return *this;
        }

operator=() [6/7]

template<typename TAlloc = irrAllocator<uchar16_t>>

ustring16<TAlloc>& irr::core::ustring16< TAlloc >::operator= ( const wchar_t *const  c )

inline

Assignment operator for wchar_t strings.

Note that this assumes that a correct unicode string is stored in the wchar_t string. Since wchar_t changes depending on its platform, it could either be a UTF-8, -16, or -32 string. This function assumes you are storing the correct unicode encoding inside the wchar_t string.

Definition at line 1188 of file irrUString.h.

        {
                if (sizeof(wchar_t) == 4)
                        *this = reinterpret_cast<const uchar32_t* const>(c);
                else if (sizeof(wchar_t) == 2)
                        *this = reinterpret_cast<const uchar16_t* const>(c);
                else if (sizeof(wchar_t) == 1)
                        *this = reinterpret_cast<const uchar8_t* const>(c);

                return *this;
        }

operator=() [7/7]

template<typename TAlloc = irrAllocator<uchar16_t>>

template<class B >

ustring16<TAlloc>& irr::core::ustring16< TAlloc >::operator= ( const B *const  c )

inline

Assignment operator for other strings.

Note that this assumes that a correct unicode string is stored in the string.

Definition at line 1204 of file irrUString.h.

        {
                if (sizeof(B) == 4)
                        *this = reinterpret_cast<const uchar32_t* const>(c);
                else if (sizeof(B) == 2)
                        *this = reinterpret_cast<const uchar16_t* const>(c);
                else if (sizeof(B) == 1)
                        *this = reinterpret_cast<const uchar8_t* const>(c);

                return *this;
        }

operator==() [1/2]

template<typename TAlloc = irrAllocator<uchar16_t>>

bool irr::core::ustring16< TAlloc >::operator== ( const uchar16_t *const  str ) const

inline

Equality operator.

Definition at line 1236 of file irrUString.h.

        {
                if (!str)
                        return false;

                size_t i;
                for (i=0; array[i] && str[i]; ++i)
                        if (array[i] != str[i])
                                return false;

                return !array[i] && !str[i];
        }

operator==() [2/2]

template<typename TAlloc = irrAllocator<uchar16_t>>

bool irr::core::ustring16< TAlloc >::operator== ( const ustring16< TAlloc > &  other ) const

inline

Equality operator.

Definition at line 1251 of file irrUString.h.

        {
                for (size_t i=0; array[i] && other.array[i]; ++i)
                        if (array[i] != other.array[i])
                                return false;

                return used == other.used;
        }

remove() [1/2]

template<typename TAlloc = irrAllocator<uchar16_t>>

ustring16<TAlloc>& irr::core::ustring16< TAlloc >::remove ( uchar32_t  c )

inline

Removes characters from a ustring16..

Parameters

c	The character to remove.

Returns

A reference to our current string.

Definition at line 2306 of file irrUString.h.

        {
                size_t pos = 0;
                size_t found = 0;
                size_t len = (c > 0xFFFF ? 2 : 1);              // Remove characters equal to the size of c as a UTF-16 character.
                for (size_t i=0; i<=used; ++i)
                {
                        uchar32_t uc32 = 0;
                        if (!UTF16_IS_SURROGATE_HI(array[i]))
                                uc32 |= array[i];
                        else if (i + 1 <= used)
                        {
                                // Convert the surrogate pair into a single UTF-32 character.
                                uc32 = unicode::toUTF32(array[i], array[i + 1]);
                        }
                        size_t len2 = (uc32 > 0xFFFF ? 2 : 1);

                        if (uc32 == c)
                        {
                                found += len;
                                continue;
                        }

                        array[pos++] = array[i];
                        if (len2 == 2)
                                array[pos++] = array[++i];
                }
                used -= found;
                array[used] = 0;
                return *this;
        }

remove() [2/2]

template<typename TAlloc = irrAllocator<uchar16_t>>

ustring16<TAlloc>& irr::core::ustring16< TAlloc >::remove ( const ustring16< TAlloc > &  toRemove )

inline

Removes a ustring16 from the ustring16.

Parameters

toRemove

The string to remove.

Returns

A reference to our current string.

Definition at line 2342 of file irrUString.h.

        {
                size_t size = toRemove.size_raw();
                if (size == 0) return *this;

                const uchar16_t* tra = toRemove.c_str();
                size_t pos = 0;
                size_t found = 0;
                for (size_t i=0; i<=used; ++i)
                {
                        size_t j = 0;
                        while (j < size)
                        {
                                if (array[i + j] != tra[j])
                                        break;
                                ++j;
                        }
                        if (j == size)
                        {
                                found += size;
                                i += size - 1;
                                continue;
                        }

                        array[pos++] = array[i];
                }
                used -= found;
                array[used] = 0;
                return *this;
        }

removeChars()

template<typename TAlloc = irrAllocator<uchar16_t>>

ustring16<TAlloc>& irr::core::ustring16< TAlloc >::removeChars ( const ustring16< TAlloc > &  characters )

inline

Removes characters from the ustring16.

Parameters

characters

The characters to remove.

Returns

A reference to our current string.

Definition at line 2377 of file irrUString.h.

        {
                if (characters.size_raw() == 0)
                        return *this;

                size_t pos = 0;
                size_t found = 0;
                const_iterator iter(characters);
                for (size_t i=0; i<=used; ++i)
                {
                        uchar32_t uc32 = 0;
                        if (!UTF16_IS_SURROGATE_HI(array[i]))
                                uc32 |= array[i];
                        else if (i + 1 <= used)
                        {
                                // Convert the surrogate pair into a single UTF-32 character.
                                uc32 = unicode::toUTF32(array[i], array[i+1]);
                        }
                        size_t len2 = (uc32 > 0xFFFF ? 2 : 1);

                        bool cont = false;
                        iter.toStart();
                        while (!iter.atEnd())
                        {
                                uchar32_t c = *iter;
                                if (uc32 == c)
                                {
                                        found += (c > 0xFFFF ? 2 : 1);          // Remove characters equal to the size of c as a UTF-16 character.
                                        ++i;
                                        cont = true;
                                        break;
                                }
                                ++iter;
                        }
                        if (cont) continue;

                        array[pos++] = array[i];
                        if (len2 == 2)
                                array[pos++] = array[++i];
                }
                used -= found;
                array[used] = 0;
                return *this;
        }

replace() [1/2]

template<typename TAlloc = irrAllocator<uchar16_t>>

ustring16<TAlloc>& irr::core::ustring16< TAlloc >::replace ( uchar32_t  toReplace, uchar32_t  replaceWith  )

inline

Replaces all characters of a given type with another one.

Parameters

toReplace	Character to replace.
replaceWith	Character replacing the old one.

Returns

A reference to our current string.

Definition at line 2177 of file irrUString.h.

        {
                iterator i(*this, 0);
                while (!i.atEnd())
                {
                        typename ustring16<TAlloc>::access a = *i;
                        if ((uchar32_t)a == toReplace)
                                a = replaceWith;
                        ++i;
                }
                return *this;
        }

replace() [2/2]

template<typename TAlloc = irrAllocator<uchar16_t>>

ustring16<TAlloc>& irr::core::ustring16< TAlloc >::replace ( const ustring16< TAlloc > &  toReplace, const ustring16< TAlloc > &  replaceWith  )

inline

Replaces all instances of a string with another one.

Parameters

toReplace	The string to replace.
replaceWith	The string replacing the old one.

Returns

A reference to our current string.

Definition at line 2195 of file irrUString.h.

        {
                if (toReplace.size() == 0)
                        return *this;

                const uchar16_t* other = toReplace.c_str();
                const uchar16_t* replace = replaceWith.c_str();
                const size_t other_size = toReplace.size_raw();
                const size_t replace_size = replaceWith.size_raw();

                // A character for character replace.  The string will not shrink or grow.
                if (replace_size == other_size)
                {
                        size_t pos = 0;
                        while ((pos = find_raw(other, pos)) != ustring16<TAlloc>::npos)
                        {
                                for (size_t i = 0; i < replace_size; ++i)
                                        array[pos + i] = replace[i];
                                ++pos;
                        }
                        return *this;
                }

                // We are going to be removing some characters.  The string will shrink.
                if (replace_size < other_size)
                {
                        size_t i = 0;
                        for (size_t pos = 0; pos <= used; ++i, ++pos)
                        {
                                // Is this potentially a match?
                                if (array[pos] == *other)
                                {
                                        // Check to see if we have a match.
                                        size_t j;
                                        for (j = 0; j < other_size; ++j)
                                        {
                                                if (array[pos + j] != other[j])
                                                        break;
                                        }

                                        // If we have a match, replace characters.
                                        if (j == other_size)
                                        {
                                                for (j = 0; j < replace_size; ++j)
                                                        array[i + j] = replace[j];
                                                i += replace_size - 1;
                                                pos += other_size - 1;
                                                continue;
                                        }
                                }

                                // No match found, just copy characters.
                                array[i - 1] = array[pos];
                        }
                        array[i] = 0;
                        used = i;

                        return *this;
                }
                
                // Determine the delta.
                size_t delta = replace_size - other_size;

                // We are going to be adding characters, so the string size will increase.
                // Count the number of times toReplace exists in the string so we can allocate the new size.
                size_t find_count = 0;
                size_t pos = 0;
                while ((pos = find_raw(other, pos)) != ustring16<TAlloc>::npos)
                {
                        ++find_count;
                        ++pos;
                }

                // Re-allocate the string now, if needed.
                size_t len = delta * find_count;
                if (used + len >= allocated)
                        reallocate(used + len);

                // Start replacing.
                pos = 0;
                while ((pos = find_raw(other, pos)) != ustring16<TAlloc>::npos)
                {
                        uchar16_t* start = array + pos + other_size - 1;
                        uchar16_t* ptr   = array + used;
                        uchar16_t* end   = array + used + delta;

                        // Shift characters to make room for the string.
                        while (ptr != start)
                        {
                                *end = *ptr;
                                --ptr;
                                --end;
                        }

                        // Add the new string now.
                        for (size_t i = 0; i < replace_size; ++i)
                                array[pos + i] = replace[i];

                        pos += replace_size;
                        used += delta;
                }

                // Terminate the string and return ourself.
                array[used] = 0;
                return *this;
        }

replace_raw()

template<typename TAlloc = irrAllocator<uchar16_t>>

ustring16<TAlloc>& irr::core::ustring16< TAlloc >::replace_raw ( uchar16_t  c, size_t  pos  )

inline

Replaces a character in the string.

Parameters

c	The new character.
pos	The position of the character to replace.

Returns

A reference to our current string.

Definition at line 2732 of file irrUString.h.

        {
                array[pos] = c;
                return *this;
        }

reserve()

template<typename TAlloc = irrAllocator<uchar16_t>>

void irr::core::ustring16< TAlloc >::reserve ( size_t  count )

inline

Reserves some memory.

Parameters

count

The amount of characters to reserve.

Definition at line 1761 of file irrUString.h.

        {
                if (count < allocated)
                        return;

                reallocate(count);
        }

size()

template<typename TAlloc = irrAllocator<uchar16_t>>

size_t irr::core::ustring16< TAlloc >::size ( ) const

inline

Returns the length of a ustring16 in full characters.

Returns

Length of a ustring16 in full characters.

Definition at line 1291 of file irrUString.h.

        {
                const_iterator i(*this, 0);
                size_t pos = 0;
                while (!i.atEnd())
                {
                        ++i;
                        ++pos;
                }
                return pos;
        }

size_raw()

template<typename TAlloc = irrAllocator<uchar16_t>>

size_t irr::core::ustring16< TAlloc >::size_raw ( ) const

inline

Returns the raw number of UTF-16 code points in the string which includes the individual surrogates.

Returns

The raw number of UTF-16 code points, excluding the trialing NUL.

Definition at line 2622 of file irrUString.h.

        {
                return used;
        }

split() [1/2]

template<typename TAlloc = irrAllocator<uchar16_t>>

template<class container >

size_t irr::core::ustring16< TAlloc >::split ( container &  ret, const uchar32_t *const  c, size_t  count = 1, bool  ignoreEmptyTokens = true, bool  keepSeparators = false  ) const

inline

Split the ustring16 into parts.

This method will split a ustring16 at certain delimiter characters into the container passed in as reference. The type of the container has to be given as template parameter. It must provide a push_back and a size method.

Parameters

ret	The result container
c	C-style ustring16 of delimiter characters
count	Number of delimiter characters
ignoreEmptyTokens	Flag to avoid empty substrings in the result container. If two delimiters occur without a character in between, an empty substring would be placed in the result. If this flag is set, only non-empty strings are stored.
keepSeparators	Flag which allows to add the separator to the result ustring16. If this flag is true, the concatenation of the substrings results in the original ustring16. Otherwise, only the characters between the delimiters are returned.

Returns

The number of resulting substrings

Definition at line 2548 of file irrUString.h.

        {
                if (!c)
                        return 0;

                const_iterator i(*this);
                const size_t oldSize=ret.size();
                size_t pos = 0;
                size_t lastpos = 0;
                size_t lastpospos = 0;
                bool lastWasSeparator = false;
                while (!i.atEnd())
                {
                        uchar32_t ch = *i;
                        bool foundSeparator = false;
                        for (size_t j=0; j<count; ++j)
                        {
                                if (ch == c[j])
                                {
                                        if ((!ignoreEmptyTokens || pos - lastpos != 0) &&
                                                        !lastWasSeparator)
                                        ret.push_back(ustring16<TAlloc>(&array[lastpospos], pos - lastpos));
                                        foundSeparator = true;
                                        lastpos = (keepSeparators ? pos : pos + 1);
                                        lastpospos = (keepSeparators ? i.getPos() : i.getPos() + 1);
                                        break;
                                }
                        }
                        lastWasSeparator = foundSeparator;
                        ++pos;
                        ++i;
                }
                size_t s = size() + 1;
                if (s > lastpos)
                        ret.push_back(ustring16<TAlloc>(&array[lastpospos], s - lastpos));
                return ret.size()-oldSize;
        }

split() [2/2]

template<typename TAlloc = irrAllocator<uchar16_t>>

template<class container >

size_t irr::core::ustring16< TAlloc >::split ( container &  ret, const ustring16< TAlloc > &  c, bool  ignoreEmptyTokens = true, bool  keepSeparators = false  ) const

inline

Split the ustring16 into parts.

This method will split a ustring16 at certain delimiter characters into the container passed in as reference. The type of the container has to be given as template parameter. It must provide a push_back and a size method.

Parameters

ret	The result container
c	A unicode string of delimiter characters
ignoreEmptyTokens	Flag to avoid empty substrings in the result container. If two delimiters occur without a character in between, an empty substring would be placed in the result. If this flag is set, only non-empty strings are stored.
keepSeparators	Flag which allows to add the separator to the result ustring16. If this flag is true, the concatenation of the substrings results in the original ustring16. Otherwise, only the characters between the delimiters are returned.

Returns

The number of resulting substrings

Definition at line 2605 of file irrUString.h.

        {
                core::array<uchar32_t> v = c.toUTF32();
                return split(ret, v.pointer(), v.size(), ignoreEmptyTokens, keepSeparators);
        }

subString()

template<typename TAlloc = irrAllocator<uchar16_t>>

ustring16<TAlloc> irr::core::ustring16< TAlloc >::subString ( size_t  begin, size_t  length  ) const

inline

Returns a substring.

Parameters

begin	Start of substring.
length	Length of substring.

Returns

A reference to our current string.

Definition at line 2027 of file irrUString.h.

        {
                size_t len = size();

                // Check our inputs to see if we can exit early.
                if ((length == 0) || (begin>=len))
                        return ustring16<TAlloc>("");

                // Clamp to maximum value.
                if (length == ustring16<TAlloc>::npos)
                        length = len - begin;

                // TODO: Check for near overflow values.
                //if (begin > ustring16<TAlloc>::npos - length)
                
                // Clamp to the string length.
                if ((length + begin) > len)
                        length = len - begin;

                ustring16<TAlloc> o;
                o.reserve((length+1) * 2);

                const_iterator i(*this, begin);
                while (!i.atEnd() && length)
                {
                        o.append(*i);
                        ++i;
                        --length;
                }

                return o;
        }

toPATH_s()

template<typename TAlloc = irrAllocator<uchar16_t>>

io::path irr::core::ustring16< TAlloc >::toPATH_s ( const unicode::EUTF_ENDIAN  endian = unicode::EUTFEE_NATIVE, const bool  addBOM = false  ) const

inline

Converts the string to a properly encoded io::path string.

Parameters

endian	The desired endianness of the string.
addBOM	If true, the proper unicode byte-order mark will be prefixed to the string.

Returns

An io::path string containing the properly encoded string.

Definition at line 3193 of file irrUString.h.

        {
#if defined(_IRR_WCHAR_FILESYSTEM)
                return toWCHAR_s(endian, addBOM);
#else
                return toUTF8_s(addBOM);
#endif
        }

toUTF16()

template<typename TAlloc = irrAllocator<uchar16_t>>

core::array<uchar16_t> irr::core::ustring16< TAlloc >::toUTF16 ( const unicode::EUTF_ENDIAN  endian = unicode::EUTFEE_NATIVE, const bool  addBOM = false  ) const

inline

Converts the string to a UTF-16 encoded string array. Unfortunately, no toUTF16_s() version exists due to limitations with Irrlicht's string class.

Parameters

endian	The desired endianness of the string.
addBOM	If true, the proper unicode byte-order mark will be prefixed to the string.

Returns

An array containing the UTF-16 encoded string.

Definition at line 2956 of file irrUString.h.

        {
                core::array<uchar16_t> ret(used + (addBOM ? unicode::BOM_UTF16_LEN : 0) + 1);
                uchar16_t* ptr = ret.pointer();

                // Add the BOM if specified.
                if (addBOM)
                {
                        if (endian == unicode::EUTFEE_NATIVE)
                                *ptr = unicode::BOM;
                        else if (endian == unicode::EUTFEE_LITTLE)
                        {
                                uchar8_t* ptr8 = reinterpret_cast<uchar8_t*>(ptr);
                                *ptr8++ = unicode::BOM_ENCODE_UTF16_LE[0];
                                *ptr8 = unicode::BOM_ENCODE_UTF16_LE[1];
                        }
                        else
                        {
                                uchar8_t* ptr8 = reinterpret_cast<uchar8_t*>(ptr);
                                *ptr8++ = unicode::BOM_ENCODE_UTF16_BE[0];
                                *ptr8 = unicode::BOM_ENCODE_UTF16_BE[1];
                        }
                        ++ptr;
                }

                memcpy((void*)ptr, (void*)array, used * sizeof(uchar16_t));
                if (endian != unicode::EUTFEE_NATIVE && getEndianness() != endian)
                {
                        for (size_t i = 0; i <= used; ++i)
                                *ptr++ = unicode::swapEndian16(*ptr);
                }
                ret.set_used(used + (addBOM ? unicode::BOM_UTF16_LEN : 0));
                ret.push_back(0);
                return ret;
        }

toUTF32()

template<typename TAlloc = irrAllocator<uchar16_t>>

core::array<uchar32_t> irr::core::ustring16< TAlloc >::toUTF32 ( const unicode::EUTF_ENDIAN  endian = unicode::EUTFEE_NATIVE, const bool  addBOM = false  ) const

inline

Converts the string to a UTF-32 encoded string array. Unfortunately, no toUTF32_s() version exists due to limitations with Irrlicht's string class.

Parameters

endian	The desired endianness of the string.
addBOM	If true, the proper unicode byte-order mark will be prefixed to the string.

Returns

An array containing the UTF-32 encoded string.

Definition at line 3053 of file irrUString.h.

        {
                core::array<uchar32_t> ret(size() + (addBOM ? unicode::BOM_UTF32_LEN : 0) + 1);
                const_iterator iter(*this, 0);

                // Add the BOM if specified.
                if (addBOM)
                {
                        if (endian == unicode::EUTFEE_NATIVE)
                                ret.push_back(unicode::BOM);
                        else
                        {
                                union
                                {
                                        uchar32_t full;
                                        u8 chunk[4];
                                } t;

                                if (endian == unicode::EUTFEE_LITTLE)
                                {
                                        t.chunk[0] = unicode::BOM_ENCODE_UTF32_LE[0];
                                        t.chunk[1] = unicode::BOM_ENCODE_UTF32_LE[1];
                                        t.chunk[2] = unicode::BOM_ENCODE_UTF32_LE[2];
                                        t.chunk[3] = unicode::BOM_ENCODE_UTF32_LE[3];
                                }
                                else
                                {
                                        t.chunk[0] = unicode::BOM_ENCODE_UTF32_BE[0];
                                        t.chunk[1] = unicode::BOM_ENCODE_UTF32_BE[1];
                                        t.chunk[2] = unicode::BOM_ENCODE_UTF32_BE[2];
                                        t.chunk[3] = unicode::BOM_ENCODE_UTF32_BE[3];
                                }
                                ret.push_back(t.full);
                        }
                }
                ret.push_back(0);

                while (!iter.atEnd())
                {
                        uchar32_t c = *iter;
                        if (endian != unicode::EUTFEE_NATIVE && getEndianness() != endian)
                                c = unicode::swapEndian32(c);
                        ret.push_back(c);
                        ++iter;
                }
                return ret;
        }

toUTF8()

template<typename TAlloc = irrAllocator<uchar16_t>>

core::array<uchar8_t> irr::core::ustring16< TAlloc >::toUTF8 ( const bool  addBOM = false ) const

inline

Converts the string to a UTF-8 encoded string array.

Parameters

addBOM

If true, the proper unicode byte-order mark will be prefixed to the string.

Returns

An array containing the UTF-8 encoded string.

Definition at line 2856 of file irrUString.h.

        {
                core::array<uchar8_t> ret(used * 4 + (addBOM ? unicode::BOM_UTF8_LEN : 0) + 1);
                const_iterator iter(*this, 0);

                // Add the byte order mark if the user wants it.
                if (addBOM)
                {
                        ret.push_back(unicode::BOM_ENCODE_UTF8[0]);
                        ret.push_back(unicode::BOM_ENCODE_UTF8[1]);
                        ret.push_back(unicode::BOM_ENCODE_UTF8[2]);
                }

                while (!iter.atEnd())
                {
                        uchar32_t c = *iter;
                        if (c > 0xFFFF)
                        {       // 4 bytes
                                uchar8_t b1 = (0x1E << 3) | ((c >> 18) & 0x7);
                                uchar8_t b2 = (0x2 << 6) | ((c >> 12) & 0x3F);
                                uchar8_t b3 = (0x2 << 6) | ((c >> 6) & 0x3F);
                                uchar8_t b4 = (0x2 << 6) | (c & 0x3F);
                                ret.push_back(b1);
                                ret.push_back(b2);
                                ret.push_back(b3);
                                ret.push_back(b4);
                        }
                        else if (c > 0x7FF)
                        {       // 3 bytes
                                uchar8_t b1 = (0xE << 4) | ((c >> 12) & 0xF);
                                uchar8_t b2 = (0x2 << 6) | ((c >> 6) & 0x3F);
                                uchar8_t b3 = (0x2 << 6) | (c & 0x3F);
                                ret.push_back(b1);
                                ret.push_back(b2);
                                ret.push_back(b3);
                        }
                        else if (c > 0x7F)
                        {       // 2 bytes
                                uchar8_t b1 = (0x6 << 5) | ((c >> 6) & 0x1F);
                                uchar8_t b2 = (0x2 << 6) | (c & 0x3F);
                                ret.push_back(b1);
                                ret.push_back(b2);
                        }
                        else
                        {       // 1 byte
                                ret.push_back(static_cast<uchar8_t>(c));
                        }
                        ++iter;
                }
                ret.push_back(0);
                return ret;
        }

toUTF8_s()

template<typename TAlloc = irrAllocator<uchar16_t>>

core::string<uchar8_t> irr::core::ustring16< TAlloc >::toUTF8_s ( const bool  addBOM = false ) const

inline

Converts the string to a UTF-8 encoded string.

Parameters

addBOM

If true, the proper unicode byte-order mark will be prefixed to the string.

Returns

A string containing the UTF-8 encoded string.

Definition at line 2799 of file irrUString.h.

        {
                core::string<uchar8_t> ret;
                ret.reserve(used * 4 + (addBOM ? unicode::BOM_UTF8_LEN : 0) + 1);
                const_iterator iter(*this, 0);

                // Add the byte order mark if the user wants it.
                if (addBOM)
                {
                        ret.append(unicode::BOM_ENCODE_UTF8[0]);
                        ret.append(unicode::BOM_ENCODE_UTF8[1]);
                        ret.append(unicode::BOM_ENCODE_UTF8[2]);
                }

                while (!iter.atEnd())
                {
                        uchar32_t c = *iter;
                        if (c > 0xFFFF)
                        {       // 4 bytes
                                uchar8_t b1 = (0x1E << 3) | ((c >> 18) & 0x7);
                                uchar8_t b2 = (0x2 << 6) | ((c >> 12) & 0x3F);
                                uchar8_t b3 = (0x2 << 6) | ((c >> 6) & 0x3F);
                                uchar8_t b4 = (0x2 << 6) | (c & 0x3F);
                                ret.append(b1);
                                ret.append(b2);
                                ret.append(b3);
                                ret.append(b4);
                        }
                        else if (c > 0x7FF)
                        {       // 3 bytes
                                uchar8_t b1 = (0xE << 4) | ((c >> 12) & 0xF);
                                uchar8_t b2 = (0x2 << 6) | ((c >> 6) & 0x3F);
                                uchar8_t b3 = (0x2 << 6) | (c & 0x3F);
                                ret.append(b1);
                                ret.append(b2);
                                ret.append(b3);
                        }
                        else if (c > 0x7F)
                        {       // 2 bytes
                                uchar8_t b1 = (0x6 << 5) | ((c >> 6) & 0x1F);
                                uchar8_t b2 = (0x2 << 6) | (c & 0x3F);
                                ret.append(b1);
                                ret.append(b2);
                        }
                        else
                        {       // 1 byte
                                ret.append(static_cast<uchar8_t>(c));
                        }
                        ++iter;
                }
                return ret;
        }

toWCHAR()

template<typename TAlloc = irrAllocator<uchar16_t>>

core::array<wchar_t> irr::core::ustring16< TAlloc >::toWCHAR ( const unicode::EUTF_ENDIAN  endian = unicode::EUTFEE_NATIVE, const bool  addBOM = false  ) const

inline

Converts the string to a wchar_t encoded string array.

The size of a wchar_t changes depending on the platform. This function will store a correct UTF-8, -16, or -32 encoded string depending on the size of a wchar_t.

Parameters

endian	The desired endianness of the string.
addBOM	If true, the proper unicode byte-order mark will be prefixed to the string.

Returns

An array containing the wchar_t encoded string.

Definition at line 3148 of file irrUString.h.

        {
                if (sizeof(wchar_t) == 4)
                {
                        core::array<uchar32_t> a(toUTF32(endian, addBOM));
                        core::array<wchar_t> ret(a.size());
                        ret.set_used(a.size());
                        memcpy((void*)ret.pointer(), (void*)a.pointer(), a.size() * sizeof(uchar32_t));
                        return ret;
                }
                if (sizeof(wchar_t) == 2)
                {
                        if (endian == unicode::EUTFEE_NATIVE && addBOM == false)
                        {
                                core::array<wchar_t> ret(used);
                                ret.set_used(used);
                                memcpy((void*)ret.pointer(), (void*)array, used * sizeof(uchar16_t));
                                return ret;
                        }
                        else
                        {
                                core::array<uchar16_t> a(toUTF16(endian, addBOM));
                                core::array<wchar_t> ret(a.size());
                                ret.set_used(a.size());
                                memcpy((void*)ret.pointer(), (void*)a.pointer(), a.size() * sizeof(uchar16_t));
                                return ret;
                        }
                }
                if (sizeof(wchar_t) == 1)
                {
                        core::array<uchar8_t> a(toUTF8(addBOM));
                        core::array<wchar_t> ret(a.size());
                        ret.set_used(a.size());
                        memcpy((void*)ret.pointer(), (void*)a.pointer(), a.size() * sizeof(uchar8_t));
                        return ret;
                }

                // Shouldn't happen.
                return core::array<wchar_t>();
        }

toWCHAR_s()

template<typename TAlloc = irrAllocator<uchar16_t>>

core::string<wchar_t> irr::core::ustring16< TAlloc >::toWCHAR_s ( const unicode::EUTF_ENDIAN  endian = unicode::EUTFEE_NATIVE, const bool  addBOM = false  ) const

inline

Converts the string to a wchar_t encoded string.

The size of a wchar_t changes depending on the platform. This function will store a correct UTF-8, -16, or -32 encoded string depending on the size of a wchar_t.

Parameters

endian	The desired endianness of the string.
addBOM	If true, the proper unicode byte-order mark will be prefixed to the string.

Returns

A string containing the wchar_t encoded string.

Definition at line 3108 of file irrUString.h.

        {
                if (sizeof(wchar_t) == 4)
                {
                        core::array<uchar32_t> a(toUTF32(endian, addBOM));
                        core::stringw ret(a.pointer());
                        return ret;
                }
                else if (sizeof(wchar_t) == 2)
                {
                        if (endian == unicode::EUTFEE_NATIVE && addBOM == false)
                        {
                                core::stringw ret(array);
                                return ret;
                        }
                        else
                        {
                                core::array<uchar16_t> a(toUTF16(endian, addBOM));
                                core::stringw ret(a.pointer());
                                return ret;
                        }
                }
                else if (sizeof(wchar_t) == 1)
                {
                        core::array<uchar8_t> a(toUTF8(addBOM));
                        core::stringw ret(a.pointer());
                        return ret;
                }

                // Shouldn't happen.
                return core::stringw();
        }

trim()

template<typename TAlloc = irrAllocator<uchar16_t>>

ustring16<TAlloc>& irr::core::ustring16< TAlloc >::trim ( const ustring16< TAlloc > &  whitespace = " \t\n\r" )

inline

Trims the ustring16. Removes the specified characters (by default, Latin-1 whitespace) from the begining and the end of the ustring16.

Parameters

whitespace

The characters that are to be considered as whitespace.

Returns

A reference to our current string.

Definition at line 2427 of file irrUString.h.

        {
                core::array<uchar32_t> utf32white = whitespace.toUTF32();

                // find start and end of the substring without the specified characters
                const size_t begin = findFirstCharNotInList(utf32white.const_pointer(), whitespace.used + 1);
                if (begin == ustring16<TAlloc>::npos)
                        return (*this="");

                const size_t end = findLastCharNotInList(utf32white.const_pointer(), whitespace.used + 1);
                if (end == ustring16<TAlloc>::npos)
                        return (*this = subString(begin, ustring16<TAlloc>::npos));
                else return (*this = subString(begin, (end + 1) - begin));
        }

validate()

template<typename TAlloc = irrAllocator<uchar16_t>>

ustring16<TAlloc>& irr::core::ustring16< TAlloc >::validate ( )

inline

Validate the existing ustring16, checking for valid surrogate pairs and checking for proper termination.

Returns

A reference to our current string.

Definition at line 2468 of file irrUString.h.

        {
                // Validate all unicode characters.
                for (size_t i=0; i<allocated; ++i)
                {
                        // Terminate on existing null.
                        if (array[i] == 0)
                        {
                                used = i;
                                return *this;
                        }
                        if (UTF16_IS_SURROGATE(array[i]))
                        {
                                if (((i+1) >= allocated) || UTF16_IS_SURROGATE_LO(array[i]))
                                        array[i] = unicode::UTF_REPLACEMENT_CHARACTER;
                                else if (UTF16_IS_SURROGATE_HI(array[i]) && !UTF16_IS_SURROGATE_LO(array[i+1]))
                                        array[i] = unicode::UTF_REPLACEMENT_CHARACTER;
                                ++i;
                        }
                        if (array[i] >= 0xFDD0 && array[i] <= 0xFDEF)
                                array[i] = unicode::UTF_REPLACEMENT_CHARACTER;
                }

                // terminate
                used = 0;
                if (allocated > 0)
                {
                        used = allocated - 1;
                        array[used] = 0;
                }
                return *this;
        }

Member Data Documentation

npos

template<typename TAlloc = irrAllocator<uchar16_t>>

const size_t irr::core::ustring16< TAlloc >::npos = -1

static

-------------------—/// end iterator classes /// -------------------—/// ---------------—/// static variables /// ---------------—///

Definition at line 808 of file irrUString.h.

---

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

• include/irrUString.h