Merge cguittfont lib in irrlicht change folder. (#6016)

* Merge cguittfont lib in irrlicht change folder.

This remove hack and static lib for FreeType

1 files changed, 0 insertions, 3892 deletions

diff --git a/src/cguittfont/irrUString.h b/src/cguittfont/irrUString.h
deleted file mode 100644
index eb7abe5a1..000000000
--- a/src/cguittfont/irrUString.h
+++ /dev/null
@@ -1,3892 +0,0 @@
-/*
-   Basic Unicode string class for Irrlicht.
-   Copyright (c) 2009-2011 John Norman
-
-   This software is provided 'as-is', without any express or implied
-   warranty. In no event will the authors be held liable for any
-   damages arising from the use of this software.
-
-   Permission is granted to anyone to use this software for any
-   purpose, including commercial applications, and to alter it and
-   redistribute it freely, subject to the following restrictions:
-
-   1. The origin of this software must not be misrepresented; you
-      must not claim that you wrote the original software. If you use
-      this software in a product, an acknowledgment in the product
-      documentation would be appreciated but is not required.
-
-   2. Altered source versions must be plainly marked as such, and
-      must not be misrepresented as being the original software.
-
-   3. This notice may not be removed or altered from any source
-      distribution.
-
-   The original version of this class can be located at:
-   http://irrlicht.suckerfreegames.com/
-
-   John Norman
-   john@suckerfreegames.com
-*/
-
-#ifndef __IRR_USTRING_H_INCLUDED__
-#define __IRR_USTRING_H_INCLUDED__
-
-#if (__cplusplus > 199711L) || (_MSC_VER >= 1600) || defined(__GXX_EXPERIMENTAL_CXX0X__)
-#	define USTRING_CPP0X
-#	if defined(__GXX_EXPERIMENTAL_CXX0X__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)))
-#		define USTRING_CPP0X_NEWLITERALS
-#	endif
-#endif
-
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#ifdef _WIN32
-#define __BYTE_ORDER 0
-#define __LITTLE_ENDIAN 0
-#define __BIG_ENDIAN 1
-#elif defined(__MACH__) && defined(__APPLE__)
-#include <machine/endian.h>
-#elif defined(__FreeBSD__)
-#include <sys/endian.h>
-#else
-#include <endian.h>
-#endif
-
-#ifdef USTRING_CPP0X
-#	include <utility>
-#endif
-
-#ifndef USTRING_NO_STL
-#	include <string>
-#	include <iterator>
-#	include <ostream>
-#endif
-
-#include "irrTypes.h"
-#include "irrAllocator.h"
-#include "irrArray.h"
-#include "irrMath.h"
-#include "irrString.h"
-#include "path.h"
-
-//! UTF-16 surrogate start values.
-static const irr::u16 UTF16_HI_SURROGATE = 0xD800;
-static const irr::u16 UTF16_LO_SURROGATE = 0xDC00;
-
-//! Is a UTF-16 code point a surrogate?
-#define UTF16_IS_SURROGATE(c)		(((c) & 0xF800) == 0xD800)
-#define UTF16_IS_SURROGATE_HI(c)	(((c) & 0xFC00) == 0xD800)
-#define UTF16_IS_SURROGATE_LO(c)	(((c) & 0xFC00) == 0xDC00)
-
-
-namespace irr
-{
-
-	// Define our character types.
-#ifdef USTRING_CPP0X_NEWLITERALS	// C++0x
-	typedef char32_t uchar32_t;
-	typedef char16_t uchar16_t;
-	typedef char uchar8_t;
-#else
-	typedef u32 uchar32_t;
-	typedef u16 uchar16_t;
-	typedef u8 uchar8_t;
-#endif
-
-namespace core
-{
-
-namespace unicode
-{
-
-//! The unicode replacement character.  Used to replace invalid characters.
-const irr::u16 UTF_REPLACEMENT_CHARACTER = 0xFFFD;
-
-//! Convert a UTF-16 surrogate pair into a UTF-32 character.
-//! \param high The high value of the pair.
-//! \param low The low value of the pair.
-//! \return The UTF-32 character expressed by the surrogate pair.
-inline uchar32_t toUTF32(uchar16_t high, uchar16_t low)
-{
-	// Convert the surrogate pair into a single UTF-32 character.
-	uchar32_t x = ((high & ((1 << 6) -1)) << 10) | (low & ((1 << 10) -1));
-	uchar32_t wu = ((high >> 6) & ((1 << 5) - 1)) + 1;
-	return (wu << 16) | x;
-}
-
-//! Swaps the endianness of a 16-bit value.
-//! \return The new value.
-inline uchar16_t swapEndian16(const uchar16_t& c)
-{
-	return ((c >> 8) & 0x00FF) | ((c << 8) & 0xFF00);
-}
-
-//! Swaps the endianness of a 32-bit value.
-//! \return The new value.
-inline uchar32_t swapEndian32(const uchar32_t& c)
-{
-	return  ((c >> 24) & 0x000000FF) |
-			((c >> 8)  & 0x0000FF00) |
-			((c << 8)  & 0x00FF0000) |
-			((c << 24) & 0xFF000000);
-}
-
-//! The Unicode byte order mark.
-const u16 BOM = 0xFEFF;
-
-//! The size of the Unicode byte order mark in terms of the Unicode character size.
-const u8 BOM_UTF8_LEN = 3;
-const u8 BOM_UTF16_LEN = 1;
-const u8 BOM_UTF32_LEN = 1;
-
-//! Unicode byte order marks for file operations.
-const u8 BOM_ENCODE_UTF8[3] = { 0xEF, 0xBB, 0xBF };
-const u8 BOM_ENCODE_UTF16_BE[2] = { 0xFE, 0xFF };
-const u8 BOM_ENCODE_UTF16_LE[2] = { 0xFF, 0xFE };
-const u8 BOM_ENCODE_UTF32_BE[4] = { 0x00, 0x00, 0xFE, 0xFF };
-const u8 BOM_ENCODE_UTF32_LE[4] = { 0xFF, 0xFE, 0x00, 0x00 };
-
-//! The size in bytes of the Unicode byte marks for file operations.
-const u8 BOM_ENCODE_UTF8_LEN = 3;
-const u8 BOM_ENCODE_UTF16_LEN = 2;
-const u8 BOM_ENCODE_UTF32_LEN = 4;
-
-//! Unicode encoding type.
-enum EUTF_ENCODE
-{
-	EUTFE_NONE		= 0,
-	EUTFE_UTF8,
-	EUTFE_UTF16,
-	EUTFE_UTF16_LE,
-	EUTFE_UTF16_BE,
-	EUTFE_UTF32,
-	EUTFE_UTF32_LE,
-	EUTFE_UTF32_BE
-};
-
-//! Unicode endianness.
-enum EUTF_ENDIAN
-{
-	EUTFEE_NATIVE	= 0,
-	EUTFEE_LITTLE,
-	EUTFEE_BIG
-};
-
-//! Returns the specified unicode byte order mark in a byte array.
-//! The byte order mark is the first few bytes in a text file that signifies its encoding.
-/** \param mode The Unicode encoding method that we want to get the byte order mark for.
-		If EUTFE_UTF16 or EUTFE_UTF32 is passed, it uses the native system endianness. **/
-//! \return An array that contains a byte order mark.
-inline core::array<u8> getUnicodeBOM(EUTF_ENCODE mode)
-{
-#define COPY_ARRAY(source, size) \
-	memcpy(ret.pointer(), source, size); \
-	ret.set_used(size)
-
-	core::array<u8> ret(4);
-	switch (mode)
-	{
-		case EUTFE_UTF8:
-			COPY_ARRAY(BOM_ENCODE_UTF8, BOM_ENCODE_UTF8_LEN);
-			break;
-		case EUTFE_UTF16:
-			#ifdef __BIG_ENDIAN__
-				COPY_ARRAY(BOM_ENCODE_UTF16_BE, BOM_ENCODE_UTF16_LEN);
-			#else
-				COPY_ARRAY(BOM_ENCODE_UTF16_LE, BOM_ENCODE_UTF16_LEN);
-			#endif
-			break;
-		case EUTFE_UTF16_BE:
-			COPY_ARRAY(BOM_ENCODE_UTF16_BE, BOM_ENCODE_UTF16_LEN);
-			break;
-		case EUTFE_UTF16_LE:
-			COPY_ARRAY(BOM_ENCODE_UTF16_LE, BOM_ENCODE_UTF16_LEN);
-			break;
-		case EUTFE_UTF32:
-			#ifdef __BIG_ENDIAN__
-				COPY_ARRAY(BOM_ENCODE_UTF32_BE, BOM_ENCODE_UTF32_LEN);
-			#else
-				COPY_ARRAY(BOM_ENCODE_UTF32_LE, BOM_ENCODE_UTF32_LEN);
-			#endif
-			break;
-		case EUTFE_UTF32_BE:
-			COPY_ARRAY(BOM_ENCODE_UTF32_BE, BOM_ENCODE_UTF32_LEN);
-			break;
-		case EUTFE_UTF32_LE:
-			COPY_ARRAY(BOM_ENCODE_UTF32_LE, BOM_ENCODE_UTF32_LEN);
-			break;
-		case EUTFE_NONE:
-			// TODO sapier: fixed warning only,
-			// don't know if something needs to be done here
-			break;
-	}
-	return ret;
-
-#undef COPY_ARRAY
-}
-
-//! Detects if the given data stream starts with a unicode BOM.
-//! \param data The data stream to check.
-//! \return The unicode BOM associated with the data stream, or EUTFE_NONE if none was found.
-inline EUTF_ENCODE determineUnicodeBOM(const char* data)
-{
-	if (memcmp(data, BOM_ENCODE_UTF8, 3) == 0) return EUTFE_UTF8;
-	if (memcmp(data, BOM_ENCODE_UTF16_BE, 2) == 0) return EUTFE_UTF16_BE;
-	if (memcmp(data, BOM_ENCODE_UTF16_LE, 2) == 0) return EUTFE_UTF16_LE;
-	if (memcmp(data, BOM_ENCODE_UTF32_BE, 4) == 0) return EUTFE_UTF32_BE;
-	if (memcmp(data, BOM_ENCODE_UTF32_LE, 4) == 0) return EUTFE_UTF32_LE;
-	return EUTFE_NONE;
-}
-
-} // end namespace unicode
-
-
-//! UTF-16 string class.
-template <typename TAlloc = irrAllocator<uchar16_t> >
-class ustring16
-{
-public:
-
-	///------------------///
-	/// iterator classes ///
-	///------------------///
-
-	//! Access an element in a unicode string, allowing one to change it.
-	class _ustring16_iterator_access
-	{
-		public:
-			_ustring16_iterator_access(const ustring16<TAlloc>* s, u32 p) : ref(s), pos(p) {}
-
-			//! Allow the class to be interpreted as a single UTF-32 character.
-			operator uchar32_t() const
-			{
-				return _get();
-			}
-
-			//! Allow one to change the character in the unicode string.
-			//! \param c The new character to use.
-			//! \return Myself.
-			_ustring16_iterator_access& operator=(const uchar32_t c)
-			{
-				_set(c);
-				return *this;
-			}
-
-			//! Increments the value by 1.
-			//! \return Myself.
-			_ustring16_iterator_access& operator++()
-			{
-				_set(_get() + 1);
-				return *this;
-			}
-
-			//! Increments the value by 1, returning the old value.
-			//! \return A unicode character.
-			uchar32_t operator++(int)
-			{
-				uchar32_t old = _get();
-				_set(old + 1);
-				return old;
-			}
-
-			//! Decrements the value by 1.
-			//! \return Myself.
-			_ustring16_iterator_access& operator--()
-			{
-				_set(_get() - 1);
-				return *this;
-			}
-
-			//! Decrements the value by 1, returning the old value.
-			//! \return A unicode character.
-			uchar32_t operator--(int)
-			{
-				uchar32_t old = _get();
-				_set(old - 1);
-				return old;
-			}
-
-			//! Adds to the value by a specified amount.
-			//! \param val The amount to add to this character.
-			//! \return Myself.
-			_ustring16_iterator_access& operator+=(int val)
-			{
-				_set(_get() + val);
-				return *this;
-			}
-
-			//! Subtracts from the value by a specified amount.
-			//! \param val The amount to subtract from this character.
-			//! \return Myself.
-			_ustring16_iterator_access& operator-=(int val)
-			{
-				_set(_get() - val);
-				return *this;
-			}
-
-			//! Multiples the value by a specified amount.
-			//! \param val The amount to multiply this character by.
-			//! \return Myself.
-			_ustring16_iterator_access& operator*=(int val)
-			{
-				_set(_get() * val);
-				return *this;
-			}
-
-			//! Divides the value by a specified amount.
-			//! \param val The amount to divide this character by.
-			//! \return Myself.
-			_ustring16_iterator_access& operator/=(int val)
-			{
-				_set(_get() / val);
-				return *this;
-			}
-
-			//! Modulos the value by a specified amount.
-			//! \param val The amount to modulo this character by.
-			//! \return Myself.
-			_ustring16_iterator_access& operator%=(int val)
-			{
-				_set(_get() % val);
-				return *this;
-			}
-
-			//! Adds to the value by a specified amount.
-			//! \param val The amount to add to this character.
-			//! \return A unicode character.
-			uchar32_t operator+(int val) const
-			{
-				return _get() + val;
-			}
-
-			//! Subtracts from the value by a specified amount.
-			//! \param val The amount to subtract from this character.
-			//! \return A unicode character.
-			uchar32_t operator-(int val) const
-			{
-				return _get() - val;
-			}
-
-			//! Multiplies the value by a specified amount.
-			//! \param val The amount to multiply this character by.
-			//! \return A unicode character.
-			uchar32_t operator*(int val) const
-			{
-				return _get() * val;
-			}
-
-			//! Divides the value by a specified amount.
-			//! \param val The amount to divide this character by.
-			//! \return A unicode character.
-			uchar32_t operator/(int val) const
-			{
-				return _get() / val;
-			}
-
-			//! Modulos the value by a specified amount.
-			//! \param val The amount to modulo this character by.
-			//! \return A unicode character.
-			uchar32_t operator%(int val) const
-			{
-				return _get() % val;
-			}
-
-		private:
-			//! Gets a uchar32_t from our current position.
-			uchar32_t _get() const
-			{
-				const uchar16_t* a = ref->c_str();
-				if (!UTF16_IS_SURROGATE(a[pos]))
-					return static_cast<uchar32_t>(a[pos]);
-				else
-				{
-					if (pos + 1 >= ref->size_raw())
-						return 0;
-
-					return unicode::toUTF32(a[pos], a[pos + 1]);
-				}
-			}
-
-			//! Sets a uchar32_t at our current position.
-			void _set(uchar32_t c)
-			{
-				ustring16<TAlloc>* ref2 = const_cast<ustring16<TAlloc>*>(ref);
-				const uchar16_t* a = ref2->c_str();
-				if (c > 0xFFFF)
-				{
-					// c will be multibyte, so split it up into the high and low surrogate pairs.
-					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));
-
-					// If the previous position was a surrogate pair, just replace them.  Else, insert the low pair.
-					if (UTF16_IS_SURROGATE_HI(a[pos]) && pos + 1 != ref2->size_raw())
-						ref2->replace_raw(vl, static_cast<u32>(pos) + 1);
-					else ref2->insert_raw(vl, static_cast<u32>(pos) + 1);
-
-					ref2->replace_raw(vh, static_cast<u32>(pos));
-				}
-				else
-				{
-					// c will be a single byte.
-					uchar16_t vh = static_cast<uchar16_t>(c);
-
-					// If the previous position was a surrogate pair, remove the extra byte.
-					if (UTF16_IS_SURROGATE_HI(a[pos]))
-						ref2->erase_raw(static_cast<u32>(pos) + 1);
-
-					ref2->replace_raw(vh, static_cast<u32>(pos));
-				}
-			}
-
-			const ustring16<TAlloc>* ref;
-			u32 pos;
-	};
-	typedef typename ustring16<TAlloc>::_ustring16_iterator_access access;
-
-
-	//! Iterator to iterate through a UTF-16 string.
-#ifndef USTRING_NO_STL
-	class _ustring16_const_iterator : public std::iterator<
-		std::bidirectional_iterator_tag,	// iterator_category
-		access,								// value_type
-		ptrdiff_t,							// difference_type
-		const access,						// pointer
-		const access						// reference
-	>
-#else
-	class _ustring16_const_iterator
-#endif
-	{
-		public:
-			typedef _ustring16_const_iterator _Iter;
-			typedef std::iterator<std::bidirectional_iterator_tag, access, ptrdiff_t, const access, const access> _Base;
-			typedef const access const_pointer;
-			typedef const access const_reference;
-
-#ifndef USTRING_NO_STL
-			typedef typename _Base::value_type value_type;
-			typedef typename _Base::difference_type difference_type;
-			typedef typename _Base::difference_type distance_type;
-			typedef typename _Base::pointer pointer;
-			typedef const_reference reference;
-#else
-			typedef access value_type;
-			typedef u32 difference_type;
-			typedef u32 distance_type;
-			typedef const_pointer pointer;
-			typedef const_reference reference;
-#endif
-
-			//! Constructors.
-			_ustring16_const_iterator(const _Iter& i) : ref(i.ref), pos(i.pos) {}
-			_ustring16_const_iterator(const ustring16<TAlloc>& s) : ref(&s), pos(0) {}
-			_ustring16_const_iterator(const ustring16<TAlloc>& s, const u32 p) : ref(&s), pos(0)
-			{
-				if (ref->size_raw() == 0 || p == 0)
-					return;
-
-				// Go to the appropriate position.
-				u32 i = p;
-				u32 sr = ref->size_raw();
-				const uchar16_t* a = ref->c_str();
-				while (i != 0 && pos < sr)
-				{
-					if (UTF16_IS_SURROGATE_HI(a[pos]))
-						pos += 2;
-					else ++pos;
-					--i;
-				}
-			}
-
-			//! Test for equalness.
-			bool operator==(const _Iter& iter) const
-			{
-				if (ref == iter.ref && pos == iter.pos)
-					return true;
-				return false;
-			}
-
-			//! Test for unequalness.
-			bool operator!=(const _Iter& iter) const
-			{
-				if (ref != iter.ref || pos != iter.pos)
-					return true;
-				return false;
-			}
-
-			//! Switch to the next full character in the string.
-			_Iter& operator++()
-			{	// ++iterator
-				if (pos == ref->size_raw()) return *this;
-				const uchar16_t* a = ref->c_str();
-				if (UTF16_IS_SURROGATE_HI(a[pos]))
-					pos += 2;			// TODO: check for valid low surrogate?
-				else ++pos;
-				if (pos > ref->size_raw()) pos = ref->size_raw();
-				return *this;
-			}
-
-			//! Switch to the next full character in the string, returning the previous position.
-			_Iter operator++(int)
-			{	// iterator++
-				_Iter _tmp(*this);
-				++*this;
-				return _tmp;
-			}
-
-			//! Switch to the previous full character in the string.
-			_Iter& operator--()
-			{	// --iterator
-				if (pos == 0) return *this;
-				const uchar16_t* a = ref->c_str();
-				--pos;
-				if (UTF16_IS_SURROGATE_LO(a[pos]) && pos != 0)	// low surrogate, go back one more.
-					--pos;
-				return *this;
-			}
-
-			//! Switch to the previous full character in the string, returning the previous position.
-			_Iter operator--(int)
-			{	// iterator--
-				_Iter _tmp(*this);
-				--*this;
-				return _tmp;
-			}
-
-			//! Advance a specified number of full characters in the string.
-			//! \return Myself.
-			_Iter& operator+=(const difference_type v)
-			{
-				if (v == 0) return *this;
-				if (v < 0) return operator-=(v * -1);
-
-				if (pos >= ref->size_raw())
-					return *this;
-
-				// Go to the appropriate position.
-				// TODO: Don't force u32 on an x64 OS.  Make it agnostic.
-				u32 i = (u32)v;
-				u32 sr = ref->size_raw();
-				const uchar16_t* a = ref->c_str();
-				while (i != 0 && pos < sr)
-				{
-					if (UTF16_IS_SURROGATE_HI(a[pos]))
-						pos += 2;
-					else ++pos;
-					--i;
-				}
-				if (pos > sr)
-					pos = sr;
-
-				return *this;
-			}
-
-			//! Go back a specified number of full characters in the string.
-			//! \return Myself.
-			_Iter& operator-=(const difference_type v)
-			{
-				if (v == 0) return *this;
-				if (v > 0) return operator+=(v * -1);
-
-				if (pos == 0)
-					return *this;
-
-				// Go to the appropriate position.
-				// TODO: Don't force u32 on an x64 OS.  Make it agnostic.
-				u32 i = (u32)v;
-				const uchar16_t* a = ref->c_str();
-				while (i != 0 && pos != 0)
-				{
-					--pos;
-					if (UTF16_IS_SURROGATE_LO(a[pos]) != 0 && pos != 0)
-						--pos;
-					--i;
-				}
-
-				return *this;
-			}
-
-			//! Return a new iterator that is a variable number of full characters forward from the current position.
-			_Iter operator+(const difference_type v) const
-			{
-				_Iter ret(*this);
-				ret += v;
-				return ret;
-			}
-
-			//! Return a new iterator that is a variable number of full characters backward from the current position.
-			_Iter operator-(const difference_type v) const
-			{
-				_Iter ret(*this);
-				ret -= v;
-				return ret;
-			}
-
-			//! Returns the distance between two iterators.
-			difference_type operator-(const _Iter& iter) const
-			{
-				// Make sure we reference the same object!
-				if (ref != iter.ref)
-					return difference_type();
-
-				_Iter i = iter;
-				difference_type ret;
-
-				// Walk up.
-				if (pos > i.pos)
-				{
-					while (pos > i.pos)
-					{
-						++i;
-						++ret;
-					}
-					return ret;
-				}
-
-				// Walk down.
-				while (pos < i.pos)
-				{
-					--i;
-					--ret;
-				}
-				return ret;
-			}
-
-			//! Accesses the full character at the iterator's position.
-			const_reference operator*() const
-			{
-				if (pos >= ref->size_raw())
-				{
-					const uchar16_t* a = ref->c_str();
-					u32 p = ref->size_raw();
-					if (UTF16_IS_SURROGATE_LO(a[p]))
-						--p;
-					reference ret(ref, p);
-					return ret;
-				}
-				const_reference ret(ref, pos);
-				return ret;
-			}
-
-			//! Accesses the full character at the iterator's position.
-			reference operator*()
-			{
-				if (pos >= ref->size_raw())
-				{
-					const uchar16_t* a = ref->c_str();
-					u32 p = ref->size_raw();
-					if (UTF16_IS_SURROGATE_LO(a[p]))
-						--p;
-					reference ret(ref, p);
-					return ret;
-				}
-				reference ret(ref, pos);
-				return ret;
-			}
-
-			//! Accesses the full character at the iterator's position.
-			const_pointer operator->() const
-			{
-				return operator*();
-			}
-
-			//! Accesses the full character at the iterator's position.
-			pointer operator->()
-			{
-				return operator*();
-			}
-
-			//! Is the iterator at the start of the string?
-			bool atStart() const
-			{
-				return pos == 0;
-			}
-
-			//! Is the iterator at the end of the string?
-			bool atEnd() const
-			{
-				const uchar16_t* a = ref->c_str();
-				if (UTF16_IS_SURROGATE(a[pos]))
-					return (pos + 1) >= ref->size_raw();
-				else return pos >= ref->size_raw();
-			}
-
-			//! Moves the iterator to the start of the string.
-			void toStart()
-			{
-				pos = 0;
-			}
-
-			//! Moves the iterator to the end of the string.
-			void toEnd()
-			{
-				pos = ref->size_raw();
-			}
-
-			//! Returns the iterator's position.
-			//! \return The iterator's position.
-			u32 getPos() const
-			{
-				return pos;
-			}
-
-		protected:
-			const ustring16<TAlloc>* ref;
-			u32 pos;
-	};
-
-	//! Iterator to iterate through a UTF-16 string.
-	class _ustring16_iterator : public _ustring16_const_iterator
-	{
-		public:
-			typedef _ustring16_iterator _Iter;
-			typedef _ustring16_const_iterator _Base;
-			typedef typename _Base::const_pointer const_pointer;
-			typedef typename _Base::const_reference const_reference;
-
-
-			typedef typename _Base::value_type value_type;
-			typedef typename _Base::difference_type difference_type;
-			typedef typename _Base::distance_type distance_type;
-			typedef access pointer;
-			typedef access reference;
-
-			using _Base::pos;
-			using _Base::ref;
-
-			//! Constructors.
-			_ustring16_iterator(const _Iter& i) : _ustring16_const_iterator(i) {}
-			_ustring16_iterator(const ustring16<TAlloc>& s) : _ustring16_const_iterator(s) {}
-			_ustring16_iterator(const ustring16<TAlloc>& s, const u32 p) : _ustring16_const_iterator(s, p) {}
-
-			//! Accesses the full character at the iterator's position.
-			reference operator*() const
-			{
-				if (pos >= ref->size_raw())
-				{
-					const uchar16_t* a = ref->c_str();
-					u32 p = ref->size_raw();
-					if (UTF16_IS_SURROGATE_LO(a[p]))
-						--p;
-					reference ret(ref, p);
-					return ret;
-				}
-				reference ret(ref, pos);
-				return ret;
-			}
-
-			//! Accesses the full character at the iterator's position.
-			reference operator*()
-			{
-				if (pos >= ref->size_raw())
-				{
-					const uchar16_t* a = ref->c_str();
-					u32 p = ref->size_raw();
-					if (UTF16_IS_SURROGATE_LO(a[p]))
-						--p;
-					reference ret(ref, p);
-					return ret;
-				}
-				reference ret(ref, pos);
-				return ret;
-			}
-
-			//! Accesses the full character at the iterator's position.
-			pointer operator->() const
-			{
-				return operator*();
-			}
-
-			//! Accesses the full character at the iterator's position.
-			pointer operator->()
-			{
-				return operator*();
-			}
-	};
-
-	typedef typename ustring16<TAlloc>::_ustring16_iterator iterator;
-	typedef typename ustring16<TAlloc>::_ustring16_const_iterator const_iterator;
-
-	///----------------------///
-	/// end iterator classes ///
-	///----------------------///
-
-	//! Default constructor
-	ustring16()
-	: array(0), allocated(1), used(0)
-	{
-#if __BYTE_ORDER == __BIG_ENDIAN
-		encoding = unicode::EUTFE_UTF16_BE;
-#else
-		encoding = unicode::EUTFE_UTF16_LE;
-#endif
-		array = allocator.allocate(1); // new u16[1];
-		array[0] = 0x0;
-	}
-
-
-	//! Constructor
-	ustring16(const ustring16<TAlloc>& other)
-	: array(0), allocated(0), used(0)
-	{
-#if __BYTE_ORDER == __BIG_ENDIAN
-		encoding = unicode::EUTFE_UTF16_BE;
-#else
-		encoding = unicode::EUTFE_UTF16_LE;
-#endif
-		*this = other;
-	}
-
-
-	//! Constructor from other string types
-	template <class B, class A>
-	ustring16(const string<B, A>& other)
-	: array(0), allocated(0), used(0)
-	{
-#if __BYTE_ORDER == __BIG_ENDIAN
-		encoding = unicode::EUTFE_UTF16_BE;
-#else
-		encoding = unicode::EUTFE_UTF16_LE;
-#endif
-		*this = other;
-	}
-
-
-#ifndef USTRING_NO_STL
-	//! Constructor from std::string
-	template <class B, class A, typename Alloc>
-	ustring16(const std::basic_string<B, A, Alloc>& other)
-	: array(0), allocated(0), used(0)
-	{
-#if __BYTE_ORDER == __BIG_ENDIAN
-		encoding = unicode::EUTFE_UTF16_BE;
-#else
-		encoding = unicode::EUTFE_UTF16_LE;
-#endif
-		*this = other.c_str();
-	}
-
-
-	//! Constructor from iterator.
-	template <typename Itr>
-	ustring16(Itr first, Itr last)
-	: array(0), allocated(0), used(0)
-	{
-#if __BYTE_ORDER == __BIG_ENDIAN
-		encoding = unicode::EUTFE_UTF16_BE;
-#else
-		encoding = unicode::EUTFE_UTF16_LE;
-#endif
-		reserve(std::distance(first, last));
-		array[used] = 0;
-
-		for (; first != last; ++first)
-			append((uchar32_t)*first);
-	}
-#endif
-
-
-#ifndef USTRING_CPP0X_NEWLITERALS
-	//! Constructor for copying a character string from a pointer.
-	ustring16(const char* const c)
-	: array(0), allocated(0), used(0)
-	{
-#if __BYTE_ORDER == __BIG_ENDIAN
-		encoding = unicode::EUTFE_UTF16_BE;
-#else
-		encoding = unicode::EUTFE_UTF16_LE;
-#endif
-
-		loadDataStream(c, strlen(c));
-		//append((uchar8_t*)c);
-	}
-
-
-	//! Constructor for copying a character string from a pointer with a given length.
-	ustring16(const char* const c, u32 length)
-	: array(0), allocated(0), used(0)
-	{
-#if __BYTE_ORDER == __BIG_ENDIAN
-		encoding = unicode::EUTFE_UTF16_BE;
-#else
-		encoding = unicode::EUTFE_UTF16_LE;
-#endif
-
-		loadDataStream(c, length);
-	}
-#endif
-
-
-	//! Constructor for copying a UTF-8 string from a pointer.
-	ustring16(const uchar8_t* const c)
-	: array(0), allocated(0), used(0)
-	{
-#if __BYTE_ORDER == __BIG_ENDIAN
-		encoding = unicode::EUTFE_UTF16_BE;
-#else
-		encoding = unicode::EUTFE_UTF16_LE;
-#endif
-
-		append(c);
-	}
-
-
-	//! Constructor for copying a UTF-8 string from a single char.
-	ustring16(const char c)
-	: array(0), allocated(0), used(0)
-	{
-#if __BYTE_ORDER == __BIG_ENDIAN
-		encoding = unicode::EUTFE_UTF16_BE;
-#else
-		encoding = unicode::EUTFE_UTF16_LE;
-#endif
-
-		append((uchar32_t)c);
-	}
-
-
-	//! Constructor for copying a UTF-8 string from a pointer with a given length.
-	ustring16(const uchar8_t* const c, u32 length)
-	: array(0), allocated(0), used(0)
-	{
-#if __BYTE_ORDER == __BIG_ENDIAN
-		encoding = unicode::EUTFE_UTF16_BE;
-#else
-		encoding = unicode::EUTFE_UTF16_LE;
-#endif
-
-		append(c, length);
-	}
-
-
-	//! Constructor for copying a UTF-16 string from a pointer.
-	ustring16(const uchar16_t* const c)
-	: array(0), allocated(0), used(0)
-	{
-#if __BYTE_ORDER == __BIG_ENDIAN
-		encoding = unicode::EUTFE_UTF16_BE;
-#else
-		encoding = unicode::EUTFE_UTF16_LE;
-#endif
-
-		append(c);
-	}
-
-
-	//! Constructor for copying a UTF-16 string from a pointer with a given length
-	ustring16(const uchar16_t* const c, u32 length)
-	: array(0), allocated(0), used(0)
-	{
-#if __BYTE_ORDER == __BIG_ENDIAN
-		encoding = unicode::EUTFE_UTF16_BE;
-#else
-		encoding = unicode::EUTFE_UTF16_LE;
-#endif
-
-		append(c, length);
-	}
-
-
-	//! Constructor for copying a UTF-32 string from a pointer.
-	ustring16(const uchar32_t* const c)
-	: array(0), allocated(0), used(0)
-	{
-#if __BYTE_ORDER == __BIG_ENDIAN
-		encoding = unicode::EUTFE_UTF16_BE;
-#else
-		encoding = unicode::EUTFE_UTF16_LE;
-#endif
-
-		append(c);
-	}
-
-
-	//! Constructor for copying a UTF-32 from a pointer with a given length.
-	ustring16(const uchar32_t* const c, u32 length)
-	: array(0), allocated(0), used(0)
-	{
-#if __BYTE_ORDER == __BIG_ENDIAN
-		encoding = unicode::EUTFE_UTF16_BE;
-#else
-		encoding = unicode::EUTFE_UTF16_LE;
-#endif
-
-		append(c, length);
-	}
-
-
-	//! Constructor for copying a wchar_t string from a pointer.
-	ustring16(const wchar_t* const c)
-	: array(0), allocated(0), used(0)
-	{
-#if __BYTE_ORDER == __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));
-	}
-
-
-	//! Constructor for copying a wchar_t string from a pointer with a given length.
-	ustring16(const wchar_t* const c, u32 length)
-	: array(0), allocated(0), used(0)
-	{
-#if __BYTE_ORDER == __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);
-	}
-
-
-#ifdef USTRING_CPP0X
-	//! Constructor for moving a ustring16
-	ustring16(ustring16<TAlloc>&& other)
-	: array(other.array), encoding(other.encoding), allocated(other.allocated), used(other.used)
-	{
-		//std::cout << "MOVE constructor" << std::endl;
-		other.array = 0;
-		other.allocated = 0;
-		other.used = 0;
-	}
-#endif
-
-
-	//! Destructor
-	~ustring16()
-	{
-		allocator.deallocate(array); // delete [] array;
-	}
-
-
-	//! Assignment operator
-	ustring16& operator=(const ustring16<TAlloc>& other)
-	{
-		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 (u32 i=0; i<=used; ++i, ++p)
-			array[i] = *p;
-
-		array[used] = 0;
-
-		// Validate our new UTF-16 string.
-		validate();
-
-		return *this;
-	}
-
-
-#ifdef USTRING_CPP0X
-	//! Move assignment operator
-	ustring16& operator=(ustring16<TAlloc>&& other)
-	{
-		if (this != &other)
-		{
-			//std::cout << "MOVE operator=" << std::endl;
-			allocator.deallocate(array);
-
-			array = other.array;
-			allocated = other.allocated;
-			encoding = other.encoding;
-			used = other.used;
-			other.array = 0;
-			other.used = 0;
-		}
-		return *this;
-	}
-#endif
-
-
-	//! Assignment operator for other string types
-	template <class B, class A>
-	ustring16<TAlloc>& operator=(const string<B, A>& other)
-	{
-		*this = other.c_str();
-		return *this;
-	}
-
-
-	//! Assignment operator for UTF-8 strings
-	ustring16<TAlloc>& operator=(const uchar8_t* const c)
-	{
-		if (!array)
-		{
-			array = allocator.allocate(1); //new u16[1];
-			allocated = 1;
-		}
-		used = 0;
-		array[used] = 0x0;
-		if (!c) return *this;
-
-		//! Append our string now.
-		append(c);
-		return *this;
-	}
-
-
-	//! Assignment operator for UTF-16 strings
-	ustring16<TAlloc>& operator=(const uchar16_t* const c)
-	{
-		if (!array)
-		{
-			array = allocator.allocate(1); //new u16[1];
-			allocated = 1;
-		}
-		used = 0;
-		array[used] = 0x0;
-		if (!c) return *this;
-
-		//! Append our string now.
-		append(c);
-		return *this;
-	}
-
-
-	//! Assignment operator for UTF-32 strings
-	ustring16<TAlloc>& operator=(const uchar32_t* const c)
-	{
-		if (!array)
-		{
-			array = allocator.allocate(1); //new u16[1];
-			allocated = 1;
-		}
-		used = 0;
-		array[used] = 0x0;
-		if (!c) return *this;
-
-		//! Append our string now.
-		append(c);
-		return *this;
-	}
-
-
-	//! 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. **/
-	ustring16<TAlloc>& operator=(const wchar_t* const c)
-	{
-		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;
-	}
-
-
-	//! Assignment operator for other strings.
-	/** Note that this assumes that a correct unicode string is stored in the string. **/
-	template <class B>
-	ustring16<TAlloc>& operator=(const B* const c)
-	{
-		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;
-	}
-
-
-	//! Direct access operator
-	access operator [](const u32 index)
-	{
-		_IRR_DEBUG_BREAK_IF(index>=size()) // bad index
-		iterator iter(*this, index);
-		return iter.operator*();
-	}
-
-
-	//! Direct access operator
-	const access operator [](const u32 index) const
-	{
-		_IRR_DEBUG_BREAK_IF(index>=size()) // bad index
-		const_iterator iter(*this, index);
-		return iter.operator*();
-	}
-
-
-	//! Equality operator
-	bool operator ==(const uchar16_t* const str) const
-	{
-		if (!str)
-			return false;
-
-		u32 i;
-		for(i=0; array[i] && str[i]; ++i)
-			if (array[i] != str[i])
-				return false;
-
-		return !array[i] && !str[i];
-	}
-
-
-	//! Equality operator
-	bool operator ==(const ustring16<TAlloc>& other) const
-	{
-		for(u32 i=0; array[i] && other.array[i]; ++i)
-			if (array[i] != other.array[i])
-				return false;
-
-		return used == other.used;
-	}
-
-
-	//! Is smaller comparator
-	bool operator <(const ustring16<TAlloc>& other) const
-	{
-		for(u32 i=0; array[i] && other.array[i]; ++i)
-		{
-			s32 diff = array[i] - other.array[i];
-			if ( diff )
-				return diff < 0;
-		}
-
-		return used < other.used;
-	}
-
-
-	//! Inequality operator
-	bool operator !=(const uchar16_t* const str) const
-	{
-		return !(*this == str);
-	}
-
-
-	//! Inequality operator
-	bool operator !=(const ustring16<TAlloc>& other) const
-	{
-		return !(*this == other);
-	}
-
-
-	//! Returns the length of a ustring16 in full characters.
-	//! \return Length of a ustring16 in full characters.
-	u32 size() const
-	{
-		const_iterator i(*this, 0);
-		u32 pos = 0;
-		while (!i.atEnd())
-		{
-			++i;
-			++pos;
-		}
-		return pos;
-	}
-
-
-	//! Informs if the ustring is empty or not.
-	//! \return True if the ustring is empty, false if not.
-	bool empty() const
-	{
-		return (size_raw() == 0);
-	}
-
-
-	//! Returns a pointer to the raw UTF-16 string data.
-	//! \return pointer to C-style NUL terminated array of UTF-16 code points.
-	const uchar16_t* c_str() const
-	{
-		return array;
-	}
-
-
-	//! Compares the first n characters of this string with another.
-	//! \param other Other string to compare to.
-	//! \param n Number of characters to compare.
-	//! \return True if the n first characters of both strings are equal.
-	bool equalsn(const ustring16<TAlloc>& other, u32 n) const
-	{
-		u32 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);
-	}
-
-
-	//! Compares the first n characters of this string with another.
-	//! \param str Other string to compare to.
-	//! \param n Number of characters to compare.
-	//! \return True if the n first characters of both strings are equal.
-	bool equalsn(const uchar16_t* const str, u32 n) const
-	{
-		if (!str)
-			return false;
-		u32 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);
-	}
-
-
-	//! Appends a character to this ustring16
-	//! \param character The character to append.
-	//! \return A reference to our current string.
-	ustring16<TAlloc>& append(uchar32_t character)
-	{
-		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;
-	}
-
-
-	//! Appends a UTF-8 string to this ustring16
-	//! \param other The UTF-8 string to append.
-	//! \param length The length of the string to append.
-	//! \return A reference to our current string.
-	ustring16<TAlloc>& append(const uchar8_t* const other, u32 length=0xffffffff)
-	{
-		if (!other)
-			return *this;
-
-		// Determine if the string is long enough for a BOM.
-		u32 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));
-		u32 start = used;
-
-		// Convert UTF-8 to UTF-16.
-		u32 pos = start;
-		for (u32 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;
-	}
-
-
-	//! Appends a UTF-16 string to this ustring16
-	//! \param other The UTF-16 string to append.
-	//! \param length The length of the string to append.
-	//! \return A reference to our current string.
-	ustring16<TAlloc>& append(const uchar16_t* const other, u32 length=0xffffffff)
-	{
-		if (!other)
-			return *this;
-
-		// Determine if the string is long enough for a BOM.
-		u32 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));
-		u32 start = used;
-		used += len;
-
-		// Copy the string now.
-		unicode::EUTF_ENDIAN m_end = getEndianness();
-		for (u32 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;
-	}
-
-
-	//! Appends a UTF-32 string to this ustring16
-	//! \param other The UTF-32 string to append.
-	//! \param length The length of the string to append.
-	//! \return A reference to our current string.
-	ustring16<TAlloc>& append(const uchar32_t* const other, u32 length=0xffffffff)
-	{
-		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.
-		u32 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));
-		u32 start = used;
-
-		// Convert UTF-32 to UTF-16.
-		unicode::EUTF_ENDIAN m_end = getEndianness();
-		u32 pos = start;
-		for (u32 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;
-	}
-
-
-	//! Appends a ustring16 to this ustring16
-	//! \param other The string to append to this one.
-	//! \return A reference to our current string.
-	ustring16<TAlloc>& append(const ustring16<TAlloc>& other)
-	{
-		const uchar16_t* oa = other.c_str();
-
-		u32 len = other.size_raw();
-
-		if (used + len >= allocated)
-			reallocate(used + len);
-
-		for (u32 l=0; l<len; ++l)
-			array[used+l] = oa[l];
-
-		used += len;
-		array[used] = 0;
-
-		return *this;
-	}
-
-
-	//! Appends a certain amount of characters of a ustring16 to this ustring16.
-	//! \param other The string to append to this one.
-	//! \param length How many characters of the other string to add to this one.
-	//! \return A reference to our current string.
-	ustring16<TAlloc>& append(const ustring16<TAlloc>& other, u32 length)
-	{
-		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);
-		u32 l = length;
-		while (!iter.atEnd() && l)
-		{
-			uchar32_t c = *iter;
-			append(c);
-			++iter;
-			--l;
-		}
-
-		return *this;
-	}
-
-
-	//! Reserves some memory.
-	//! \param count The amount of characters to reserve.
-	void reserve(u32 count)
-	{
-		if (count < allocated)
-			return;
-
-		reallocate(count);
-	}
-
-
-	//! Finds first occurrence of character.
-	//! \param c The character to search for.
-	//! \return Position where the character has been found, or -1 if not found.
-	s32 findFirst(uchar32_t c) const
-	{
-		const_iterator i(*this, 0);
-
-		s32 pos = 0;
-		while (!i.atEnd())
-		{
-			uchar32_t t = *i;
-			if (c == t)
-				return pos;
-			++pos;
-			++i;
-		}
-
-		return -1;
-	}
-
-	//! Finds first occurrence of a character of a list.
-	//! \param 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".
-	//! \param count The amount of characters in the list. Usually, this should be strlen(c).
-	//! \return Position where one of the characters has been found, or -1 if not found.
-	s32 findFirstChar(const uchar32_t* const c, u32 count=1) const
-	{
-		if (!c || !count)
-			return -1;
-
-		const_iterator i(*this, 0);
-
-		s32 pos = 0;
-		while (!i.atEnd())
-		{
-			uchar32_t t = *i;
-			for (u32 j=0; j<count; ++j)
-				if (t == c[j])
-					return pos;
-			++pos;
-			++i;
-		}
-
-		return -1;
-	}
-
-
-	//! Finds first position of a character not in a given list.
-	//! \param 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".
-	//! \param count The amount of characters in the list. Usually, this should be strlen(c).
-	//! \return Position where the character has been found, or -1 if not found.
-	s32 findFirstCharNotInList(const uchar32_t* const c, u32 count=1) const
-	{
-		if (!c || !count)
-			return -1;
-
-		const_iterator i(*this, 0);
-
-		s32 pos = 0;
-		while (!i.atEnd())
-		{
-			uchar32_t t = *i;
-			u32 j;
-			for (j=0; j<count; ++j)
-				if (t == c[j])
-					break;
-
-			if (j==count)
-				return pos;
-			++pos;
-			++i;
-		}
-
-		return -1;
-	}
-
-	//! Finds last position of a character not in a given list.
-	//! \param 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".
-	//! \param count The amount of characters in the list. Usually, this should be strlen(c).
-	//! \return Position where the character has been found, or -1 if not found.
-	s32 findLastCharNotInList(const uchar32_t* const c, u32 count=1) const
-	{
-		if (!c || !count)
-			return -1;
-
-		const_iterator i(end());
-		--i;
-
-		s32 pos = size() - 1;
-		while (!i.atStart())
-		{
-			uchar32_t t = *i;
-			u32 j;
-			for (j=0; j<count; ++j)
-				if (t == c[j])
-					break;
-
-			if (j==count)
-				return pos;
-			--pos;
-			--i;
-		}
-
-		return -1;
-	}
-
-	//! Finds next occurrence of character.
-	//! \param c The character to search for.
-	//! \param startPos The position in the string to start searching.
-	//! \return Position where the character has been found, or -1 if not found.
-	s32 findNext(uchar32_t c, u32 startPos) const
-	{
-		const_iterator i(*this, startPos);
-
-		s32 pos = startPos;
-		while (!i.atEnd())
-		{
-			uchar32_t t = *i;
-			if (t == c)
-				return pos;
-			++pos;
-			++i;
-		}
-
-		return -1;
-	}
-
-
-	//! Finds last occurrence of character.
-	//! \param c The character to search for.
-	//! \param start The start position of the reverse search ( default = -1, on end ).
-	//! \return Position where the character has been found, or -1 if not found.
-	s32 findLast(uchar32_t c, s32 start = -1) const
-	{
-		u32 s = size();
-		start = core::clamp ( start < 0 ? (s32)s : start, 0, (s32)s ) - 1;
-
-		const_iterator i(*this, start);
-		u32 pos = start;
-		while (!i.atStart())
-		{
-			uchar32_t t = *i;
-			if (t == c)
-				return pos;
-			--pos;
-			--i;
-		}
-
-		return -1;
-	}
-
-	//! Finds last occurrence of a character in a list.
-	//! \param 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".
-	//! \param count The amount of characters in the list. Usually, this should be strlen(c).
-	//! \return Position where one of the characters has been found, or -1 if not found.
-	s32 findLastChar(const uchar32_t* const c, u32 count=1) const
-	{
-		if (!c || !count)
-			return -1;
-
-		const_iterator i(end());
-		--i;
-
-		s32 pos = size();
-		while (!i.atStart())
-		{
-			uchar32_t t = *i;
-			for (u32 j=0; j<count; ++j)
-				if (t == c[j])
-					return pos;
-			--pos;
-			--i;
-		}
-
-		return -1;
-	}
-
-
-	//! Finds another ustring16 in this ustring16.
-	//! \param str The string to find.
-	//! \param start The start position of the search.
-	//! \return Positions where the ustring16 has been found, or -1 if not found.
-	s32 find(const ustring16<TAlloc>& str, const u32 start = 0) const
-	{
-		u32 my_size = size();
-		u32 their_size = str.size();
-
-		if (their_size == 0 || my_size - start < their_size)
-			return -1;
-
-		const_iterator i(*this, start);
-
-		s32 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 -1;
-	}
-
-
-	//! Finds another ustring16 in this ustring16.
-	//! \param str The string to find.
-	//! \param start The start position of the search.
-	//! \return Positions where the string has been found, or -1 if not found.
-	s32 find_raw(const ustring16<TAlloc>& str, const u32 start = 0) const
-	{
-		const uchar16_t* data = str.c_str();
-		if (data && *data)
-		{
-			u32 len = 0;
-
-			while (data[len])
-				++len;
-
-			if (len > used)
-				return -1;
-
-			for (u32 i=start; i<=used-len; ++i)
-			{
-				u32 j=0;
-
-				while(data[j] && array[i+j] == data[j])
-					++j;
-
-				if (!data[j])
-					return i;
-			}
-		}
-
-		return -1;
-	}
-
-
-	//! Returns a substring.
-	//! \param begin: Start of substring.
-	//! \param length: Length of substring.
-	//! \return A reference to our current string.
-	ustring16<TAlloc> subString(u32 begin, s32 length) const
-	{
-		u32 len = size();
-		// if start after ustring16
-		// or no proper substring length
-		if ((length <= 0) || (begin>=len))
-			return ustring16<TAlloc>("");
-		// clamp length to maximal value
-		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;
-	}
-
-
-	//! Appends a character to this ustring16.
-	//! \param c Character to append.
-	//! \return A reference to our current string.
-	ustring16<TAlloc>& operator += (char c)
-	{
-		append((uchar32_t)c);
-		return *this;
-	}
-
-
-	//! Appends a character to this ustring16.
-	//! \param c Character to append.
-	//! \return A reference to our current string.
-	ustring16<TAlloc>& operator += (uchar32_t c)
-	{
-		append(c);
-		return *this;
-	}
-
-
-	//! Appends a number to this ustring16.
-	//! \param c Number to append.
-	//! \return A reference to our current string.
-	ustring16<TAlloc>& operator += (short c)
-	{
-		append(core::stringc(c));
-		return *this;
-	}
-
-
-	//! Appends a number to this ustring16.
-	//! \param c Number to append.
-	//! \return A reference to our current string.
-	ustring16<TAlloc>& operator += (unsigned short c)
-	{
-		append(core::stringc(c));
-		return *this;
-	}
-
-
-#ifdef USTRING_CPP0X_NEWLITERALS
-	//! Appends a number to this ustring16.
-	//! \param c Number to append.
-	//! \return A reference to our current string.
-	ustring16<TAlloc>& operator += (int c)
-	{
-		append(core::stringc(c));
-		return *this;
-	}
-
-
-	//! Appends a number to this ustring16.
-	//! \param c Number to append.
-	//! \return A reference to our current string.
-	ustring16<TAlloc>& operator += (unsigned int c)
-	{
-		append(core::stringc(c));
-		return *this;
-	}
-#endif
-
-
-	//! Appends a number to this ustring16.
-	//! \param c Number to append.
-	//! \return A reference to our current string.
-	ustring16<TAlloc>& operator += (long c)
-	{
-		append(core::stringc(c));
-		return *this;
-	}
-
-
-	//! Appends a number to this ustring16.
-	//! \param c Number to append.
-	//! \return A reference to our current string.
-	ustring16<TAlloc>& operator += (unsigned long c)
-	{
-		append(core::stringc(c));
-		return *this;
-	}
-
-
-	//! Appends a number to this ustring16.
-	//! \param c Number to append.
-	//! \return A reference to our current string.
-	ustring16<TAlloc>& operator += (double c)
-	{
-		append(core::stringc(c));
-		return *this;
-	}
-
-
-	//! Appends a char ustring16 to this ustring16.
-	//! \param c Char ustring16 to append.
-	//! \return A reference to our current string.
-	ustring16<TAlloc>& operator += (const uchar16_t* const c)
-	{
-		append(c);
-		return *this;
-	}
-
-
-	//! Appends a ustring16 to this ustring16.
-	//! \param other ustring16 to append.
-	//! \return A reference to our current string.
-	ustring16<TAlloc>& operator += (const ustring16<TAlloc>& other)
-	{
-		append(other);
-		return *this;
-	}
-
-
-	//! Replaces all characters of a given type with another one.
-	//! \param toReplace Character to replace.
-	//! \param replaceWith Character replacing the old one.
-	//! \return A reference to our current string.
-	ustring16<TAlloc>& replace(uchar32_t toReplace, uchar32_t replaceWith)
-	{
-		iterator i(*this, 0);
-		while (!i.atEnd())
-		{
-			typename ustring16<TAlloc>::access a = *i;
-			if ((uchar32_t)a == toReplace)
-				a = replaceWith;
-			++i;
-		}
-		return *this;
-	}
-
-
-	//! Replaces all instances of a string with another one.
-	//! \param toReplace The string to replace.
-	//! \param replaceWith The string replacing the old one.
-	//! \return A reference to our current string.
-	ustring16<TAlloc>& replace(const ustring16<TAlloc>& toReplace, const ustring16<TAlloc>& replaceWith)
-	{
-		if (toReplace.size() == 0)
-			return *this;
-
-		const uchar16_t* other = toReplace.c_str();
-		const uchar16_t* replace = replaceWith.c_str();
-		const u32 other_size = toReplace.size_raw();
-		const u32 replace_size = replaceWith.size_raw();
-
-		// Determine the delta.  The algorithm will change depending on the delta.
-		s32 delta = replace_size - other_size;
-
-		// A character for character replace.  The string will not shrink or grow.
-		if (delta == 0)
-		{
-			s32 pos = 0;
-			while ((pos = find_raw(other, pos)) != -1)
-			{
-				for (u32 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 (delta < 0)
-		{
-			u32 i = 0;
-			for (u32 pos = 0; pos <= used; ++i, ++pos)
-			{
-				// Is this potentially a match?
-				if (array[pos] == *other)
-				{
-					// Check to see if we have a match.
-					u32 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;
-		}
-
-		// 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.
-		u32 find_count = 0;
-		s32 pos = 0;
-		while ((pos = find_raw(other, pos)) != -1)
-		{
-			++find_count;
-			++pos;
-		}
-
-		// Re-allocate the string now, if needed.
-		u32 len = delta * find_count;
-		if (used + len >= allocated)
-			reallocate(used + len);
-
-		// Start replacing.
-		pos = 0;
-		while ((pos = find_raw(other, pos)) != -1)
-		{
-			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 (u32 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;
-	}
-
-
-	//! Removes characters from a ustring16..
-	//! \param c The character to remove.
-	//! \return A reference to our current string.
-	ustring16<TAlloc>& remove(uchar32_t c)
-	{
-		u32 pos = 0;
-		u32 found = 0;
-		u32 len = (c > 0xFFFF ? 2 : 1);		// Remove characters equal to the size of c as a UTF-16 character.
-		for (u32 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]);
-			}
-			u32 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;
-	}
-
-
-	//! Removes a ustring16 from the ustring16.
-	//! \param toRemove The string to remove.
-	//! \return A reference to our current string.
-	ustring16<TAlloc>& remove(const ustring16<TAlloc>& toRemove)
-	{
-		u32 size = toRemove.size_raw();
-		if (size == 0) return *this;
-
-		const uchar16_t* tra = toRemove.c_str();
-		u32 pos = 0;
-		u32 found = 0;
-		for (u32 i=0; i<=used; ++i)
-		{
-			u32 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;
-	}
-
-
-	//! Removes characters from the ustring16.
-	//! \param characters The characters to remove.
-	//! \return A reference to our current string.
-	ustring16<TAlloc>& removeChars(const ustring16<TAlloc>& characters)
-	{
-		if (characters.size_raw() == 0)
-			return *this;
-
-		u32 pos = 0;
-		u32 found = 0;
-		const_iterator iter(characters);
-		for (u32 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]);
-			}
-			u32 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;
-	}
-
-
-	//! Trims the ustring16.
-	//! Removes the specified characters (by default, Latin-1 whitespace) from the begining and the end of the ustring16.
-	//! \param whitespace The characters that are to be considered as whitespace.
-	//! \return A reference to our current string.
-	ustring16<TAlloc>& trim(const ustring16<TAlloc>& whitespace = " \t\n\r")
-	{
-		core::array<uchar32_t> utf32white = whitespace.toUTF32();
-
-		// find start and end of the substring without the specified characters
-		const s32 begin = findFirstCharNotInList(utf32white.const_pointer(), whitespace.used + 1);
-		if (begin == -1)
-			return (*this="");
-
-		const s32 end = findLastCharNotInList(utf32white.const_pointer(), whitespace.used + 1);
-
-		return (*this = subString(begin, (end +1) - begin));
-	}
-
-
-	//! Erases a character from the ustring16.
-	//! May be slow, because all elements following after the erased element have to be copied.
-	//! \param index Index of element to be erased.
-	//! \return A reference to our current string.
-	ustring16<TAlloc>& erase(u32 index)
-	{
-		_IRR_DEBUG_BREAK_IF(index>used) // access violation
-
-		iterator i(*this, index);
-
-		uchar32_t t = *i;
-		u32 len = (t > 0xFFFF ? 2 : 1);
-
-		for (u32 j = static_cast<u32>(i.getPos()) + len; j <= used; ++j)
-			array[j - len] = array[j];
-
-		used -= len;
-		array[used] = 0;
-
-		return *this;
-	}
-
-
-	//! Validate the existing ustring16, checking for valid surrogate pairs and checking for proper termination.
-	//! \return A reference to our current string.
-	ustring16<TAlloc>& validate()
-	{
-		// Validate all unicode characters.
-		for (u32 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;
-	}
-
-
-	//! Gets the last char of the ustring16, or 0.
-	//! \return The last char of the ustring16, or 0.
-	uchar32_t lastChar() const
-	{
-		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];
-		}
-	}
-
-
-	//! 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.
-	\param ret The result container
-	\param c C-style ustring16 of delimiter characters
-	\param count Number of delimiter characters
-	\param 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.
-	\param 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.
-	\return The number of resulting substrings
-	*/
-	template<class container>
-	u32 split(container& ret, const uchar32_t* const c, u32 count=1, bool ignoreEmptyTokens=true, bool keepSeparators=false) const
-	{
-		if (!c)
-			return 0;
-
-		const_iterator i(*this);
-		const u32 oldSize=ret.size();
-		u32 pos = 0;
-		u32 lastpos = 0;
-		u32 lastpospos = 0;
-		bool lastWasSeparator = false;
-		while (!i.atEnd())
-		{
-			uchar32_t ch = *i;
-			bool foundSeparator = false;
-			for (u32 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;
-		}
-		u32 s = size() + 1;
-		if (s > lastpos)
-			ret.push_back(ustring16<TAlloc>(&array[lastpospos], s - lastpos));
-		return ret.size()-oldSize;
-	}
-
-
-	//! 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.
-	\param ret The result container
-	\param c A unicode string of delimiter characters
-	\param 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.
-	\param 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.
-	\return The number of resulting substrings
-	*/
-	template<class container>
-	u32 split(container& ret, const ustring16<TAlloc>& c, bool ignoreEmptyTokens=true, bool keepSeparators=false) const
-	{
-		core::array<uchar32_t> v = c.toUTF32();
-		return split(ret, v.pointer(), v.size(), ignoreEmptyTokens, keepSeparators);
-	}
-
-
-	//! Gets the size of the allocated memory buffer for the string.
-	//! \return The size of the allocated memory buffer.
-	u32 capacity() const
-	{
-		return allocated;
-	}
-
-
-	//! Returns the raw number of UTF-16 code points in the string which includes the individual surrogates.
-	//! \return The raw number of UTF-16 code points, excluding the trialing NUL.
-	u32 size_raw() const
-	{
-		return used;
-	}
-
-
-	//! Inserts a character into the string.
-	//! \param c The character to insert.
-	//! \param pos The position to insert the character.
-	//! \return A reference to our current string.
-	ustring16<TAlloc>& insert(uchar32_t c, u32 pos)
-	{
-		u8 len = (c > 0xFFFF ? 2 : 1);
-
-		if (used + len >= allocated)
-			reallocate(used + len);
-
-		used += len;
-
-		iterator iter(*this, pos);
-		for (u32 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;
-	}
-
-
-	//! Inserts a string into the string.
-	//! \param c The string to insert.
-	//! \param pos The position to insert the string.
-	//! \return A reference to our current string.
-	ustring16<TAlloc>& insert(const ustring16<TAlloc>& c, u32 pos)
-	{
-		u32 len = c.size_raw();
-		if (len == 0) return *this;
-
-		if (used + len >= allocated)
-			reallocate(used + len);
-
-		used += len;
-
-		iterator iter(*this, pos);
-		for (u32 i = used - 2; i > iter.getPos() + len; --i)
-			array[i] = array[i - len];
-
-		const uchar16_t* s = c.c_str();
-		for (u32 i = 0; i < len; ++i)
-		{
-			array[pos++] = *s;
-			++s;
-		}
-
-		array[used] = 0;
-		return *this;
-	}
-
-
-	//! Inserts a character into the string.
-	//! \param c The character to insert.
-	//! \param pos The position to insert the character.
-	//! \return A reference to our current string.
-	ustring16<TAlloc>& insert_raw(uchar16_t c, u32 pos)
-	{
-		if (used + 1 >= allocated)
-			reallocate(used + 1);
-
-		++used;
-
-		for (u32 i = used - 1; i > pos; --i)
-			array[i] = array[i - 1];
-
-		array[pos] = c;
-		array[used] = 0;
-		return *this;
-	}
-
-
-	//! Removes a character from string.
-	//! \param pos Position of the character to remove.
-	//! \return A reference to our current string.
-	ustring16<TAlloc>& erase_raw(u32 pos)
-	{
-		for (u32 i=pos; i<=used; ++i)
-		{
-			array[i] = array[i + 1];
-		}
-		--used;
-		array[used] = 0;
-		return *this;
-	}
-
-
-	//! Replaces a character in the string.
-	//! \param c The new character.
-	//! \param pos The position of the character to replace.
-	//! \return A reference to our current string.
-	ustring16<TAlloc>& replace_raw(uchar16_t c, u32 pos)
-	{
-		array[pos] = c;
-		return *this;
-	}
-
-
-	//! Returns an iterator to the beginning of the string.
-	//! \return An iterator to the beginning of the string.
-	iterator begin()
-	{
-		iterator i(*this, 0);
-		return i;
-	}
-
-
-	//! Returns an iterator to the beginning of the string.
-	//! \return An iterator to the beginning of the string.
-	const_iterator begin() const
-	{
-		const_iterator i(*this, 0);
-		return i;
-	}
-
-
-	//! Returns an iterator to the beginning of the string.
-	//! \return An iterator to the beginning of the string.
-	const_iterator cbegin() const
-	{
-		const_iterator i(*this, 0);
-		return i;
-	}
-
-
-	//! Returns an iterator to the end of the string.
-	//! \return An iterator to the end of the string.
-	iterator end()
-	{
-		iterator i(*this, 0);
-		i.toEnd();
-		return i;
-	}
-
-
-	//! Returns an iterator to the end of the string.
-	//! \return An iterator to the end of the string.
-	const_iterator end() const
-	{
-		const_iterator i(*this, 0);
-		i.toEnd();
-		return i;
-	}
-
-
-	//! Returns an iterator to the end of the string.
-	//! \return An iterator to the end of the string.
-	const_iterator cend() const
-	{
-		const_iterator i(*this, 0);
-		i.toEnd();
-		return i;
-	}
-
-
-	//! Converts the string to a UTF-8 encoded string.
-	//! \param addBOM If true, the proper unicode byte-order mark will be prefixed to the string.
-	//! \return A string containing the UTF-8 encoded string.
-	core::string<uchar8_t> toUTF8_s(const bool addBOM = false) const
-	{
-		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;
-	}
-
-
-	//! Converts the string to a UTF-8 encoded string array.
-	//! \param addBOM If true, the proper unicode byte-order mark will be prefixed to the string.
-	//! \return An array containing the UTF-8 encoded string.
-	core::array<uchar8_t> toUTF8(const bool addBOM = false) const
-	{
-		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;
-	}
-
-
-#ifdef USTRING_CPP0X_NEWLITERALS	// C++0x
-	//! Converts the string to a UTF-16 encoded string.
-	//! \param endian The desired endianness of the string.
-	//! \param addBOM If true, the proper unicode byte-order mark will be prefixed to the string.
-	//! \return A string containing the UTF-16 encoded string.
-	core::string<char16_t> toUTF16_s(const unicode::EUTF_ENDIAN endian = unicode::EUTFEE_NATIVE, const bool addBOM = false) const
-	{
-		core::string<char16_t> ret;
-		ret.reserve(used + (addBOM ? unicode::BOM_UTF16_LEN : 0) + 1);
-
-		// Add the BOM if specified.
-		if (addBOM)
-		{
-			if (endian == unicode::EUTFEE_NATIVE)
-				ret[0] = unicode::BOM;
-			else if (endian == unicode::EUTFEE_LITTLE)
-			{
-				uchar8_t* ptr8 = reinterpret_cast<uchar8_t*>(ret.c_str());
-				*ptr8++ = unicode::BOM_ENCODE_UTF16_LE[0];
-				*ptr8 = unicode::BOM_ENCODE_UTF16_LE[1];
-			}
-			else
-			{
-				uchar8_t* ptr8 = reinterpret_cast<uchar8_t*>(ret.c_str());
-				*ptr8++ = unicode::BOM_ENCODE_UTF16_BE[0];
-				*ptr8 = unicode::BOM_ENCODE_UTF16_BE[1];
-			}
-		}
-
-		ret.append(array);
-		if (endian != unicode::EUTFEE_NATIVE && getEndianness() != endian)
-		{
-			char16_t* ptr = ret.c_str();
-			for (u32 i = 0; i < ret.size(); ++i)
-				*ptr++ = unicode::swapEndian16(*ptr);
-		}
-		return ret;
-	}
-#endif
-
-
-	//! Converts the string to a UTF-16 encoded string array.
-	//! Unfortunately, no toUTF16_s() version exists due to limitations with Irrlicht's string class.
-	//! \param endian The desired endianness of the string.
-	//! \param addBOM If true, the proper unicode byte-order mark will be prefixed to the string.
-	//! \return An array containing the UTF-16 encoded string.
-	core::array<uchar16_t> toUTF16(const unicode::EUTF_ENDIAN endian = unicode::EUTFEE_NATIVE, const bool addBOM = false) const
-	{
-		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 (u32 i = 0; i <= used; ++i)
-				ptr[i] = unicode::swapEndian16(ptr[i]);
-		}
-		ret.set_used(used + (addBOM ? unicode::BOM_UTF16_LEN : 0));
-		ret.push_back(0);
-		return ret;
-	}
-
-
-#ifdef USTRING_CPP0X_NEWLITERALS	// C++0x
-	//! Converts the string to a UTF-32 encoded string.
-	//! \param endian The desired endianness of the string.
-	//! \param addBOM If true, the proper unicode byte-order mark will be prefixed to the string.
-	//! \return A string containing the UTF-32 encoded string.
-	core::string<char32_t> toUTF32_s(const unicode::EUTF_ENDIAN endian = unicode::EUTFEE_NATIVE, const bool addBOM = false) const
-	{
-		core::string<char32_t> ret;
-		ret.reserve(size() + 1 + (addBOM ? unicode::BOM_UTF32_LEN : 0));
-		const_iterator iter(*this, 0);
-
-		// Add the BOM if specified.
-		if (addBOM)
-		{
-			if (endian == unicode::EUTFEE_NATIVE)
-				ret.append(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.append(t.full);
-			}
-		}
-
-		while (!iter.atEnd())
-		{
-			uchar32_t c = *iter;
-			if (endian != unicode::EUTFEE_NATIVE && getEndianness() != endian)
-				c = unicode::swapEndian32(c);
-			ret.append(c);
-			++iter;
-		}
-		return ret;
-	}
-#endif
-
-
-	//! Converts the string to a UTF-32 encoded string array.
-	//! Unfortunately, no toUTF32_s() version exists due to limitations with Irrlicht's string class.
-	//! \param endian The desired endianness of the string.
-	//! \param addBOM If true, the proper unicode byte-order mark will be prefixed to the string.
-	//! \return An array containing the UTF-32 encoded string.
-	core::array<uchar32_t> toUTF32(const unicode::EUTF_ENDIAN endian = unicode::EUTFEE_NATIVE, const bool addBOM = false) const
-	{
-		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;
-	}
-
-
-	//! 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. **/
-	//! \param endian The desired endianness of the string.
-	//! \param addBOM If true, the proper unicode byte-order mark will be prefixed to the string.
-	//! \return A string containing the wchar_t encoded string.
-	core::string<wchar_t> toWCHAR_s(const unicode::EUTF_ENDIAN endian = unicode::EUTFEE_NATIVE, const bool addBOM = false) const
-	{
-		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();
-	}
-
-
-	//! 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. **/
-	//! \param endian The desired endianness of the string.
-	//! \param addBOM If true, the proper unicode byte-order mark will be prefixed to the string.
-	//! \return An array containing the wchar_t encoded string.
-	core::array<wchar_t> toWCHAR(const unicode::EUTF_ENDIAN endian = unicode::EUTFEE_NATIVE, const bool addBOM = false) const
-	{
-		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>();
-	}
-
-	//! Converts the string to a properly encoded io::path string.
-	//! \param endian The desired endianness of the string.
-	//! \param addBOM If true, the proper unicode byte-order mark will be prefixed to the string.
-	//! \return An io::path string containing the properly encoded string.
-	io::path toPATH_s(const unicode::EUTF_ENDIAN endian = unicode::EUTFEE_NATIVE, const bool addBOM = false) const
-	{
-#if defined(_IRR_WCHAR_FILESYSTEM)
-		return toWCHAR_s(endian, addBOM);
-#else
-		return toUTF8_s(addBOM);
-#endif
-	}
-
-	//! Loads an unknown stream of data.
-	//! Will attempt to determine if the stream is unicode data.  Useful for loading from files.
-	//! \param data The data stream to load from.
-	//! \param data_size The length of the data string.
-	//! \return A reference to our current string.
-	ustring16<TAlloc>& loadDataStream(const char* data, size_t data_size)
-	{
-		// 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;
-	}
-
-	//! Gets the encoding of the Unicode string this class contains.
-	//! \return An enum describing the current encoding of this string.
-	const unicode::EUTF_ENCODE getEncoding() const
-	{
-		return encoding;
-	}
-
-	//! Gets the endianness of the Unicode string this class contains.
-	//! \return An enum describing the endianness of this string.
-	const unicode::EUTF_ENDIAN getEndianness() const
-	{
-		if (encoding == unicode::EUTFE_UTF16_LE ||
-			encoding == unicode::EUTFE_UTF32_LE)
-			return unicode::EUTFEE_LITTLE;
-		else return unicode::EUTFEE_BIG;
-	}
-
-private:
-
-	//! Reallocate the string, making it bigger or smaller.
-	//! \param new_size The new size of the string.
-	void reallocate(u32 new_size)
-	{
-		uchar16_t* old_array = array;
-
-		array = allocator.allocate(new_size + 1); //new u16[new_size];
-		allocated = new_size + 1;
-		if (old_array == 0) return;
-
-		u32 amount = used < new_size ? used : new_size;
-		for (u32 i=0; i<=amount; ++i)
-			array[i] = old_array[i];
-
-		if (allocated <= used)
-			used = allocated - 1;
-
-		array[used] = 0;
-
-		allocator.deallocate(old_array); // delete [] old_array;
-	}
-
-	//--- member variables
-
-	uchar16_t* array;
-	unicode::EUTF_ENCODE encoding;
-	u32 allocated;
-	u32 used;
-	TAlloc allocator;
-	//irrAllocator<uchar16_t> allocator;
-};
-
-typedef ustring16<irrAllocator<uchar16_t> > ustring;
-
-
-//! Appends two ustring16s.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const ustring16<TAlloc>& right)
-{
-	ustring16<TAlloc> ret(left);
-	ret += right;
-	return ret;
-}
-
-
-//! Appends a ustring16 and a null-terminated unicode string.
-template <typename TAlloc, class B>
-inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const B* const right)
-{
-	ustring16<TAlloc> ret(left);
-	ret += right;
-	return ret;
-}
-
-
-//! Appends a ustring16 and a null-terminated unicode string.
-template <class B, typename TAlloc>
-inline ustring16<TAlloc> operator+(const B* const left, const ustring16<TAlloc>& right)
-{
-	ustring16<TAlloc> ret(left);
-	ret += right;
-	return ret;
-}
-
-
-//! Appends a ustring16 and an Irrlicht string.
-template <typename TAlloc, typename B, typename BAlloc>
-inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const string<B, BAlloc>& right)
-{
-	ustring16<TAlloc> ret(left);
-	ret += right;
-	return ret;
-}
-
-
-//! Appends a ustring16 and an Irrlicht string.
-template <typename TAlloc, typename B, typename BAlloc>
-inline ustring16<TAlloc> operator+(const string<B, BAlloc>& left, const ustring16<TAlloc>& right)
-{
-	ustring16<TAlloc> ret(left);
-	ret += right;
-	return ret;
-}
-
-
-//! Appends a ustring16 and a std::basic_string.
-template <typename TAlloc, typename B, typename A, typename BAlloc>
-inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const std::basic_string<B, A, BAlloc>& right)
-{
-	ustring16<TAlloc> ret(left);
-	ret += right;
-	return ret;
-}
-
-
-//! Appends a ustring16 and a std::basic_string.
-template <typename TAlloc, typename B, typename A, typename BAlloc>
-inline ustring16<TAlloc> operator+(const std::basic_string<B, A, BAlloc>& left, const ustring16<TAlloc>& right)
-{
-	ustring16<TAlloc> ret(left);
-	ret += right;
-	return ret;
-}
-
-
-//! Appends a ustring16 and a char.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const char right)
-{
-	ustring16<TAlloc> ret(left);
-	ret += right;
-	return ret;
-}
-
-
-//! Appends a ustring16 and a char.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(const char left, const ustring16<TAlloc>& right)
-{
-	ustring16<TAlloc> ret(left);
-	ret += right;
-	return ret;
-}
-
-
-#ifdef USTRING_CPP0X_NEWLITERALS
-//! Appends a ustring16 and a uchar32_t.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const uchar32_t right)
-{
-	ustring16<TAlloc> ret(left);
-	ret += right;
-	return ret;
-}
-
-
-//! Appends a ustring16 and a uchar32_t.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(const uchar32_t left, const ustring16<TAlloc>& right)
-{
-	ustring16<TAlloc> ret(left);
-	ret += right;
-	return ret;
-}
-#endif
-
-
-//! Appends a ustring16 and a short.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const short right)
-{
-	ustring16<TAlloc> ret(left);
-	ret += core::stringc(right);
-	return ret;
-}
-
-
-//! Appends a ustring16 and a short.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(const short left, const ustring16<TAlloc>& right)
-{
-	ustring16<TAlloc> ret((core::stringc(left)));
-	ret += right;
-	return ret;
-}
-
-
-//! Appends a ustring16 and an unsigned short.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const unsigned short right)
-{
-	ustring16<TAlloc> ret(left);
-	ret += core::stringc(right);
-	return ret;
-}
-
-
-//! Appends a ustring16 and an unsigned short.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(const unsigned short left, const ustring16<TAlloc>& right)
-{
-	ustring16<TAlloc> ret((core::stringc(left)));
-	ret += right;
-	return ret;
-}
-
-
-//! Appends a ustring16 and an int.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const int right)
-{
-	ustring16<TAlloc> ret(left);
-	ret += core::stringc(right);
-	return ret;
-}
-
-
-//! Appends a ustring16 and an int.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(const int left, const ustring16<TAlloc>& right)
-{
-	ustring16<TAlloc> ret((core::stringc(left)));
-	ret += right;
-	return ret;
-}
-
-
-//! Appends a ustring16 and an unsigned int.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const unsigned int right)
-{
-	ustring16<TAlloc> ret(left);
-	ret += core::stringc(right);
-	return ret;
-}
-
-
-//! Appends a ustring16 and an unsigned int.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(const unsigned int left, const ustring16<TAlloc>& right)
-{
-	ustring16<TAlloc> ret((core::stringc(left)));
-	ret += right;
-	return ret;
-}
-
-
-//! Appends a ustring16 and a long.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const long right)
-{
-	ustring16<TAlloc> ret(left);
-	ret += core::stringc(right);
-	return ret;
-}
-
-
-//! Appends a ustring16 and a long.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(const long left, const ustring16<TAlloc>& right)
-{
-	ustring16<TAlloc> ret((core::stringc(left)));
-	ret += right;
-	return ret;
-}
-
-
-//! Appends a ustring16 and an unsigned long.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const unsigned long right)
-{
-	ustring16<TAlloc> ret(left);
-	ret += core::stringc(right);
-	return ret;
-}
-
-
-//! Appends a ustring16 and an unsigned long.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(const unsigned long left, const ustring16<TAlloc>& right)
-{
-	ustring16<TAlloc> ret((core::stringc(left)));
-	ret += right;
-	return ret;
-}
-
-
-//! Appends a ustring16 and a float.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const float right)
-{
-	ustring16<TAlloc> ret(left);
-	ret += core::stringc(right);
-	return ret;
-}
-
-
-//! Appends a ustring16 and a float.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(const float left, const ustring16<TAlloc>& right)
-{
-	ustring16<TAlloc> ret((core::stringc(left)));
-	ret += right;
-	return ret;
-}
-
-
-//! Appends a ustring16 and a double.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const double right)
-{
-	ustring16<TAlloc> ret(left);
-	ret += core::stringc(right);
-	return ret;
-}
-
-
-//! Appends a ustring16 and a double.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(const double left, const ustring16<TAlloc>& right)
-{
-	ustring16<TAlloc> ret((core::stringc(left)));
-	ret += right;
-	return ret;
-}
-
-
-#ifdef USTRING_CPP0X
-//! Appends two ustring16s.
-template <typename TAlloc>
-inline ustring16<TAlloc>&& operator+(const ustring16<TAlloc>& left, ustring16<TAlloc>&& right)
-{
-	//std::cout << "MOVE operator+(&, &&)" << std::endl;
-	right.insert(left, 0);
-	return std::move(right);
-}
-
-
-//! Appends two ustring16s.
-template <typename TAlloc>
-inline ustring16<TAlloc>&& operator+(ustring16<TAlloc>&& left, const ustring16<TAlloc>& right)
-{
-	//std::cout << "MOVE operator+(&&, &)" << std::endl;
-	left.append(right);
-	return std::move(left);
-}
-
-
-//! Appends two ustring16s.
-template <typename TAlloc>
-inline ustring16<TAlloc>&& operator+(ustring16<TAlloc>&& left, ustring16<TAlloc>&& right)
-{
-	//std::cout << "MOVE operator+(&&, &&)" << std::endl;
-	if ((right.size_raw() <= left.capacity() - left.size_raw()) ||
-		(right.capacity() - right.size_raw() < left.size_raw()))
-	{
-		left.append(right);
-		return std::move(left);
-	}
-	else
-	{
-		right.insert(left, 0);
-		return std::move(right);
-	}
-}
-
-
-//! Appends a ustring16 and a null-terminated unicode string.
-template <typename TAlloc, class B>
-inline ustring16<TAlloc>&& operator+(ustring16<TAlloc>&& left, const B* const right)
-{
-	//std::cout << "MOVE operator+(&&, B*)" << std::endl;
-	left.append(right);
-	return std::move(left);
-}
-
-
-//! Appends a ustring16 and a null-terminated unicode string.
-template <class B, typename TAlloc>
-inline ustring16<TAlloc>&& operator+(const B* const left, ustring16<TAlloc>&& right)
-{
-	//std::cout << "MOVE operator+(B*, &&)" << std::endl;
-	right.insert(left, 0);
-	return std::move(right);
-}
-
-
-//! Appends a ustring16 and an Irrlicht string.
-template <typename TAlloc, typename B, typename BAlloc>
-inline ustring16<TAlloc>&& operator+(const string<B, BAlloc>& left, ustring16<TAlloc>&& right)
-{
-	//std::cout << "MOVE operator+(&, &&)" << std::endl;
-	right.insert(left, 0);
-	return std::move(right);
-}
-
-
-//! Appends a ustring16 and an Irrlicht string.
-template <typename TAlloc, typename B, typename BAlloc>
-inline ustring16<TAlloc>&& operator+(ustring16<TAlloc>&& left, const string<B, BAlloc>& right)
-{
-	//std::cout << "MOVE operator+(&&, &)" << std::endl;
-	left.append(right);
-	return std::move(left);
-}
-
-
-//! Appends a ustring16 and a std::basic_string.
-template <typename TAlloc, typename B, typename A, typename BAlloc>
-inline ustring16<TAlloc>&& operator+(const std::basic_string<B, A, BAlloc>& left, ustring16<TAlloc>&& right)
-{
-	//std::cout << "MOVE operator+(&, &&)" << std::endl;
-	right.insert(core::ustring16<TAlloc>(left), 0);
-	return std::move(right);
-}
-
-
-//! Appends a ustring16 and a std::basic_string.
-template <typename TAlloc, typename B, typename A, typename BAlloc>
-inline ustring16<TAlloc>&& operator+(ustring16<TAlloc>&& left, const std::basic_string<B, A, BAlloc>& right)
-{
-	//std::cout << "MOVE operator+(&&, &)" << std::endl;
-	left.append(right);
-	return std::move(left);
-}
-
-
-//! Appends a ustring16 and a char.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(ustring16<TAlloc>&& left, const char right)
-{
-	left.append((uchar32_t)right);
-	return std::move(left);
-}
-
-
-//! Appends a ustring16 and a char.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(const char left, ustring16<TAlloc>&& right)
-{
-	right.insert((uchar32_t)left, 0);
-	return std::move(right);
-}
-
-
-#ifdef USTRING_CPP0X_NEWLITERALS
-//! Appends a ustring16 and a uchar32_t.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(ustring16<TAlloc>&& left, const uchar32_t right)
-{
-	left.append(right);
-	return std::move(left);
-}
-
-
-//! Appends a ustring16 and a uchar32_t.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(const uchar32_t left, ustring16<TAlloc>&& right)
-{
-	right.insert(left, 0);
-	return std::move(right);
-}
-#endif
-
-
-//! Appends a ustring16 and a short.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(ustring16<TAlloc>&& left, const short right)
-{
-	left.append(core::stringc(right));
-	return std::move(left);
-}
-
-
-//! Appends a ustring16 and a short.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(const short left, ustring16<TAlloc>&& right)
-{
-	right.insert(core::stringc(left), 0);
-	return std::move(right);
-}
-
-
-//! Appends a ustring16 and an unsigned short.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(ustring16<TAlloc>&& left, const unsigned short right)
-{
-	left.append(core::stringc(right));
-	return std::move(left);
-}
-
-
-//! Appends a ustring16 and an unsigned short.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(const unsigned short left, ustring16<TAlloc>&& right)
-{
-	right.insert(core::stringc(left), 0);
-	return std::move(right);
-}
-
-
-//! Appends a ustring16 and an int.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(ustring16<TAlloc>&& left, const int right)
-{
-	left.append(core::stringc(right));
-	return std::move(left);
-}
-
-
-//! Appends a ustring16 and an int.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(const int left, ustring16<TAlloc>&& right)
-{
-	right.insert(core::stringc(left), 0);
-	return std::move(right);
-}
-
-
-//! Appends a ustring16 and an unsigned int.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(ustring16<TAlloc>&& left, const unsigned int right)
-{
-	left.append(core::stringc(right));
-	return std::move(left);
-}
-
-
-//! Appends a ustring16 and an unsigned int.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(const unsigned int left, ustring16<TAlloc>&& right)
-{
-	right.insert(core::stringc(left), 0);
-	return std::move(right);
-}
-
-
-//! Appends a ustring16 and a long.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(ustring16<TAlloc>&& left, const long right)
-{
-	left.append(core::stringc(right));
-	return std::move(left);
-}
-
-
-//! Appends a ustring16 and a long.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(const long left, ustring16<TAlloc>&& right)
-{
-	right.insert(core::stringc(left), 0);
-	return std::move(right);
-}
-
-
-//! Appends a ustring16 and an unsigned long.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(ustring16<TAlloc>&& left, const unsigned long right)
-{
-	left.append(core::stringc(right));
-	return std::move(left);
-}
-
-
-//! Appends a ustring16 and an unsigned long.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(const unsigned long left, ustring16<TAlloc>&& right)
-{
-	right.insert(core::stringc(left), 0);
-	return std::move(right);
-}
-
-
-//! Appends a ustring16 and a float.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(ustring16<TAlloc>&& left, const float right)
-{
-	left.append(core::stringc(right));
-	return std::move(left);
-}
-
-
-//! Appends a ustring16 and a float.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(const float left, ustring16<TAlloc>&& right)
-{
-	right.insert(core::stringc(left), 0);
-	return std::move(right);
-}
-
-
-//! Appends a ustring16 and a double.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(ustring16<TAlloc>&& left, const double right)
-{
-	left.append(core::stringc(right));
-	return std::move(left);
-}
-
-
-//! Appends a ustring16 and a double.
-template <typename TAlloc>
-inline ustring16<TAlloc> operator+(const double left, ustring16<TAlloc>&& right)
-{
-	right.insert(core::stringc(left), 0);
-	return std::move(right);
-}
-#endif
-
-
-#ifndef USTRING_NO_STL
-//! Writes a ustring16 to an ostream.
-template <typename TAlloc>
-inline std::ostream& operator<<(std::ostream& out, const ustring16<TAlloc>& in)
-{
-	out << in.toUTF8_s().c_str();
-	return out;
-}
-
-//! Writes a ustring16 to a wostream.
-template <typename TAlloc>
-inline std::wostream& operator<<(std::wostream& out, const ustring16<TAlloc>& in)
-{
-	out << in.toWCHAR_s().c_str();
-	return out;
-}
-#endif
-
-
-#ifndef USTRING_NO_STL
-
-namespace unicode
-{
-
-//! Hashing algorithm for hashing a ustring.  Used for things like unordered_maps.
-//! Algorithm taken from std::hash<std::string>.
-class hash : public std::unary_function<core::ustring, size_t>
-{
-	public:
-		size_t operator()(const core::ustring& s) const
-		{
-			size_t ret = 2166136261U;
-			size_t index = 0;
-			size_t stride = 1 + s.size_raw() / 10;
-
-			core::ustring::const_iterator i = s.begin();
-			while (i != s.end())
-			{
-				// TODO: Don't force u32 on an x64 OS.  Make it agnostic.
-				ret = 16777619U * ret ^ (size_t)s[(u32)index];
-				index += stride;
-				i += stride;
-			}
-			return (ret);
-		}
-};
-
-} // end namespace unicode
-
-#endif
-
-} // end namespace core
-} // end namespace irr
-
-#endif