Removing cegui-{0.5,0.6,0.7}. Use cegui instead

4 files changed, 0 insertions, 5747 deletions

diff --git a/pcr/cegui-0.5/CEGUIString.h b/pcr/cegui-0.5/CEGUIString.h
deleted file mode 100644
index 13a61ba15..000000000
--- a/pcr/cegui-0.5/CEGUIString.h
+++ /dev/null
@@ -1,5603 +0,0 @@
-/***********************************************************************
-	filename: 	CEGUIString.h
-	created:	26/2/2004
-	author:		Paul D Turner
-	
-	purpose:	Defines string class used within the GUI system.
-*************************************************************************/
-/***************************************************************************
- *   Copyright (C) 2004 - 2006 Paul D Turner & The CEGUI Development Team
- *
- *   Permission is hereby granted, free of charge, to any person obtaining
- *   a copy of this software and associated documentation files (the
- *   "Software"), to deal in the Software without restriction, including
- *   without limitation the rights to use, copy, modify, merge, publish,
- *   distribute, sublicense, and/or sell copies of the Software, and to
- *   permit persons to whom the Software is furnished to do so, subject to
- *   the following conditions:
- *
- *   The above copyright notice and this permission notice shall be
- *   included in all copies or substantial portions of the Software.
- *
- *   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- *   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- *   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- *   IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
- *   OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- *   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- *   OTHER DEALINGS IN THE SOFTWARE.
- ***************************************************************************/
-#ifndef _CEGUIString_h_
-#define _CEGUIString_h_
-
-#include "CEGUIBase.h"
-#include <string>
-#include <string.h>
-#include <stdexcept>
-
-// Start of CEGUI namespace section
-namespace CEGUI
-{
-#define STR_QUICKBUFF_SIZE	32
-	/*************************************************************************
-		Basic Types
-	*************************************************************************/
-	typedef		uint8	utf8;
-	//typedef		uint16	utf16;  // removed typedef to prevent usage, as utf16 is not supported (yet)
-	typedef		uint32	utf32;
-
-/*!
-\brief
-	String class used within the GUI system.
-
-	For the most part, this class can replace std::string in basic usage.  However, currently String does not use the
-	current locale, and also comparisons do not take into account the Unicode data tables, so are not 'correct'
-	as such.
-*/
-class CEGUIEXPORT String
-{
-public:
-	/*************************************************************************
-		Integral Types
-	*************************************************************************/
-	typedef		utf32			value_type;					//!< Basic 'code point' type used for String (utf32)
-	typedef		size_t			size_type;					//!< Unsigned type used for size values and indices
-	typedef		std::ptrdiff_t		difference_type;			//!< Signed type used for differences
-	typedef		utf32&			reference;					//!< Type used for utf32 code point references
-	typedef		const utf32&	const_reference;			//!< Type used for constant utf32 code point references
-	typedef		utf32*			pointer;					//!< Type used for utf32 code point pointers
-	typedef		const utf32*	const_pointer;				//!< Type used for constant utf32 code point pointers
-
-	static const size_type		npos;						//!< Value used to represent 'not found' conditions and 'all code points' etc.
-
-private:
-	/*************************************************************************
-		Implementation data
-	*************************************************************************/
-	size_type	d_cplength;			//!< holds length of string in code points (not including null termination)
-	size_type	d_reserve;			//!< code point reserve size (currently allocated buffer size in code points).
-
-	mutable utf8*		d_encodedbuff;		//!< holds string data encoded as utf8 (generated only by calls to c_str() and data())
-	mutable size_type	d_encodeddatlen;	//!< holds length of encoded data (in case it's smaller than buffer).
-	mutable size_type	d_encodedbufflen;	//!< length of above buffer (since buffer can be bigger then the data it holds to save re-allocations).
-
-	utf32		d_quickbuff[STR_QUICKBUFF_SIZE];	//!< This is a integrated 'quick' buffer to save allocations for smallish strings
-	utf32*		d_buffer;							//!< Pointer the the main buffer memory.  This is only valid when quick-buffer is not being used
-
-public:
-	/*************************************************************************
-		Iterator Classes
-	*************************************************************************/
-	/*!
-	\brief
-		Constant forward iterator class for String objects
-	*/
-#if defined(_MSC_VER) && (_MSC_VER <= 1200)
-	class const_iterator : public std::iterator<std::random_access_iterator_tag, utf32>
-#else
-	class const_iterator : public std::iterator<std::random_access_iterator_tag, utf32, std::ptrdiff_t, const utf32*, const utf32&>
-#endif
-	{
-
-	public:
-		//////////////////////////////////////////////////////////////////////////
-		// data
-		//////////////////////////////////////////////////////////////////////////
-		const utf32*	d_ptr;
-
-
-		//////////////////////////////////////////////////////////////////////////
-		// Methods
-		//////////////////////////////////////////////////////////////////////////
-		const_iterator(void)
-		{
-			d_ptr = 0;
-		}
-		const_iterator(const_pointer ptr)
-		{
-			d_ptr = ptr;
-		}
-
-		const_reference	operator*() const
-		{
-			return *d_ptr;
-		}
-
-#if defined(_MSC_VER) && (_MSC_VER <= 1200)
-#	pragma warning (push)
-#	pragma warning (disable : 4284)
-#endif
-		const_pointer	operator->() const		
-		{
-			return &**this;
-		}
-
-#if defined(_MSC_VER) && (_MSC_VER <= 1200)
-#	pragma warning (pop)
-#endif
-
-		const_iterator&	operator++()
-		{
-			++d_ptr;
-			return *this;
-		}
-
-		const_iterator	operator++(int)		
-		{
-			const_iterator temp = *this;
-			++*this;
-			return temp;
-		}
-
-		const_iterator&	operator--()
-		{
-			--d_ptr;
-			return *this;
-		}
-
-		const_iterator	operator--(int)		
-		{
-			const_iterator temp = *this;
-			--*this;
-			return temp;
-		}
-
-		const_iterator& operator+=(difference_type offset)
-		{
-			d_ptr += offset;
-			return *this;
-		}
-
-		const_iterator operator+(difference_type offset) const
-		{
-			const_iterator temp = *this;
-			return temp += offset;
-		}
-
-		const_iterator& operator-=(difference_type offset)
-		{
-			return *this += -offset;
-		}
-
-		const_iterator operator-(difference_type offset) const
-		{
-			const_iterator temp = *this;
-			return temp -= offset;
-		}
-
-		difference_type operator-(const const_iterator& iter) const
-		{
-			return d_ptr - iter.d_ptr;
-		}
-
-		const_reference operator[](difference_type offset) const
-		{
-			return *(*this + offset);
-		}
-
-		bool operator==(const const_iterator& iter) const
-		{
-			return d_ptr == iter.d_ptr;
-		}
-
-		bool operator!=(const const_iterator& iter) const
-		{
-			return !(*this == iter);
-		}
-
-		bool operator<(const const_iterator& iter) const
-		{
-			return d_ptr < iter.d_ptr;
-		}
-
-		bool operator>(const const_iterator& iter) const
-		{
-			return (!(iter < *this));
-		}
-
-		bool operator<=(const const_iterator& iter) const
-		{
-			return (!(iter < *this));
-		}
-
-		bool operator>=(const const_iterator& iter) const
-		{
-			return (!(*this < iter));
-		}
-
-		friend const_iterator operator+(difference_type offset, const const_iterator& iter)
-		{
-			return iter + offset;
-		}
-
-	};
-
-	/*!
-	\brief
-		Forward iterator class for String objects
-	*/
-	class iterator : public const_iterator
-	{
-	public:
-		iterator(void) {}
-		iterator(pointer ptr) : const_iterator(ptr) {}
-
-
-		reference operator*() const
-		{
-			return ((reference)**(const_iterator *)this);
-		}
-
-#if defined(_MSC_VER) && (_MSC_VER <= 1200)
-#	pragma warning (push)
-#	pragma warning (disable : 4284)
-#endif
-
-		pointer operator->() const
-		{
-			return &**this;
-		}
-
-#if defined(_MSC_VER) && (_MSC_VER <= 1200)
-#	pragma warning (pop)
-#endif
-
-		iterator& operator++()
-		{
-			++this->d_ptr;
-			return *this;
-		}
-
-		iterator operator++(int)
-		{
-			iterator temp = *this;
-			++*this;
-			return temp;
-		}
-
-		iterator& operator--()
-		{
-			--this->d_ptr;
-			return *this;
-		}
-
-		iterator operator--(int)
-		{
-			iterator temp = *this;
-			--*this;
-			return temp;
-		}
-
-		iterator& operator+=(difference_type offset)
-		{
-			this->d_ptr += offset;
-			return *this;
-		}
-
-		iterator operator+(difference_type offset) const
-		{
-			iterator temp = *this;
-			return temp + offset;
-		}
-
-		iterator& operator-=(difference_type offset)
-		{
-			return *this += -offset;
-		}
-
-		iterator operator-(difference_type offset) const
-		{
-			iterator temp = *this;
-			return temp -= offset;
-		}
-
-		difference_type operator-(const const_iterator& iter) const
-		{
-			return ((const_iterator)*this - iter);
-		}
-
-		reference operator[](difference_type offset) const
-		{
-			return *(*this + offset);
-		}
-
-		friend iterator operator+(difference_type offset, const iterator& iter)
-		{
-			return iter + offset;
-		}
-
-	};
-
-	/*!
-	\brief
-		Constant reverse iterator class for String objects
-	*/
-#if defined(_MSC_VER) && ((_MSC_VER <= 1200) || ((_MSC_VER <= 1300) && defined(_STLPORT_VERSION)))
-	typedef	std::reverse_iterator<const_iterator, const_pointer, const_reference, difference_type>	const_reverse_iterator;
-#else
-	typedef	std::reverse_iterator<const_iterator>	const_reverse_iterator;
-#endif
-
-	/*!
-	\brief
-		Reverse iterator class for String objects
-	*/
-#if defined(_MSC_VER) && ((_MSC_VER <= 1200) || ((_MSC_VER <= 1300) && defined(_STLPORT_VERSION)))
-	typedef std::reverse_iterator<iterator, pointer, reference, difference_type>			reverse_iterator;
-#else
-	typedef std::reverse_iterator<iterator>			reverse_iterator;
-#endif
-
-public:
-    /*!
-    \brief
-        Functor that can be used as comparator in a std::map with String keys.
-        It's faster than using the default, but the map will no longer be sorted alphabetically.
-    */
-    struct FastLessCompare
-    {
-        bool operator() (const String& a, const String& b) const
-        {
-            const size_t la = a.length();
-            const size_t lb = b.length();
-            if (la == lb)
-                return (memcmp(a.ptr(), b.ptr(), la*sizeof(utf32)) < 0);
-            return (la < lb);
-        }
-    };
-
-public:
-	//////////////////////////////////////////////////////////////////////////
-	// Default Construction and Destructor
-	//////////////////////////////////////////////////////////////////////////
-	/*!
-	\brief
-		Constructs an empty string
-	*/
-	String(void)
-	{
-		init();
-	}
-
-	/*!
-	\brief
-		Destructor for String objects
-	*/
-	~String(void);
-
-	//////////////////////////////////////////////////////////////////////////
-	// Construction via CEGUI::String
-	//////////////////////////////////////////////////////////////////////////
-	/*!
-	\brief
-		Copy constructor - Creates a new string with the same value as \a str
-
-	\param str
-		String object used to initialise the newly created string
-
-	\return
-		Nothing
-	*/
-	String(const String& str)
-	{
-		init();
-		assign(str);
-	}
-	
-
-	/*!
-	\brief
-		Constructs a new string initialised with code points from another String object.
-
-	\param str
-		String object used to initialise the newly created string
-
-	\param str_idx
-		Starting code-point of \a str to be used when initialising the new String
-
-	\param str_num
-		Maximum number of code points from \a str that are to be assigned to the new String
-
-	\return
-		Nothing
-	*/
-	String(const String& str, size_type str_idx, size_type str_num = npos)
-	{
-		init();
-		assign(str, str_idx, str_num);
-	}
-
-	//////////////////////////////////////////////////////////////////////////
-	// Construction via std::string
-	//////////////////////////////////////////////////////////////////////////
-	/*!
-	\brief
-		Constructs a new string and initialises it using the std::string std_str
-
-	\param std_str
-		The std::string object that is to be used to initialise the new String object.
-
-	\note
-		The characters of \a std_str are taken to be unencoded data which represent Unicode code points 0x00..0xFF.  No translation of
-		the provided data will occur.
-
-	\return
-		Nothing
-
-	\exception std::length_error	Thrown if resulting String object would be too big.
-	*/
-	String(const std::string& std_str)
-	{
-		init();
-		assign(std_str);
-	}
-		
-	/*!
-	\brief
-		Constructs a new string initialised with characters from the given std::string object.
-
-	\param std_str
-		std::string object used to initialise the newly created string
-
-	\param str_idx
-		Starting character of \a std_str to be used when initialising the new String
-
-	\note
-		The characters of \a std_str are taken to be unencoded data which represent Unicode code points 0x00..0xFF.  No translation of
-		the provided data will occur.
-
-	\param str_num
-		Maximum number of characters from \a std_str that are to be assigned to the new String
-
-	\return
-		Nothing
-
-	\exception std::length_error	Thrown if resulting String object would be too big.
-	*/
-	String(const std::string& std_str, size_type str_idx, size_type str_num = npos)
-	{
-		init();
-		assign(std_str, str_idx, str_num);
-	}
-
-
-	//////////////////////////////////////////////////////////////////////////
-	// Construction via UTF-8 stream (for straight ASCII use, only codes 0x00 - 0x7f are valid)
-	//////////////////////////////////////////////////////////////////////////
-	/*!
-	\brief
-		Constructs a new String object and initialise it using the provided utf8 encoded string buffer.
-
-	\param utf8_str
-		Pointer to a buffer containing a null-terminated Unicode string encoded as utf8 data.
-
-	\note
-		A basic string literal (cast to utf8*) can be passed to this function, provided that the string is
-		comprised only of code points 0x00..0x7f.  The use of extended ASCII characters (with values >0x7f)
-		would result in incorrect behaviour as the String will attempt to 'decode' the data, with unpredictable
-		results.
-
-	\return
-		Nothing
-
-	\exception std::length_error	Thrown if resulting String object would be too big.
-	*/
-	String(const utf8* utf8_str)
-	{
-		init();
-		assign(utf8_str);
-	}
-
-	/*!
-	\brief
-		Constructs a new String object and initialise it using the provided utf8 encoded string buffer.
-
-		A basic string literal (cast to utf8*) can be passed to this function, provided that the string is
-		comprised only of code points 0x00..0x7f.  The use of extended ASCII characters (with values >0x7f)
-		would result in incorrect behaviour as the String will attempt to 'decode' the data, with unpredictable
-		results.
-
-	\param utf8_str
-		Pointer to a buffer containing Unicode string data encoded as utf8.
-
-	\note
-		A basic string literal (cast to utf8*) can be passed to this function, provided that the string is
-		comprised only of code points 0x00..0x7f.  The use of extended ASCII characters (with values >0x7f)
-		would result in incorrect behaviour as the String will attempt to 'decode' the data, with unpredictable
-		results.
-
-	\param chars_len
-		Length of the provided utf8 string in code units (not code-points).
-
-	\return
-		Nothing
-
-	\exception std::length_error	Thrown if resulting String object would be too big.
-	*/
-	String(const utf8* utf8_str, size_type chars_len)
-	{
-		init();
-		assign(utf8_str, chars_len);
-	}
-
-	//////////////////////////////////////////////////////////////////////////
-	// Construction via code-point (using a UTF-32 code unit)
-	//////////////////////////////////////////////////////////////////////////
-	/*!
-	\brief
-		Constructs a new String that is initialised with the specified code point
-
-	\param num
-		The number of times \a code_point is to be put into new String object
-
-	\param code_point
-		The Unicode code point to be used when initialising the String object
-
-	\return
-		Nothing
-
-	\exception std::length_error	Thrown if resulting String object would be too big.
-	*/
-	String(size_type num, utf32 code_point)
-	{
-		init();
-		assign(num, code_point);
-	}
-
-	//////////////////////////////////////////////////////////////////////////
-	// Construction via iterator
-	//////////////////////////////////////////////////////////////////////////
-	// Create string with characters in the range [beg, end)
-	/*!
-	\brief
-		Construct a new string object and initialise it with code-points from the range [beg, end).
-
-	\param beg
-		Iterator describing the start of the data to be used when initialising the String object
-
-	\param end
-		Iterator describing the (exclusive) end of the data to be used when initialising the String object
-
-	\return 
-		Nothing
-	*/
-	String(const_iterator iter_beg, const_iterator iter_end)
-	{
-		init();
-		append(iter_beg, iter_end);
-	}
-
-
-	//////////////////////////////////////////////////////////////////////////
-	// Construction via c-string
-	//////////////////////////////////////////////////////////////////////////
-	/*!
-	\brief
-		Constructs a new String object and initialise it using the provided c-string.
-
-	\param c_str
-		Pointer to a c-string.
-
-	\return
-		Nothing
-
-	\exception std::length_error	Thrown if resulting String object would be too big.
-	*/
-	String(const char* cstr)
-	{
-		init();
-		assign(cstr);
-	}
-
-	/*!
-	\brief
-		Constructs a new String object and initialise it using characters from the provided char array.
-
-	\param chars
-		char array.
-
-	\param chars_len
-		Number of chars from the array to be used.
-
-	\return
-		Nothing
-
-	\exception std::length_error	Thrown if resulting String object would be too big.
-	*/
-	String(const char* chars, size_type chars_len)
-	{
-		init();
-		assign(chars, chars_len);
-	}
-
-
-	//////////////////////////////////////////////////////////////////////////
-	// Size operations
-	//////////////////////////////////////////////////////////////////////////
-	/*!
-	\brief
-		Returns the size of the String in code points
-
-	\return
-		Number of code points currently in the String
-	*/
-	size_type	size(void) const
-	{
-		return d_cplength;
-	}
-
-	/*!
-	\brief
-		Returns the size of the String in code points
-
-	\return
-		Number of code points currently in the String
-	*/
-	size_type	length(void) const
-	{
-		return d_cplength;
-	}
-
-	/*!
-	\brief
-		Returns true if the String is empty
-
-	\return
-		true if the String is empty, else false.
-	*/
-	bool	empty(void) const
-	{
-		return	(d_cplength == 0);
-	}
-
-	/*!
-	\brief
-		Returns the maximum size of a String.
-
-		Any operation that would result in a String that is larger than this value will throw the std::length_error exception.
-
-	\return
-		The maximum number of code points that a string can contain
-	*/
-	static size_type	max_size(void)
-	{
-		return (((size_type)-1) / sizeof(utf32));
-	}
-
-	//////////////////////////////////////////////////////////////////////////
-	// Capacity Operations
-	//////////////////////////////////////////////////////////////////////////
-	// return the number of code points the string could hold without re-allocation
-	// (due to internal encoding this will always report the figure for worst-case encoding, and could even be < size()!)
-	/*!
-	\brief
-		Return the number of code points that the String could hold before a re-allocation would be required.
-
-	\return
-		Size of the current reserve buffer.  This is the maximum number of code points the String could hold before a buffer
-		re-allocation would be required
-	*/
-	size_type capacity(void) const
-	{
-		return d_reserve - 1;
-	}
-
-	// reserve internal memory for at-least 'num' code-points (characters).  if num is 0, request is shrink-to-fit.
-	/*!
-	\brief
-		Specifies the amount of reserve capacity to allocate.
-
-	\param num
-		The number of code points to allocate space for.  If \a num is larger that the current reserve, then a re-allocation will occur.  If
-		\a num is smaller than the current reserve (but not 0) the buffer may be shrunk to the larger of the specified number, or the current
-		String size (operation is currently not implemented).  If \a num is 0, then the buffer is re-allocated to fit the current String size.
-
-	\return
-		Nothing
-
-	\exception std::length_error	Thrown if resulting String object would be too big.
-	*/
-	void	reserve(size_type num = 0)
-	{
-		if (num == 0)
-			trim();
-		else
-			grow(num);
-	}
-
-	//////////////////////////////////////////////////////////////////////////
-	// Comparisons
-	//////////////////////////////////////////////////////////////////////////
-	/*!
-	\brief
-		Compares this String with the String 'str'.
-
-	\note
-		This does currently not properly consider Unicode and / or the system locale.
-
-	\param str
-		The String object that is to compared with this String.
-
-	\return
-		-  0 if the String objects are equal
-		- <0 if this String is lexicographically smaller than \a str
-		- >0 if this String is lexicographically greater than \a str
-	*/
-	int		compare(const String& str) const
-	{
-		return compare(0, d_cplength, str);
-	}
-
-	/*!
-	\brief
-		Compares code points from this String with code points from the String 'str'.
-
-	\note
-		This does currently not properly consider Unicode and / or the system locale.
-
-	\param idx
-		Index of the first code point from this String to consider.
-
-	\param len
-		Maximum number of code points from this String to consider.
-
-	\param str
-		The String object that is to compared with this String.
-
-	\param str_idx
-		Index of the first code point from String \a str to consider.
-
-	\param str_len
-		Maximum number of code points from String \a str to consider
-
-	\return
-		-  0 if the specified sub-strings are equal
-		- <0 if specified sub-strings are lexicographically smaller than \a str
-		- >0 if specified sub-strings are lexicographically greater than \a str
-
-	\exception std::out_of_range	Thrown if either \a idx or \a str_idx are invalid.
-	*/
-	int		compare(size_type idx, size_type len, const String& str, size_type str_idx = 0, size_type str_len = npos) const
-	{
-		if ((d_cplength < idx) || (str.d_cplength < str_idx))
-			throw std::out_of_range("Index is out of range for CEGUI::String");
-
-		if ((len == npos) || (idx + len > d_cplength))
-			len = d_cplength - idx;
-
-		if ((str_len == npos) || (str_idx + str_len > str.d_cplength))
-			str_len = str.d_cplength - str_idx;
-
-		int val = (len == 0) ? 0 : utf32_comp_utf32(&ptr()[idx], &str.ptr()[str_idx], (len < str_len) ? len : str_len);
-
-		return (val != 0) ? ((val < 0) ? -1 : 1) : (len < str_len) ? -1 : (len == str_len) ? 0 : 1;
-	}
-
-
-	/*!
-	\brief
-		Compares this String with the std::string 'std_str'.
-
-	\note
-		This does currently not properly consider Unicode and / or the system locale.
-
-	\param std_str
-		The std::string object that is to compared with this String.
-
-	\note
-		Characters from \a std_str are considered to represent Unicode code points in the range 0x00..0xFF.  No translation of
-		the encountered data is performed.
-
-	\return
-		-  0 if the string objects are equal
-		- <0 if this string is lexicographically smaller than \a std_str
-		- >0 if this string is lexicographically greater than \a std_str
-	*/
-	int		compare(const std::string& std_str) const
-	{
-		return compare(0, d_cplength, std_str);
-	}
-
-
-	/*!
-	\brief
-		Compares code points from this String with code points from the std::string 'std_str'.
-
-	\note
-		This does currently not properly consider Unicode and / or the system locale.
-
-	\param idx
-		Index of the first code point from this String to consider.
-
-	\param len
-		Maximum number of code points from this String to consider.
-
-	\param std_str
-		The std::string object that is to compared with this String.
-
-	\note
-		Characters from \a std_str are considered to represent Unicode code points in the range 0x00..0xFF.  No translation of
-		the encountered data is performed.
-
-	\param str_idx
-		Index of the first character from std::string \a std_str to consider.
-
-	\param str_len
-		Maximum number of characters from std::string \a std_str to consider
-
-	\return
-		-  0 if the specified sub-strings are equal
-		- <0 if specified sub-strings are lexicographically smaller than \a std_str
-		- >0 if specified sub-strings are lexicographically greater than \a std_str
-
-	\exception std::out_of_range	Thrown if either \a idx or \a str_idx are invalid.
-	*/
-	int		compare(size_type idx, size_type len, const std::string& std_str, size_type str_idx = 0, size_type str_len = npos) const
-	{
-		if (d_cplength < idx)
-			throw std::out_of_range("Index is out of range for CEGUI::String");
-
-		if (std_str.size() < str_idx)
-			throw std::out_of_range("Index is out of range for std::string");
-
-		if ((len == npos) || (idx + len > d_cplength))
-			len = d_cplength - idx;
-
-		if ((str_len == npos) || (str_idx + str_len > std_str.size()))
-			str_len = (size_type)std_str.size() - str_idx;
-
-		int val = (len == 0) ? 0 : utf32_comp_char(&ptr()[idx], &std_str.c_str()[str_idx], (len < str_len) ? len : str_len);
-
-		return (val != 0) ? ((val < 0) ? -1 : 1) : (len < str_len) ? -1 : (len == str_len) ? 0 : 1;
-	}
-
-
-	/*!
-	\brief
-		Compares this String with the null-terminated utf8 encoded 'utf8_str'.
-
-	\note
-		This does currently not properly consider Unicode and / or the system locale.
-
-	\param utf8_str
-		The buffer containing valid Unicode data encoded as utf8 that is to compared with this String.
-
-	\note
-		A basic string literal (cast to utf8*) can be passed to this function, provided that the string is
-		comprised only of code points 0x00..0x7f.  The use of extended ASCII characters (with values >0x7f)
-		would result in incorrect behaviour as the String will attempt to 'decode' the data, with unpredictable
-		results.
-
-	\return
-		-  0 if the strings are equal
-		- <0 if this string is lexicographically smaller than \a utf8_str
-		- >0 if this string is lexicographically greater than \a utf8_str
-	*/
-	int		compare(const utf8* utf8_str) const
-	{
-		return compare(0, d_cplength, utf8_str, encoded_size(utf8_str));
-	}
-
-
-	/*!
-	\brief
-		Compares code points from this String with the null-terminated utf8 encoded 'utf8_str'.
-
-	\note
-		This does currently not properly consider Unicode and / or the system locale.
-
-	\param idx
-		Index of the first code point from this String to consider.
-
-	\param len
-		Maximum number of code points from this String to consider.
-
-	\param utf8_str
-		The buffer containing valid Unicode data encoded as utf8 that is to compared with this String.
-
-	\note
-		A basic string literal (cast to utf8*) can be passed to this function, provided that the string is
-		comprised only of code points 0x00..0x7f.  The use of extended ASCII characters (with values >0x7f)
-		would result in incorrect behaviour as the String will attempt to 'decode' the data, with unpredictable
-		results.
-
-	\return
-		-  0 if the specified sub-strings are equal
-		- <0 if specified sub-strings are lexicographically smaller than \a utf8_str
-		- >0 if specified sub-strings are lexicographically greater than \a utf8_str
-
-	\exception std::out_of_range	Thrown if \a idx is invalid.
-	*/
-	int		compare(size_type idx, size_type len, const utf8* utf8_str) const
-	{
-		return compare(idx, len, utf8_str, encoded_size(utf8_str));
-	}
-
-	/*!
-	\brief
-		Compares code points from this String with the utf8 encoded data in buffer 'utf8_str'.
-
-	\note
-		This does currently not properly consider Unicode and / or the system locale.
-
-	\param idx
-		Index of the first code point from this String to consider.
-
-	\param len
-		Maximum number of code points from this String to consider.
-
-	\param utf8_str
-		The buffer containing valid Unicode data encoded as utf8 that is to compared with this String.
-
-	\note
-		A basic string literal (cast to utf8*) can be passed to this function, provided that the string is
-		comprised only of code points 0x00..0x7f.  The use of extended ASCII characters (with values >0x7f)
-		would result in incorrect behaviour as the String will attempt to 'decode' the data, with unpredictable
-		results.
-
-	\param str_cplen
-		The number of encoded code points in the buffer \a utf8_str (this is not the same as the number of code units).
-
-	\return
-		-  0 if the specified sub-strings are equal
-		- <0 if specified sub-strings are lexicographically smaller than \a utf8_str
-		- >0 if specified sub-strings are lexicographically greater than \a utf8_str
-
-	\exception std::out_of_range	Thrown if \a idx is invalid.
-	\exception std::length_error	Thrown if \a str_cplen is set to npos.
-	*/
-	int		compare(size_type idx, size_type len, const utf8* utf8_str, size_type str_cplen) const
-	{
-		if (d_cplength < idx)
-			throw std::out_of_range("Index is out of range for CEGUI::String");
-
-		if (str_cplen == npos)
-			throw std::length_error("Length for utf8 encoded string can not be 'npos'");
-
-		if ((len == npos) || (idx + len > d_cplength))
-			len = d_cplength - idx;
-
-		int val = (len == 0) ? 0 : utf32_comp_utf8(&ptr()[idx], utf8_str, (len < str_cplen) ? len : str_cplen);
-
-		return (val != 0) ? ((val < 0) ? -1 : 1) : (len < str_cplen) ? -1 : (len == str_cplen) ? 0 : 1;
-	}
-
-
-	/*!
-	\brief
-		Compares this String with the given c-string.
-
-	\note
-		This does currently not properly consider Unicode and / or the system locale.
-
-	\param c_str
-		The c-string that is to compared with this String.
-
-	\return
-		-  0 if the strings are equal
-		- <0 if this string is lexicographically smaller than \a c_str
-		- >0 if this string is lexicographically greater than \a c_str
-	*/
-	int		compare(const char* cstr) const
-	{
-		return compare(0, d_cplength, cstr, strlen(cstr));
-	}
-
-
-	/*!
-	\brief
-		Compares code points from this String with the given c-string.
-
-	\note
-		This does currently not properly consider Unicode and / or the system locale.
-
-	\param idx
-		Index of the first code point from this String to consider.
-
-	\param len
-		Maximum number of code points from this String to consider.
-
-	\param c_str
-		The c-string that is to compared with this String.
-
-	\return
-		-  0 if the specified sub-strings are equal
-		- <0 if specified sub-strings are lexicographically smaller than \a c_str
-		- >0 if specified sub-strings are lexicographically greater than \a c_str
-
-	\exception std::out_of_range	Thrown if \a idx is invalid.
-	*/
-	int		compare(size_type idx, size_type len, const char* cstr) const
-	{
-		return compare(idx, len, cstr, strlen(cstr));
-	}
-
-
-	/*!
-	\brief
-		Compares code points from this String with chars in the given char array.
-
-	\note
-		This does currently not properly consider Unicode and / or the system locale.
-
-	\param idx
-		Index of the first code point from this String to consider.
-
-	\param len
-		Maximum number of code points from this String to consider.
-
-	\param chars
-		The array containing the chars that are to compared with this String.
-
-	\param chars_len
-		The number of chars in the array.
-
-	\return
-		-  0 if the specified sub-strings are equal
-		- <0 if specified sub-strings are lexicographically smaller than \a chars
-		- >0 if specified sub-strings are lexicographically greater than \a chars
-
-	\exception std::out_of_range	Thrown if \a idx is invalid.
-	\exception std::length_error	Thrown if \a chars_len is set to npos.
-	*/
-	int		compare(size_type idx, size_type len, const char* chars, size_type chars_len) const
-	{
-		if (d_cplength < idx)
-			throw std::out_of_range("Index is out of range for CEGUI::String");
-
-		if (chars_len == npos)
-			throw std::length_error("Length for char array can not be 'npos'");
-
-		if ((len == npos) || (idx + len > d_cplength))
-			len = d_cplength - idx;
-
-		int val = (len == 0) ? 0 : utf32_comp_char(&ptr()[idx], chars, (len < chars_len) ? len : chars_len);
-
-		return (val != 0) ? ((val < 0) ? -1 : 1) : (len < chars_len) ? -1 : (len == chars_len) ? 0 : 1;
-	}
-
-
-	//////////////////////////////////////////////////////////////////////////
-	// Character access
-	//////////////////////////////////////////////////////////////////////////
-	/*!
-	\brief
-		Returns the code point at the given index.
-
-	\param idx
-		Zero based index of the code point to be returned.
-
-	\note
-		- For constant strings length()/size() provide a valid index and will access the default utf32 value.
-		- For non-constant strings length()/size() is an invalid index, and acceesing (especially writing) this index could cause string corruption.
-
-	\return
-		The utf32 code point at the given index within the String.
-	*/
-	reference	operator[](size_type idx)
-	{
-		return (ptr()[idx]);
-	}
-
-	/*!
-	\brief
-		Returns the code point at the given index.
-
-	\param idx
-		Zero based index of the code point to be returned.
-
-	\note
-		- For constant strings length()/size() provide a valid index and will access the default utf32 value.
-		- For non-constant strings length()/size() is an invalid index, and acceesing (especially writing) this index could cause string corruption.
-
-	\return
-		The utf32 code point at the given index within the String.
-	*/
-	value_type	operator[](size_type idx) const
-	{
-		return ptr()[idx];
-	}
-
-	/*!
-	\brief
-		Returns the code point at the given index.
-
-	\param idx
-		Zero based index of the code point to be returned.
-
-	\return
-		The utf32 code point at the given index within the String.
-
-	\exception std::out_of_range	Thrown if \a idx is >= length().
-	*/
-	reference	at(size_type idx)
-	{
-		if (d_cplength <= idx)
-			throw std::out_of_range("Index is out of range for CEGUI::String");
-
-		return ptr()[idx];
-	}
-
-	/*!
-	\brief
-		Returns the code point at the given index.
-
-	\param idx
-		Zero based index of the code point to be returned.
-
-	\return
-		The utf32 code point at the given index within the String.
-
-	\exception std::out_of_range	Thrown if \a idx is >= length().
-	*/
-	const_reference	at(size_type idx) const
-	{
-		if (d_cplength <= idx)
-			throw std::out_of_range("Index is out of range for CEGUI::String");
-
-		return ptr()[idx];
-	}
-
-
-	//////////////////////////////////////////////////////////////////////////
-	// C-Strings and arrays
-	//////////////////////////////////////////////////////////////////////////
-	/*!
-	\brief
-		Returns contents of the String as a null terminated string of utf8 encoded data.
-
-	\return
-		Pointer to a char buffer containing the contents of the String encoded as null-terminated utf8 data.
-
-	\note
-		The buffer returned from this function is owned by the String object.
-
-	\note
-		Any function that modifies the String data will invalidate the buffer returned by this call.
-	*/
-	const char* c_str(void) const
-	{
-		return (const char*)build_utf8_buff();
-	}
-
-	/*!
-	\brief
-		Returns contents of the String as utf8 encoded data.
-
-	\return
-		Pointer to a buffer containing the contents of the String encoded utf8 data.
-
-	\note
-		The buffer returned from this function is owned by the String object.
-
-	\note
-		Any function that modifies the String data will invalidate the buffer returned by this call.
-	*/
-	const utf8* data(void) const
-	{
-		return build_utf8_buff();
-	}
-
-    /*!
-    \brief
-        Returns a pointer to the buffer in use.
-    */
-	utf32*	ptr(void)
-	{
-		return (d_reserve > STR_QUICKBUFF_SIZE) ? d_buffer : d_quickbuff;
-	}
-
-	/*!
-    \brief
-        Returns a pointer to the buffer in use. (const version)
-    */
-	const utf32*	ptr(void) const
-	{
-		return (d_reserve > STR_QUICKBUFF_SIZE) ? d_buffer : d_quickbuff;
-	}
-
-	// copy, at most, 'len' code-points of the string, begining with code-point 'idx', into the array 'buf' as valid utf8 encoded data
-	// return number of utf8 code units placed into the buffer
-	/*!
-	\brief
-		Copies an area of the String into the provided buffer as encoded utf8 data.
-
-	\param buf
-		Pointer to a buffer that is to receive the encoded data (this must be big enough to hold the encoded data)
-
-	\param len
-		Maximum number of code points from the String that should be encoded into the buffer
-	
-	\param idx
-		Index of the first code point to be encoded into the buffer
-
-	\return
-		The number of utf8 encoded code units transferred to the buffer.
-
-		\note A code unit does not equal a code point.  A utf32 code point, when encoded as utf8, can occupy between 1 and 4 code units.
-
-	\exception std::out_of_range	Thrown if \a idx was invalid for this String.
-	*/
-	size_type	copy(utf8* buf, size_type len = npos, size_type idx = 0) const
-	{
-		if (d_cplength < idx)
-			throw std::out_of_range("Index is out of range for CEGUI::String");
-
-		if (len == npos)
-			len = d_cplength;
-
-		return encode(&ptr()[idx], buf, npos, len);
-	}
-
-	//////////////////////////////////////////////////////////////////////////
-	// UTF8 Encoding length information
-	//////////////////////////////////////////////////////////////////////////
-	// return the number of bytes required to hold 'num' code-points, starting at code-point 'idx', of the the string when encoded as utf8 data.
-	/*!
-	\brief
-		Return the number of utf8 code units required to hold an area of the String when encoded as utf8 data
-
-	\param num
-		Maximum number of code points to consider when calculating utf8 encoded size.
-
-	\param idx
-		Index of the first code point to consider when calculating the utf8 encoded size
-
-	\return
-		The number of utf8 code units (bytes) required to hold the specified sub-string when encoded as utf8 data.
-
-	\exception std::out_of_range	Thrown if \a idx was invalid for this String.
-	*/
-	size_type	utf8_stream_len(size_type num = npos, size_type idx = 0) const
-	{
-		using namespace std;
-
-		if (d_cplength < idx)
-			throw out_of_range("Index was out of range for CEGUI::String object");
-
-		size_type	maxlen = d_cplength - idx;
-
-		return encoded_size(&ptr()[idx], ceguimin(num, maxlen));
-	}
-
-	//////////////////////////////////////////////////////////////////////////
-	// Assignment Functions
-	//////////////////////////////////////////////////////////////////////////
-	/*!
-	\brief
-		Assign the value of String \a str to this String
-
-	\param str
-		String object containing the string value to be assigned.
-
-	\return
-		This String after the assignment has happened
-	*/
-	String&	operator=(const String& str)
-	{
-		return assign(str);
-	}
-
-	/*!
-	\brief
-		Assign a sub-string of String \a str to this String
-
-	\param str
-		String object containing the string data to be assigned.
-
-	\param str_idx
-		Index of the first code point in \a str that is to be assigned
-
-	\param str_num
-		Maximum number of code points from \a str that are be be assigned
-
-	\return
-		This String after the assignment has happened
-
-	\exception std::out_of_range	Thrown if str_idx is invalid for \a str
-	*/
-	String&	assign(const String& str, size_type str_idx = 0, size_type str_num = npos)
-	{
-		if (str.d_cplength < str_idx)
-			throw std::out_of_range("Index was out of range for CEGUI::String object");
-
-		if (str_num == npos)
-			str_num = str.d_cplength - str_idx;
-
-		grow(str_num);
-		setlen(str_num);
-		memcpy(ptr(), &str.ptr()[str_idx], str_num * sizeof(utf32));
-		
-		return *this;
-	}
-
-	/*!
-	\brief
-		Assign the value of std::string \a std_str to this String
-
-	\note
-		The characters of \a std_str are taken to be unencoded data which represent Unicode code points 0x00..0xFF.  No translation of
-		the provided data will occur.
-
-	\param std_str
-		std::string object containing the string value to be assigned.
-
-	\return
-		This String after the assignment has happened
-
-	\exception std::length_error	Thrown if the resulting String would have been too large.
-	*/
-	String&	operator=(const std::string& std_str)
-	{
-		return assign(std_str);
-	}
-
-	/*!
-	\brief
-		Assign a sub-string of std::string \a std_str to this String
-
-	\note
-		The characters of \a std_str are taken to be unencoded data which represent Unicode code points 0x00..0xFF.  No translation of
-		the provided data will occur.
-
-	\param std_str
-		std::string object containing the string value to be assigned.
-
-	\param str_idx
-		Index of the first character of \a std_str to be assigned
-
-	\param str_num
-		Maximum number of characters from \a std_str to be assigned
-
-	\return
-		This String after the assignment has happened
-
-	\exception std::out_of_range	Thrown if \a str_idx is invalid for \a std_str
-	\exception std::length_error	Thrown if the resulting String would have been too large.
-	*/
-	String&	assign(const std::string& std_str, size_type str_idx = 0, size_type str_num = npos)
-	{
-		if (std_str.size() < str_idx)
-			throw std::out_of_range("Index was out of range for std::string object");
-
-		if (str_num == npos)
-			str_num = (size_type)std_str.size() - str_idx;
-
-		grow(str_num);
-		setlen(str_num);
-
-		while(str_num--)
-		{
-			((*this)[str_num]) = static_cast<utf32>(static_cast<unsigned char>(std_str[str_num + str_idx]));
-		}
-
-		return *this;
-	}
-
-	/*!
-	\brief
-		Assign to this String the string value represented by the given null-terminated utf8 encoded data
-
-	\note
-		A basic string literal (cast to utf8*) can be passed to this function, provided that the string is
-		comprised only of code points 0x00..0x7f.  The use of extended ASCII characters (with values >0x7f)
-		would result in incorrect behaviour as the String will attempt to 'decode' the data, with unpredictable
-		results.
-
-	\param utf8_str
-		Buffer containing valid null-terminated utf8 encoded data
-
-	\return
-		This String after the assignment has happened
-
-	\exception std::length_error	Thrown if the resulting String would have been too large.
-	*/
-	String&	operator=(const utf8* utf8_str)
-	{
-		return assign(utf8_str, utf_length(utf8_str));
-	}
-
-	/*!
-	\brief
-		Assign to this String the string value represented by the given null-terminated utf8 encoded data
-
-	\note
-		A basic string literal (cast to utf8*) can be passed to this function, provided that the string is
-		comprised only of code points 0x00..0x7f.  The use of extended ASCII characters (with values >0x7f)
-		would result in incorrect behaviour as the String will attempt to 'decode' the data, with unpredictable
-		results.
-
-	\param utf8_str
-		Buffer containing valid null-terminated utf8 encoded data
-
-	\return
-		This String after the assignment has happened
-
-	\exception std::length_error	Thrown if the resulting String would have been too large.
-	*/
-	String&	assign(const utf8* utf8_str)
-	{
-		return assign(utf8_str, utf_length(utf8_str));
-	}
-
-	/*!
-	\brief
-		Assign to this String the string value represented by the given utf8 encoded data
-
-	\note
-		A basic string literal (cast to utf8*) can be passed to this function, provided that the string is
-		comprised only of code points 0x00..0x7f.  The use of extended ASCII characters (with values >0x7f)
-		would result in incorrect behaviour as the String will attempt to 'decode' the data, with unpredictable
-		results.
-
-	\param utf8_str
-		Buffer containing valid utf8 encoded data
-
-	\param str_num
-		Number of code units (not code points) in the buffer pointed to by \a utf8_str
-
-	\return
-		This String after the assignment has happened
-
-	\exception std::length_error	Thrown if the resulting String would have been too large, or if str_num is 'npos'.
-	*/
-	String&	assign(const utf8* utf8_str, size_type str_num)
-	{
-		if (str_num == npos)
-			throw std::length_error("Length for utf8 encoded string can not be 'npos'");
-
-		size_type enc_sze = encoded_size(utf8_str, str_num);
-
-		grow(enc_sze);
-		encode(utf8_str, ptr(), d_reserve, str_num);
-		setlen(enc_sze);
-		return *this;
-	}
-
-	/*!
-	\brief
-		Assigns the specified utf32 code point to this String.  Result is always a String 1 code point in length.
-
-	\param code_point
-		Valid utf32 Unicode code point to be assigned to the string
-
-	\return
-		This String after assignment
-	*/
-	String&	operator=(utf32 code_point)
-	{
-		return assign(1, code_point);
-	}
-
-	/*!
-	\brief
-		Assigns the specified code point repeatedly to the String
-
-	\param num
-		The number of times to assign the code point
-
-	\param code_point
-		Valid utf32 Unicode code point to be assigned to the string
-
-	\return
-		This String after assignment.
-
-	\exception std::length_error	Thrown if \a num was 'npos'
-	*/
-	String&	assign(size_type num, utf32 code_point)
-	{
-		if (num == npos)
-			throw std::length_error("Code point count can not be 'npos'");
-
-		grow(num);
-		setlen(num);
-		utf32* p = ptr();
-
-		while(num--)
-			*p++ = code_point;
-
-		return *this;
-	}
-
-
-	/*!
-	\brief
-		Assign to this String the given C-string.
-
-	\param c_str
-		Pointer to a valid C style string.
-
-	\return
-		This String after the assignment has happened
-
-	\exception std::length_error	Thrown if the resulting String would have been too large.
-	*/
-	String&	operator=(const char* cstr)
-	{
-		return assign(cstr, strlen(cstr));
-	}
-
-
-	/*!
-	\brief
-		Assign to this String the given C-string.
-
-	\param c_str
-		Pointer to a valid C style string.
-
-	\return
-		This String after the assignment has happened
-
-	\exception std::length_error	Thrown if the resulting String would have been too large.
-	*/
-	String&	assign(const char* cstr)
-	{
-		return assign(cstr, strlen(cstr));
-	}
-
-
-	/*!
-	\brief
-		Assign to this String a number of chars from a char array.
-
-	\param chars
-		char array.
-
-	\param chars_len
-		Number of chars to be assigned.
-
-	\return
-		This String after the assignment has happened
-
-	\exception std::length_error	Thrown if the resulting String would have been too large.
-	*/
-	String&	assign(const char* chars, size_type chars_len)
-	{
-		grow(chars_len);
-		utf32* pt = ptr();
-
-		for (size_type i = 0; i < chars_len; ++i)
-		{
-			*pt++ = static_cast<utf32>(static_cast<unsigned char>(*chars++));
-		}
-
-		setlen(chars_len);
-		return *this;
-	}
-
-
-	/*!
-	\brief
-		Swaps the value of this String with the given String \a str
-
-	\param str
-		String object whos value is to be swapped with this String.
-
-	\return
-		Nothing
-	*/
-	void	swap(String& str)
-	{
-		size_type	temp_len	= d_cplength;
-		d_cplength = str.d_cplength;
-		str.d_cplength = temp_len;
-
-		size_type	temp_res	= d_reserve;
-		d_reserve = str.d_reserve;
-		str.d_reserve = temp_res;
-
-		utf32*		temp_buf	= d_buffer;
-		d_buffer = str.d_buffer;
-		str.d_buffer = temp_buf;
-
-		// see if we need to swap 'quick buffer' data
-		if (temp_res <= STR_QUICKBUFF_SIZE)
-		{
-			utf32		temp_qbf[STR_QUICKBUFF_SIZE];
-
-			memcpy(temp_qbf, d_quickbuff, STR_QUICKBUFF_SIZE * sizeof(utf32));
-			memcpy(d_quickbuff, str.d_quickbuff, STR_QUICKBUFF_SIZE * sizeof(utf32));
-			memcpy(str.d_quickbuff, temp_qbf, STR_QUICKBUFF_SIZE * sizeof(utf32));
-		}
-
-	}
-
-	//////////////////////////////////////////////////////////////////////////
-	// Appending Functions
-	//////////////////////////////////////////////////////////////////////////
-	/*!
-	\brief
-		Appends the String \a str
-
-	\param str
-		String object that is to be appended
-
-	\return
-		This String after the append operation
-
-	\exception std::length_error	Thrown if resulting String would be too large.
-	*/
-	String&	operator+=(const String& str)
-	{
-		return append(str);
-	}
-
-	/*!
-	\brief
-		Appends a sub-string of the String \a str
-
-	\param str
-		String object containing data to be appended
-
-	\param str_idx
-		Index of the first code point to be appended
-
-	\param str_num
-		Maximum number of code points to be appended
-
-	\return
-		This String after the append operation
-
-	\exception std::out_of_range	Thrown if \a str_idx is invalid for \a str.
-	\exception std::length_error	Thrown if resulting String would be too large.
-	*/
-	String& append(const String& str, size_type str_idx = 0, size_type str_num = npos)
-	{
-		if (str.d_cplength < str_idx)
-			throw std::out_of_range("Index is out of range for CEGUI::String");
-
-		if (str_num == npos)
-			str_num = str.d_cplength - str_idx;
-
-		grow(d_cplength + str_num);
-		memcpy(&ptr()[d_cplength], &str.ptr()[str_idx], str_num * sizeof(utf32));
-		setlen(d_cplength + str_num);
-		return *this;
-	}
-
-
-	/*!
-	\brief
-		Appends the std::string \a std_str
-
-	\param std_str
-		std::string object that is to be appended
-
-	\note
-		The characters of \a std_str are taken to be unencoded data which represent Unicode code points 0x00..0xFF.  No translation of
-		the provided data will occur.
-
-	\return
-		This String after the append operation
-
-	\exception std::length_error	Thrown if resulting String would be too large.
-	*/
-	String&	operator+=(const std::string& std_str)
-	{
-		return append(std_str);
-	}
-
-	/*!
-	\brief
-		Appends a sub-string of the std::string \a std_str
-
-	\param std_str
-		std::string object containing data to be appended
-
-	\note
-		The characters of \a std_str are taken to be unencoded data which represent Unicode code points 0x00..0xFF.  No translation of
-		the provided data will occur.
-
-	\param str_idx
-		Index of the first character to be appended
-
-	\param str_num
-		Maximum number of characters to be appended
-
-	\return
-		This String after the append operation
-
-	\exception std::out_of_range	Thrown if \a str_idx is invalid for \a std_str.
-	\exception std::length_error	Thrown if resulting String would be too large.
-	*/
-	String& append(const std::string& std_str, size_type str_idx = 0, size_type str_num = npos)
-	{
-		if (std_str.size() < str_idx)
-			throw std::out_of_range("Index is out of range for std::string");
-
-		if (str_num == npos)
-			str_num = (size_type)std_str.size() - str_idx;
-
-		size_type newsze = d_cplength + str_num;
-
-		grow(newsze);
-		utf32* pt = &ptr()[newsze-1];
-
-		while(str_num--)
-			*pt-- = static_cast<utf32>(static_cast<unsigned char>(std_str[str_num]));
-
-		setlen(newsze);
-		return *this;
-	}
-
-
-	/*!
-	\brief
-		Appends to the String the null-terminated utf8 encoded data in the buffer utf8_str.
-
-	\param utf8_str
-		buffer holding the null-terminated utf8 encoded data that is to be appended
-
-	\note
-		A basic string literal (cast to utf8*) can be passed to this function, provided that the string is
-		comprised only of code points 0x00..0x7f.  The use of extended ASCII characters (with values >0x7f)
-		would result in incorrect behaviour as the String will attempt to 'decode' the data, with unpredictable
-		results.
-
-	\return
-		This String after the append operation
-
-	\exception std::length_error	Thrown if resulting String would be too large.
-	*/
-	String&	operator+=(const utf8* utf8_str)
-	{
-		return append(utf8_str, utf_length(utf8_str));
-	}
-
-	/*!
-	\brief
-		Appends to the String the null-terminated utf8 encoded data in the buffer utf8_str.
-
-	\param utf8_str
-		Buffer holding the null-terminated utf8 encoded data that is to be appended
-
-	\note
-		A basic string literal (cast to utf8*) can be passed to this function, provided that the string is
-		comprised only of code points 0x00..0x7f.  The use of extended ASCII characters (with values >0x7f)
-		would result in incorrect behaviour as the String will attempt to 'decode' the data, with unpredictable
-		results.
-
-	\return
-		This String after the append operation
-
-	\exception std::length_error	Thrown if resulting String would be too large.
-	*/
-	String& append(const utf8* utf8_str)
-	{
-		return append(utf8_str, utf_length(utf8_str));
-	}
-
-
-	/*!
-	\brief
-		Appends to the String the utf8 encoded data in the buffer utf8_str.
-
-	\param utf8_str
-		Buffer holding the utf8 encoded data that is to be appended
-
-	\note
-		A basic string literal (cast to utf8*) can be passed to this function, provided that the string is
-		comprised only of code points 0x00..0x7f.  The use of extended ASCII characters (with values >0x7f)
-		would result in incorrect behaviour as the String will attempt to 'decode' the data, with unpredictable
-		results.
-
-	\param len
-		Number of code units (not code points) in the buffer to be appended
-
-	\return
-		This String after the append operation
-
-	\exception std::length_error	Thrown if resulting String would be too large, or if \a len was 'npos'
-	*/
-	String& append(const utf8* utf8_str, size_type len)
-	{
-		if (len == npos)
-			throw std::length_error("Length for utf8 encoded string can not be 'npos'");
-
-		size_type encsz = encoded_size(utf8_str, len);
-		size_type newsz = d_cplength + encsz;
-
-		grow(newsz);
-		encode(utf8_str, &ptr()[d_cplength], encsz, len);
-		setlen(newsz);
-
-		return *this;
-	}
-
-
-	/*!
-	\brief
-		Appends a single code point to the string
-
-	\param code_point
-		utf32 Unicode code point that is to be appended
-
-	\return
-		This String after the append operation
-
-	\exception std::length_error	Thrown if resulting String would be too long.
-	*/
-	String& operator+=(utf32 code_point)
-	{
-		return append(1, code_point);
-	}
-
-	/*!
-	\brief
-		Appends a single code point multiple times to the string
-
-	\param num
-		Number of copies of the code point to be appended
-
-	\param code_point
-		utf32 Unicode code point that is to be appended
-
-	\return
-		This String after the append operation
-
-	\exception std::length_error	Thrown if resulting String would be too long, or if \a num was 'npos'.
-	*/
-	String& append(size_type num, utf32 code_point)
-	{
-		if (num == npos)
-			throw std::length_error("Code point count can not be 'npos'");
-
-		size_type newsz = d_cplength + num;
-		grow(newsz);
-
-		utf32* p = &ptr()[d_cplength];
-
-		while(num--)
-			*p++ = code_point;
-
-		setlen(newsz);
-
-		return *this;
-	}
-
-	/*!
-	\brief
-		Appends a single code point to the string
-
-	\param code_point
-		utf32 Unicode code point that is to be appended
-
-	\return
-		Nothing
-
-	\exception std::length_error	Thrown if resulting String would be too long.
-	*/
-	void	push_back(utf32 code_point)
-	{
-		append(1, code_point);
-	}
-
-	/*!
-	\brief
-		Appends the code points in the reange [beg, end)
-
-	\param beg
-		Iterator describing the start of the range to be appended
-
-	\param end
-		Iterator describing the (exclusive) end of the range to be appended.
-
-	\return
-		This String after the append operation
-
-	\exception std::length_error	Thrown if the resulting string would be too large.
-	*/
-	String&	append(const_iterator iter_beg, const_iterator iter_end)
-	{
-		return replace(end(), end(), iter_beg, iter_end);
-	}
-
-
-	/*!
-	\brief
-		Appends to the String the given c-string.
-
-	\param c_str
-		c-string that is to be appended.
-
-	\return
-		This String after the append operation
-
-	\exception std::length_error	Thrown if resulting String would be too large.
-	*/
-	String&	operator+=(const char* cstr)
-	{
-		return append(cstr, strlen(cstr));
-	}
-
-
-	/*!
-	\brief
-		Appends to the String the given c-string.
-
-	\param c_str
-		c-string that is to be appended.
-
-	\return
-		This String after the append operation
-
-	\exception std::length_error	Thrown if resulting String would be too large.
-	*/
-	String& append(const char* cstr)
-	{
-		return append(cstr, strlen(cstr));
-	}
-
-
-	/*!
-	\brief
-		Appends to the String chars from the given char array.
-
-	\param chars
-		char array holding the chars that are to be appended
-
-	\param chars_len
-		Number of chars to be appended
-
-	\return
-		This String after the append operation
-
-	\exception std::length_error	Thrown if resulting String would be too large, or if \a chars_len was 'npos'
-	*/
-	String& append(const char* chars, size_type chars_len)
-	{
-		if (chars_len == npos)
-			throw std::length_error("Length for char array can not be 'npos'");
-
-		size_type newsz = d_cplength + chars_len;
-
-		grow(newsz);
-
-		utf32* pt = &ptr()[newsz-1];
-
-		while(chars_len--)
-			*pt-- = static_cast<utf32>(static_cast<unsigned char>(chars[chars_len]));
-
-		setlen(newsz);
-
-		return *this;
-	}
-
-
-	//////////////////////////////////////////////////////////////////////////
-	// Insertion Functions
-	//////////////////////////////////////////////////////////////////////////
-	/*!
-	\brief
-		Inserts the given String object at the specified position.
-
-	\param idx
-		Index where the string is to be inserted.
-
-	\param str
-		String object that is to be inserted.
-
-	\return
-		This String after the insert.
-
-	\exception std::out_of_range	Thrown if \a idx is invalid for this String.
-	\exception std::length_error	Thrown if resulting String would be too large.
-	*/
-	String&	insert(size_type idx, const String& str)
-	{
-		return insert(idx, str, 0, npos);
-	}
-
-	/*!
-	\brief
-		Inserts a sub-string of the given String object at the specified position.
-
-	\param idx
-		Index where the string is to be inserted.
-
-	\param str
-		String object containing data to be inserted.
-
-	\param str_idx
-		Index of the first code point from \a str to be inserted.
-
-	\param str_num
-		Maximum number of code points from \a str to be inserted.
-
-	\return
-		This String after the insert.
-
-	\exception std::out_of_range	Thrown if \a idx or \a str_idx are out of range.
-	\exception std::length_error	Thrown if resulting String would be too large.
-	*/
-	String& insert(size_type idx, const String& str, size_type str_idx, size_type str_num)
-	{
-		if ((d_cplength < idx) || (str.d_cplength < str_idx))
-			throw std::out_of_range("Index is out of range for CEGUI::String");
-
-		if (str_num == npos)
-			str_num = str.d_cplength - str_idx;
-
-		size_type newsz = d_cplength + str_num;
-		grow(newsz);
-		memmove(&ptr()[idx + str_num], &ptr()[idx], (d_cplength - idx) * sizeof(utf32));
-		memcpy(&ptr()[idx], &str.ptr()[str_idx], str_num * sizeof(utf32));
-		setlen(newsz);
-
-		return *this;
-	}
-
-	/*!
-	\brief
-		Inserts the given std::string object at the specified position.
-
-	\param idx
-		Index where the std::string is to be inserted.
-
-	\param std_str
-		std::string object that is to be inserted.
-
-	\note
-		The characters of \a std_str are taken to be unencoded data which represent Unicode code points 0x00..0xFF.  No translation of
-		the provided data will occur.
-
-	\return
-		This String after the insert.
-
-	\exception std::out_of_range	Thrown if \a idx is invalid for this String.
-	\exception std::length_error	Thrown if resulting String would be too large.
-	*/
-	String&	insert(size_type idx, const std::string& std_str)
-	{
-		return insert(idx, std_str, 0, npos);
-	}
-
-	/*!
-	\brief
-		Inserts a sub-string of the given std::string object at the specified position.
-
-	\param idx
-		Index where the string is to be inserted.
-
-	\param std_str
-		std::string object containing data to be inserted.
-
-	\note
-		The characters of \a std_str are taken to be unencoded data which represent Unicode code points 0x00..0xFF.  No translation of
-		the provided data will occur.
-
-	\param str_idx
-		Index of the first character from \a std_str to be inserted.
-
-	\param str_num
-		Maximum number of characters from \a str to be inserted.
-
-	\return
-		This String after the insert.
-
-	\exception std::out_of_range	Thrown if \a idx or \a str_idx are out of range.
-	\exception std::length_error	Thrown if resulting String would be too large.
-	*/
-	String& insert(size_type idx, const std::string& std_str, size_type str_idx, size_type str_num)
-	{
-		if (d_cplength < idx)
-			throw std::out_of_range("Index is out of range for CEGUI::String");
-
-		if (std_str.size() < str_idx)
-			throw std::out_of_range("Index is out of range for std::string");
-
-		if (str_num == npos)
-			str_num = (size_type)std_str.size() - str_idx;
-
-		size_type newsz = d_cplength + str_num;
-		grow(newsz);
-
-		memmove(&ptr()[idx + str_num], &ptr()[idx], (d_cplength - idx) * sizeof(utf32));
-
-		utf32* pt = &ptr()[idx + str_num - 1];
-		
-		while(str_num--)
-			*pt-- = static_cast<utf32>(static_cast<unsigned char>(std_str[str_idx + str_num]));
-
-		setlen(newsz);
-
-		return *this;
-	}
-
-	/*!
-	\brief
-		Inserts the given null-terminated utf8 encoded data at the specified position.
-
-	\param idx
-		Index where the data is to be inserted.
-
-	\param utf8_str
-		Buffer containing the null-terminated utf8 encoded data that is to be inserted.
-
-	\note
-		A basic string literal (cast to utf8*) can be passed to this function, provided that the string is
-		comprised only of code points 0x00..0x7f.  The use of extended ASCII characters (with values >0x7f)
-		would result in incorrect behaviour as the String will attempt to 'decode' the data, with unpredictable
-		results.
-
-	\return
-		This String after the insert.
-
-	\exception std::out_of_range	Thrown if \a idx is invalid for this String.
-	\exception std::length_error	Thrown if resulting String would be too large.
-	*/
-	String&	insert(size_type idx, const utf8* utf8_str)
-	{
-		return insert(idx, utf8_str, utf_length(utf8_str));
-	}
-
-	/*!
-	\brief
-		Inserts the given utf8 encoded data at the specified position.
-
-	\param idx
-		Index where the data is to be inserted.
-
-	\param utf8_str
-		Buffer containing the utf8 encoded data that is to be inserted.
-
-	\note
-		A basic string literal (cast to utf8*) can be passed to this function, provided that the string is
-		comprised only of code points 0x00..0x7f.  The use of extended ASCII characters (with values >0x7f)
-		would result in incorrect behaviour as the String will attempt to 'decode' the data, with unpredictable
-		results.
-
-	\param len
-		Length of the data to be inserted in uf8 code units (not code points)
-
-	\return
-		This String after the insert.
-
-	\exception std::out_of_range	Thrown if \a idx is invalid for this String.
-	\exception std::length_error	Thrown if resulting String would be too large, or if \a len is 'npos'
-	*/
-	String& insert(size_type idx, const utf8* utf8_str, size_type len)
-	{
-		if (d_cplength < idx)
-			throw std::out_of_range("Index is out of range for CEGUI::String");
-
-		if (len == npos)
-			throw std::length_error("Length of utf8 encoded string can not be 'npos'");
-
-		size_type encsz = encoded_size(utf8_str, len);
-		size_type newsz = d_cplength + encsz;
-
-		grow(newsz);
-		memmove(&ptr()[idx + encsz], &ptr()[idx], (d_cplength - idx) * sizeof(utf32));
-		encode(utf8_str, &ptr()[idx], encsz, len);
-		setlen(newsz);
-
-		return *this;
-	}
-
-	/*!
-	\brief
-		Inserts a code point multiple times into the String
-
-	\param idx
-		Index where the code point(s) are to be inserted
-
-	\param num
-		The number of times to insert the code point
-
-	\param code_point
-		The utf32 code point that is to be inserted
-
-	\return
-		This String after the insertion.
-
-	\exception std::out_of_range	Thrown if \a idx is invalid for this String.
-	\exception std::length_error	Thrown if resulting String would be too large, or if \a num is 'npos'
-	*/
-	String& insert(size_type idx, size_type num, utf32 code_point)
-	{
-		if (d_cplength < idx)
-			throw std::out_of_range("Index is out of range for CEGUI::String");
-
-		if (num == npos)
-			throw std::length_error("Code point count can not be 'npos'");
-
-		size_type newsz = d_cplength + num;
-		grow(newsz);
-
-		memmove(&ptr()[idx + num], &ptr()[idx], (d_cplength - idx) * sizeof(utf32));
-
-		utf32* pt = &ptr()[idx + num - 1];
-
-		while(num--)
-			*pt-- = code_point;
-
-		setlen(newsz);
-
-		return *this;
-	}
-
-	/*!
-	\brief
-		Inserts a code point multiple times into the String
-
-	\param pos
-		Iterator describing the position where the code point(s) are to be inserted
-
-	\param num
-		The number of times to insert the code point
-
-	\param code_point
-		The utf32 code point that is to be inserted
-
-	\return
-		This String after the insertion.
-
-	\exception std::length_error	Thrown if resulting String would be too large, or if \a num is 'npos'
-	*/
-	void insert(iterator pos, size_type num, utf32 code_point)
-	{
-		insert(safe_iter_dif(pos, begin()), num, code_point);
-	}
-
-	/*!
-	\brief
-		Inserts a single code point into the String
-
-	\param pos
-		Iterator describing the position where the code point is to be inserted
-
-	\param code_point
-		The utf32 code point that is to be inserted
-
-	\return
-		This String after the insertion.
-
-	\exception std::length_error	Thrown if resulting String would be too large.
-	*/
-	iterator insert(iterator pos, utf32 code_point)
-	{
-		insert(pos, 1, code_point);
-		return pos;
-	}
-
-	/*!
-	\brief
-		Inserts code points specified by the range [beg, end).
-
-	\param pos
-		Iterator describing the position where the data is to be inserted
-
-	\param beg
-		Iterator describing the begining of the range to be inserted
-
-	\param end
-		Iterator describing the (exclusive) end of the range to be inserted.
-
-	\return
-		Nothing.
-
-	\exception std::length_error	Thrown if resulting String would be too large.
-	*/
-	void	insert(iterator iter_pos, const_iterator iter_beg, const_iterator iter_end)
-	{
-		replace(iter_pos, iter_pos, iter_beg, iter_end);
-	}
-
-
-	/*!
-	\brief
-		Inserts the given c-string at the specified position.
-
-	\param idx
-		Index where the c-string is to be inserted.
-
-	\param c_str
-		c-string that is to be inserted.
-
-	\return
-		This String after the insert.
-
-	\exception std::out_of_range	Thrown if \a idx is invalid for this String.
-	\exception std::length_error	Thrown if resulting String would be too large.
-	*/
-	String&	insert(size_type idx, const char* cstr)
-	{
-		return insert(idx, cstr, strlen(cstr));
-	}
-
-
-	/*!
-	\brief
-		Inserts chars from the given char array at the specified position.
-
-	\param idx
-		Index where the data is to be inserted.
-
-	\param chars
-		char array containing the chars that are to be inserted.
-
-	\param chars_len
-		Length of the char array to be inserted.
-
-	\return
-		This String after the insert.
-
-	\exception std::out_of_range	Thrown if \a idx is invalid for this String.
-	\exception std::length_error	Thrown if resulting String would be too large, or if \a chars_len is 'npos'
-	*/
-	String& insert(size_type idx, const char* chars, size_type chars_len)
-	{
-		if (d_cplength < idx)
-			throw std::out_of_range("Index is out of range for CEGUI::String");
-
-		if (chars_len == npos)
-			throw std::length_error("Length of char array can not be 'npos'");
-
-		size_type newsz = d_cplength + chars_len;
-
-		grow(newsz);
-		memmove(&ptr()[idx + chars_len], &ptr()[idx], (d_cplength - idx) * sizeof(utf32));
-
-		utf32* pt = &ptr()[idx + chars_len - 1];
-
-		while(chars_len--)
-			*pt-- = static_cast<utf32>(static_cast<unsigned char>(chars[chars_len]));
-
-		setlen(newsz);
-
-		return *this;
-	}
-
-
-	//////////////////////////////////////////////////////////////////////////
-	// Erasing characters
-	//////////////////////////////////////////////////////////////////////////
-	/*!
-	\brief
-		Removes all data from the String
-
-	\return
-		Nothing
-	*/
-	void	clear(void)
-	{
-		setlen(0);
-		trim();
-	}
-
-	/*!
-	\brief
-		Removes all data from the String
-
-	\return
-		The empty String (*this)
-	*/
-	String& erase(void)
-	{
-		clear();
-		return *this;
-	}
-
-	/*!
-	\brief
-		Erase a single code point from the string
-
-	\param idx
-		The index of the code point to be removed.
-
-	\return
-		This String after the erase operation
-
-	\exception std::out_of_range	Thrown if \a idx is invalid for this String.
-	*/
-	String&	erase(size_type idx)
-	{
-		return erase(idx, 1);
-	}
-
-	/*!
-	\brief
-		Erase a range of code points
-
-	\param idx
-		Index of the first code point to be removed.
-
-	\param len
-		Maximum number of code points to be removed.
-
-	\return
-		This String after the erase operation.
-
-	\exception std::out_of_range	Thrown if \a idx is invalid for this String.
-	*/
-	String& erase(size_type idx, size_type len = npos)
-	{
-		if (d_cplength < idx)
-			throw std::out_of_range("Index is out of range foe CEGUI::String");
-
-		if (len == npos)
-			len = d_cplength - idx;
-
-		size_type newsz = d_cplength - len;
-
-		memmove(&ptr()[idx], &ptr()[idx + len], (d_cplength - idx - len) * sizeof(utf32));
-		setlen(newsz);
-		return	*this;
-	}
-
-	/*!
-	\brief
-		Erase the code point described by the given iterator
-
-	\param pos
-		Iterator describing the code point to be erased
-
-	\return
-		This String after the erase operation.
-	*/
-	String& erase(iterator pos)
-	{
-		return erase(safe_iter_dif(pos, begin()), 1);
-	}
-
-	/*!
-	\brief
-		Erase a range of code points described by the iterators [beg, end).
-
-	\param beg
-		Iterator describing the postion of the beginning of the range to erase
-
-	\param end
-		Iterator describing the postion of the (exclusive) end of the range to erase
-
-	\return
-		This String after the erase operation.
-	*/
-	String& erase(iterator iter_beg, iterator iter_end)
-	{
-		return erase(safe_iter_dif(iter_beg, begin()), safe_iter_dif(iter_end, iter_beg));
-	}
-
-	//////////////////////////////////////////////////////////////////////////
-	// Resizing
-	//////////////////////////////////////////////////////////////////////////
-	/*!
-	\brief
-		Resizes the String either by inserting default utf32 code points to make it larger, or by truncating to make it smaller
-
-	\param num
-		The length, in code points, that the String is to be made.
-
-	\return
-		Nothing.
-
-	\exception std::length_error	Thrown if the String would be too large.
-	*/
-	void	resize(size_type num)
-	{
-		resize(num, utf32());
-	}
-
-	/*!
-	\brief
-		Resizes the String either by inserting the given utf32 code point to make it larger, or by truncating to make it smaller
-
-	\param num
-		The length, in code points, that the String is to be made.
-
-	\param code_point
-		The utf32 code point that should be used when majing the String larger
-
-	\return
-		Nothing.
-
-	\exception std::length_error	Thrown if the String would be too large.
-	*/
-	void	resize(size_type num, utf32 code_point)
-	{
-		if (num < d_cplength)
-		{
-			setlen(num);
-		}
-		else
-		{
-			append(num - d_cplength, code_point);
-		}
-
-	}
-
-	//////////////////////////////////////////////////////////////////////////
-	// Replacing Characters
-	//////////////////////////////////////////////////////////////////////////
-	/*!
-	\brief
-		Replace code points in the String with the specified String object
-
-	\param idx
-		Index of the first code point to be replaced
-
-	\param len
-		Maximum number of code points to be replaced (if this is 0, operation is an insert at position \a idx)
-
-	\param str
-		The String object that is to replace the specified code points
-
-	\return
-		This String after the replace operation
-
-	\exception std::out_of_range	Thrown if \a idx is invalid for this String
-	\exception std::length_error	Thrown if the resulting String would be too large.
-	*/
-	String& replace(size_type idx, size_type len, const String& str)
-	{
-		return replace(idx, len, str, 0, npos);
-	}
-
-	/*!
-	\brief
-		Replace the code points in the range [beg, end) with the specified String object
-
-	\note
-		If \a beg == \a end, the operation is a insert at iterator position \a beg
-
-	\param beg
-		Iterator describing the start of the range to be replaced
-
-	\param end
-		Iterator describing the (exclusive) end of the range to be replaced.
-
-	\param str
-		The String object that is to replace the specified range of code points
-
-	\return
-		This String after the replace operation
-
-	\exception std::length_error	Thrown if the resulting String would be too large.
-	*/
-	String& replace(iterator iter_beg, iterator iter_end, const String& str)
-	{
-		return replace(safe_iter_dif(iter_beg, begin()), safe_iter_dif(iter_end, iter_beg), str, 0, npos);
-	}
-
-	/*!
-	\brief
-		Replace code points in the String with a specified sub-string of a given String object.
-
-	\param idx
-		Index of the first code point to be replaced
-
-	\param len
-		Maximum number of code points to be replaced.  If this is 0, the operation is an insert at position \a idx.
-
-	\param str
-		String object containing the data that will replace the specified range of code points
-
-	\param str_idx
-		Index of the first code point of \a str that is to replace the specified code point range
-
-	\param str_num
-		Maximum number of code points of \a str that are to replace the specified code point range
-
-	\return
-		This String after the replace operation
-
-	\exception std::out_of_range	Thrown if either \a idx, or \a str_idx are invalid
-	\exception std::length_error	Thrown if the resulting String would have been too large.
-	*/
-	String& replace(size_type idx, size_type len, const String& str, size_type str_idx, size_type str_num)
-	{
-		if ((d_cplength < idx) || (str.d_cplength < str_idx))
-			throw std::out_of_range("Index is out of range for CEGUI::String");
-
-		if (((str_idx + str_num) > str.d_cplength) || (str_num == npos))
-			str_num = str.d_cplength - str_idx;
-
-		if (((len + idx) > d_cplength) || (len == npos))
-			len = d_cplength - idx;
-
-		size_type newsz = d_cplength + str_num - len;
-
-		grow(newsz);
-
-		if ((idx + len) < d_cplength)
-			memmove(&ptr()[idx + str_num], &ptr()[len + idx], (d_cplength - idx - len) * sizeof(utf32));
-
-		memcpy(&ptr()[idx], &str.ptr()[str_idx], str_num * sizeof(utf32));
-		setlen(newsz);
-
-		return *this;
-	}
-
-
-	/*!
-	\brief
-		Replace code points in the String with the specified std::string object
-
-	\param idx
-		Index of the first code point to be replaced
-
-	\param len
-		Maximum number of code points to be replaced (if this is 0, operation is an insert at position \a idx)
-
-	\param std_str
-		The std::string object that is to replace the specified code points
-
-	\note
-		Characters from \a std_str are considered to represent Unicode code points in the range 0x00..0xFF.  No translation of
-		the encountered data is performed.
-
-	\return
-		This String after the replace operation
-
-	\exception std::out_of_range	Thrown if \a idx is invalid for this String
-	\exception std::length_error	Thrown if the resulting String would be too large.
-	*/
-	String& replace(size_type idx, size_type len, const std::string& std_str)
-	{
-		return replace(idx, len, std_str, 0, npos);
-	}
-
-	/*!
-	\brief
-		Replace the code points in the range [beg, end) with the specified std::string object
-
-	\note
-		If \a beg == \a end, the operation is a insert at iterator position \a beg
-
-	\param beg
-		Iterator describing the start of the range to be replaced
-
-	\param end
-		Iterator describing the (exclusive) end of the range to be replaced.
-
-	\param std_str
-		The std::string object that is to replace the specified range of code points
-
-	\note
-		Characters from \a std_str are considered to represent Unicode code points in the range 0x00..0xFF.  No translation of
-		the encountered data is performed.
-
-	\return
-		This String after the replace operation
-
-	\exception std::length_error	Thrown if the resulting String would be too large.
-	*/
-	String& replace(iterator iter_beg, iterator iter_end, const std::string& std_str)
-	{
-		return replace(safe_iter_dif(iter_beg, begin()), safe_iter_dif(iter_end, iter_beg), std_str, 0, npos);
-	}
-
-	/*!
-	\brief
-		Replace code points in the String with a specified sub-string of a given std::string object.
-
-	\param idx
-		Index of the first code point to be replaced
-
-	\param len
-		Maximum number of code points to be replaced.  If this is 0, the operation is an insert at position \a idx.
-
-	\param std_str
-		std::string object containing the data that will replace the specified range of code points
-
-	\note
-		Characters from \a std_str are considered to represent Unicode code points in the range 0x00..0xFF.  No translation of
-		the encountered data is performed.
-
-	\param str_idx
-		Index of the first code point of \a std_str that is to replace the specified code point range
-
-	\param str_num
-		Maximum number of code points of \a std_str that are to replace the specified code point range
-
-	\return
-		This String after the replace operation
-
-	\exception std::out_of_range	Thrown if either \a idx, or \a str_idx are invalid
-	\exception std::length_error	Thrown if the resulting String would have been too large.
-	*/
-	String& replace(size_type idx, size_type len, const std::string& std_str, size_type str_idx, size_type str_num)
-	{
-		if (d_cplength < idx)
-			throw std::out_of_range("Index is out of range for CEGUI::String");
-
-		if (std_str.size() < str_idx)
-			throw std::out_of_range("Index is out of range for std::string");
-
-		if (((str_idx + str_num) > std_str.size()) || (str_num == npos))
-			str_num = (size_type)std_str.size() - str_idx;
-
-		if (((len + idx) > d_cplength) || (len == npos))
-			len = d_cplength - idx;
-
-		size_type newsz = d_cplength + str_num - len;
-
-		grow(newsz);
-
-		if ((idx + len) < d_cplength)
-			memmove(&ptr()[idx + str_num], &ptr()[len + idx], (d_cplength - idx - len) * sizeof(utf32));
-
-		utf32* pt = &ptr()[idx + str_num - 1];
-
-		while (str_num--)
-			*pt-- = static_cast<utf32>(static_cast<unsigned char>(std_str[str_idx + str_num]));
-
-		setlen(newsz);
-
-		return *this;
-	}
-
-
-	/*!
-	\brief
-		Replace code points in the String with the specified null-terminated utf8 encoded data.
-
-	\param idx
-		Index of the first code point to be replaced
-
-	\param len
-		Maximum number of code points to be replaced (if this is 0, operation is an insert at position \a idx)
-
-	\param utf8_str
-		Buffer containing the null-terminated utf8 encoded data that is to replace the specified code points
-
-	\note
-		A basic string literal (cast to utf8*) can be passed to this function, provided that the string is
-		comprised only of code points 0x00..0x7f.  The use of extended ASCII characters (with values >0x7f)
-		would result in incorrect behaviour as the String will attempt to 'decode' the data, with unpredictable
-		results.
-
-	\return
-		This String after the replace operation
-
-	\exception std::out_of_range	Thrown if \a idx is invalid for this String
-	\exception std::length_error	Thrown if the resulting String would be too large.
-	*/
-	String& replace(size_type idx, size_type len, const utf8* utf8_str)
-	{
-		return replace(idx, len, utf8_str, utf_length(utf8_str));
-	}
-
-	/*!
-	\brief
-		Replace the code points in the range [beg, end) with the specified null-terminated utf8 encoded data.
-
-	\note
-		If \a beg == \a end, the operation is a insert at iterator position \a beg
-
-	\param beg
-		Iterator describing the start of the range to be replaced
-
-	\param end
-		Iterator describing the (exclusive) end of the range to be replaced.
-
-	\param utf8_str
-		Buffer containing the null-terminated utf8 encoded data that is to replace the specified range of code points
-
-	\note
-		A basic string literal (cast to utf8*) can be passed to this function, provided that the string is
-		comprised only of code points 0x00..0x7f.  The use of extended ASCII characters (with values >0x7f)
-		would result in incorrect behaviour as the String will attempt to 'decode' the data, with unpredictable
-		results.
-
-	\return
-		This String after the replace operation
-
-	\exception std::length_error	Thrown if the resulting String would be too large.
-	*/
-	String& replace(iterator iter_beg, iterator iter_end, const utf8* utf8_str)
-	{
-		return replace(iter_beg, iter_end, utf8_str, utf_length(utf8_str));
-	}
-
-	/*!
-	\brief
-		Replace code points in the String with the specified utf8 encoded data.
-
-	\param idx
-		Index of the first code point to be replaced
-
-	\param len
-		Maximum number of code points to be replaced (if this is 0, operation is an insert at position \a idx)
-
-	\param utf8_str
-		Buffer containing the null-terminated utf8 encoded data that is to replace the specified code points
-
-	\note
-		A basic string literal (cast to utf8*) can be passed to this function, provided that the string is
-		comprised only of code points 0x00..0x7f.  The use of extended ASCII characters (with values >0x7f)
-		would result in incorrect behaviour as the String will attempt to 'decode' the data, with unpredictable
-		results.
-
-	\param str_len
-		Length of the utf8 encoded data in utf8 code units (not code points).
-
-	\return
-		This String after the replace operation
-
-	\exception std::out_of_range	Thrown if \a idx is invalid for this String
-	\exception std::length_error	Thrown if the resulting String would be too large, or if \a str_len was 'npos'.
-	*/
-	String& replace(size_type idx, size_type len, const utf8* utf8_str, size_type str_len)
-	{
-		if (d_cplength < idx)
-			throw std::out_of_range("Index is out of range for CEGUI::String");
-
-		if (str_len == npos)
-			throw std::length_error("Length for utf8 encoded string can not be 'npos'");
-
-		if (((len + idx) > d_cplength) || (len == npos))
-			len = d_cplength - idx;
-
-		size_type encsz = encoded_size(utf8_str, str_len);
-		size_type newsz = d_cplength + encsz - len;
-
-		grow(newsz);
-
-		if ((idx + len) < d_cplength)
-			memmove(&ptr()[idx + encsz], &ptr()[len + idx], (d_cplength - idx - len) * sizeof(utf32));
-
-		encode(utf8_str, &ptr()[idx], encsz, str_len);
-
-		setlen(newsz);
-		return *this;
-	}
-
-	/*!
-	\brief
-		Replace the code points in the range [beg, end) with the specified null-terminated utf8 encoded data.
-
-	\note
-		If \a beg == \a end, the operation is a insert at iterator position \a beg
-
-	\param beg
-		Iterator describing the start of the range to be replaced
-
-	\param end
-		Iterator describing the (exclusive) end of the range to be replaced.
-
-	\param utf8_str
-		Buffer containing the null-terminated utf8 encoded data that is to replace the specified range of code points
-
-	\note
-		A basic string literal (cast to utf8*) can be passed to this function, provided that the string is
-		comprised only of code points 0x00..0x7f.  The use of extended ASCII characters (with values >0x7f)
-		would result in incorrect behaviour as the String will attempt to 'decode' the data, with unpredictable
-		results.
-
-	\param str_len
-		Length of the utf8 encoded data in utf8 code units (not code points).
-
-	\return
-		This String after the replace operation
-
-		\exception std::length_error	Thrown if the resulting String would be too large, or if \a str_len was 'npos'.
-	*/
-	String& replace(iterator iter_beg, iterator iter_end, const utf8* utf8_str, size_type str_len)
-	{
-		return replace(safe_iter_dif(iter_beg, begin()), safe_iter_dif(iter_end, iter_beg), utf8_str, str_len);
-	}
-
-	/*!
-	\brief
-		Replaces a specified range of code points with occurrences of a given code point
-
-	\param idx
-		Index of the first code point to be replaced
-
-	\param len
-		Maximum number of code points to replace.  If this is 0 the operation is an insert
-
-	\param num
-		Number of occurrences of \a code_point that are to replace the specified range of code points
-
-	\param code_point
-		Code point that is to be used when replacing the specified range of code points
-
-	\return
-		This String after the replace operation.
-
-	\exception std::out_of_range	Thrown if \a idx is invalid for this String
-	\exception std::length_error	Thrown if resulting String would have been too long, or if \a num was 'npos'.
-	*/
-	String& replace(size_type idx, size_type len, size_type num, utf32 code_point)
-	{
-		if (d_cplength < idx)
-			throw std::out_of_range("Index is out of range for CEGUI::String");
-
-		if (num == npos)
-			throw std::length_error("Code point count can not be 'npos'");
-
-		if (((len + idx) > d_cplength) || (len == npos))
-			len = d_cplength - idx;
-
-		size_type newsz = d_cplength + num - len;
-
-		grow(newsz);
-
-		if ((idx + len) < d_cplength)
-			memmove(&ptr()[idx + num], &ptr()[len + idx], (d_cplength - idx - len) * sizeof(utf32));
-
-		utf32* pt = &ptr()[idx + num - 1];
-
-		while (num--)
-			*pt-- = code_point;
-
-		setlen(newsz);
-
-		return *this;
-	}
-
-	/*!
-	\brief
-		Replace the code points in the range [beg, end) with occurrences of a given code point
-
-	\note
-		If \a beg == \a end, the operation is an insert at iterator position \a beg
-
-	\param beg
-		Iterator describing the start of the range to be replaced
-
-	\param end
-		Iterator describing the (exclusive) end of the range to be replaced.
-
-	\param num
-		Number of occurrences of \a code_point that are to replace the specified range of code points
-
-	\param code_point
-		Code point that is to be used when replacing the specified range of code points
-
-	\return
-		This String after the replace operation
-
-	\exception std::length_error	Thrown if resulting String would have been too long, or if \a num was 'npos'.
-	*/
-	String& replace(iterator iter_beg, iterator iter_end, size_type num, utf32 code_point)
-	{
-		return replace(safe_iter_dif(iter_beg, begin()), safe_iter_dif(iter_end, iter_beg), num, code_point);
-	}
-
-
-	/*!
-	\brief
-		Replace the code points in the range [beg, end) with code points from the range [newBeg, newEnd).
-
-	\note
-		If \a beg == \a end, the operation is an insert at iterator position \a beg
-
-	\param beg
-		Iterator describing the start of the range to be replaced
-
-	\param end
-		Iterator describing the (exclusive) end of the range to be replaced.
-
-	\param newBeg
-		Iterator describing the beginning of the range to insert.
-
-	\param newEnd	
-		Iterator describing the (exclusive) end of the range to insert.
-
-	\return
-		This String after the insert operation.
-
-	\exception std::length_error	Thrown if the resulting string would be too long.
-	*/
-	String& replace(iterator iter_beg, iterator iter_end, const_iterator iter_newBeg, const_iterator iter_newEnd)
-	{
-		if (iter_beg == iter_end)
-		{
-			erase(safe_iter_dif(iter_beg, begin()), safe_iter_dif(iter_end, iter_beg));
-		}
-		else
-		{
-			size_type str_len = safe_iter_dif(iter_newEnd, iter_newBeg);
-			size_type idx = safe_iter_dif(iter_beg, begin());
-			size_type len = safe_iter_dif(iter_end, iter_beg);
-
-			if ((len + idx) > d_cplength)
-				len = d_cplength - idx;
-
-			size_type newsz = d_cplength + str_len - len;
-
-			grow(newsz);
-
-			if ((idx + len) < d_cplength)
-				memmove(&ptr()[idx + str_len], &ptr()[len + idx], (d_cplength - idx - len) * sizeof(utf32));
-
-			memcpy(&ptr()[idx], iter_newBeg.d_ptr, str_len * sizeof(utf32));
-			setlen(newsz);
-		}
-
-		return *this;
-	}
-
-
-	/*!
-	\brief
-		Replace code points in the String with the specified c-string.
-
-	\param idx
-		Index of the first code point to be replaced
-
-	\param len
-		Maximum number of code points to be replaced (if this is 0, operation is an insert at position \a idx)
-
-	\param c_str
-		c-string that is to replace the specified code points
-
-	\return
-		This String after the replace operation
-
-	\exception std::out_of_range	Thrown if \a idx is invalid for this String
-	\exception std::length_error	Thrown if the resulting String would be too large.
-	*/
-	String& replace(size_type idx, size_type len, const char* cstr)
-	{
-		return replace(idx, len, cstr, strlen(cstr));
-	}
-
-
-	/*!
-	\brief
-		Replace the code points in the range [beg, end) with the specified c-string.
-
-	\note
-		If \a beg == \a end, the operation is a insert at iterator position \a beg
-
-	\param beg
-		Iterator describing the start of the range to be replaced
-
-	\param end
-		Iterator describing the (exclusive) end of the range to be replaced.
-
-	\param c_str
-		c-string that is to replace the specified range of code points
-
-	\return
-		This String after the replace operation
-
-	\exception std::length_error	Thrown if the resulting String would be too large.
-	*/
-	String& replace(iterator iter_beg, iterator iter_end, const char* cstr)
-	{
-		return replace(iter_beg, iter_end, cstr, strlen(cstr));
-	}
-
-
-	/*!
-	\brief
-		Replace code points in the String with chars from the given char array.
-
-	\param idx
-		Index of the first code point to be replaced
-
-	\param len
-		Maximum number of code points to be replaced (if this is 0, operation is an insert at position \a idx)
-
-	\param chars
-		char array containing the cars that are to replace the specified code points
-
-	\param chars_len
-		Number of chars in the char array.
-
-	\return
-		This String after the replace operation
-
-	\exception std::out_of_range	Thrown if \a idx is invalid for this String
-	\exception std::length_error	Thrown if the resulting String would be too large, or if \a chars_len was 'npos'.
-	*/
-	String& replace(size_type idx, size_type len, const char* chars, size_type chars_len)
-	{
-		if (d_cplength < idx)
-			throw std::out_of_range("Index is out of range for CEGUI::String");
-
-		if (chars_len == npos)
-			throw std::length_error("Length for the char array can not be 'npos'");
-
-		if (((len + idx) > d_cplength) || (len == npos))
-			len = d_cplength - idx;
-
-		size_type newsz = d_cplength + chars_len - len;
-
-		grow(newsz);
-
-		if ((idx + len) < d_cplength)
-			memmove(&ptr()[idx + chars_len], &ptr()[len + idx], (d_cplength - idx - len) * sizeof(utf32));
-
-		utf32* pt = &ptr()[idx + chars_len - 1];
-
-		while (chars_len--)
-			*pt-- = static_cast<utf32>(static_cast<unsigned char>(chars[chars_len]));
-
-		setlen(newsz);
-		return *this;
-	}
-
-
-	/*!
-	\brief
-		Replace the code points in the range [beg, end) with chars from the given char array.
-
-	\note
-		If \a beg == \a end, the operation is a insert at iterator position \a beg
-
-	\param beg
-		Iterator describing the start of the range to be replaced
-
-	\param end
-		Iterator describing the (exclusive) end of the range to be replaced.
-
-	\param chars
-		char array containing the chars that are to replace the specified range of code points
-
-	\param chars_len
-		Number of chars in the char array.
-
-	\return
-		This String after the replace operation
-
-	\exception std::length_error	Thrown if the resulting String would be too large, or if \a chars_len was 'npos'.
-	*/
-	String& replace(iterator iter_beg, iterator iter_end, const char* chars, size_type chars_len)
-	{
-		return replace(safe_iter_dif(iter_beg, begin()), safe_iter_dif(iter_end, iter_beg), chars, chars_len);
-	}
-
-
-	//////////////////////////////////////////////////////////////////////////
-	// Find a code point
-	//////////////////////////////////////////////////////////////////////////
-	/*!
-	\brief
-		Search forwards for a given code point
-
-	\param code_point
-		The utf32 code point to search for
-
-	\param idx
-		Index of the code point where the search is to start.
-
-	\return
-		- Index of the first occurrence of \a code_point travelling forwards from \a idx.
-		- npos if the code point could not be found
-	*/
-	size_type	find(utf32 code_point, size_type idx = 0) const
-	{
-		if (idx < d_cplength)
-		{
-			const utf32* pt = &ptr()[idx];
-
-			while (idx < d_cplength)
-			{
-				if (*pt++ == code_point)
-					return idx;
-
-				++idx;
-			}
-
-		}
-
-		return npos;
-	}
-
-	/*!
-	\brief
-		Search backwards for a given code point
-
-	\param code_point
-		The utf32 code point to search for
-
-	\param idx
-		Index of the code point where the search is to start.
-
-	\return
-		- Index of the first occurrence of \a code_point travelling backwards from \a idx.
-		- npos if the code point could not be found
-	*/
-	size_type	rfind(utf32 code_point, size_type idx = npos) const
-	{
-		if (idx >= d_cplength)
-			idx = d_cplength - 1;
-
-		if (d_cplength > 0)
-		{
-			const utf32* pt = &ptr()[idx];
-
-			do
-			{
-				if (*pt-- == code_point)
-					return idx;
-
-			} while (idx-- != 0);
-
-		}
-
-		return npos;
-	}
-
-	//////////////////////////////////////////////////////////////////////////
-	// Find a substring
-	//////////////////////////////////////////////////////////////////////////
-	/*!
-	\brief
-		Search forwards for a sub-string
-
-	\param str
-		String object describing the sub-string to search for
-
-	\param idx
-		Index of the code point where the search is to start
-
-	\return
-		- Index of the first occurrence of sub-string \a str travelling forwards from \a idx.
-		- npos if the sub-string could not be found
-	*/
-	size_type	find(const String& str, size_type idx = 0) const
-	{
-		if ((str.d_cplength == 0) && (idx < d_cplength))
-			return idx;
-
-		if (idx < d_cplength)
-		{
-			// loop while search string could fit in to search area
-			while (d_cplength - idx >= str.d_cplength)
-			{
-				if (0 == compare(idx, str.d_cplength, str))
-					return idx;
-
-				++idx;
-			}
-
-		}
-
-		return npos;
-	}
-
-	/*!
-	\brief
-		Search backwards for a sub-string
-
-	\param str
-		String object describing the sub-string to search for
-
-	\param idx
-		Index of the code point where the search is to start
-
-	\return
-		- Index of the first occurrence of sub-string \a str travelling backwards from \a idx.
-		- npos if the sub-string could not be found
-	*/
-	size_type	rfind(const String& str, size_type idx = npos) const
-	{
-		if (str.d_cplength == 0)
-			return (idx < d_cplength) ? idx : d_cplength;
-
-		if (str.d_cplength <= d_cplength)
-		{
-			if (idx > (d_cplength - str.d_cplength))
-				idx = d_cplength - str.d_cplength;
-
-			do
-			{
-				if (0 == compare(idx, str.d_cplength, str))
-					return idx;
-
-			} while (idx-- != 0);
-
-		}
-
-		return npos;
-	}
-
-	/*!
-	\brief
-		Search forwards for a sub-string
-
-	\param std_str
-		std::string object describing the sub-string to search for
-
-	\note
-		Characters from \a std_str are considered to represent Unicode code points in the range 0x00..0xFF.  No translation of
-		the encountered data is performed.
-
-	\param idx
-		Index of the code point where the search is to start
-
-	\return
-		- Index of the first occurrence of sub-string \a std_str travelling forwards from \a idx.
-		- npos if the sub-string could not be found
-	*/
-	size_type	find(const std::string& std_str, size_type idx = 0) const
-	{
-		std::string::size_type sze = std_str.size();
-
-		if ((sze == 0) && (idx < d_cplength))
-			return idx;
-
-		if (idx < d_cplength)
-		{
-			// loop while search string could fit in to search area
-			while (d_cplength - idx >= sze)
-			{
-				if (0 == compare(idx, (size_type)sze, std_str))
-					return idx;
-
-				++idx;
-			}
-
-		}
-
-		return npos;
-	}
-
-	/*!
-	\brief
-		Search backwards for a sub-string
-
-	\param std_str
-		std::string object describing the sub-string to search for
-
-	\note
-		Characters from \a std_str are considered to represent Unicode code points in the range 0x00..0xFF.  No translation of
-		the encountered data is performed.
-
-	\param idx
-		Index of the code point where the search is to start
-
-	\return
-		- Index of the first occurrence of sub-string \a std_str travelling backwards from \a idx.
-		- npos if the sub-string could not be found
-	*/
-	size_type	rfind(const std::string& std_str, size_type idx = npos) const
-	{
-		std::string::size_type sze = std_str.size();
-
-		if (sze == 0)
-			return (idx < d_cplength) ? idx : d_cplength;
-
-		if (sze <= d_cplength)
-		{
-			if (idx > (d_cplength - sze))
-				idx = d_cplength - sze;
-
-			do
-			{
-				if (0 == compare(idx, (size_type)sze, std_str))
-					return idx;
-
-			} while (idx-- != 0);
-
-		}
-
-		return npos;
-	}
-
-	/*!
-	\brief
-		Search forwards for a sub-string
-
-	\param utf8_str
-		Buffer containing null-terminated utf8 encoded data describing the sub-string to search for
-
-	\note
-		A basic string literal (cast to utf8*) can be passed to this function, provided that the string is
-		comprised only of code points 0x00..0x7f.  The use of extended ASCII characters (with values >0x7f)
-		would result in incorrect behaviour as the String will attempt to 'decode' the data, with unpredictable
-		results.
-
-	\param idx
-		Index of the code point where the search is to start
-
-	\return
-		- Index of the first occurrence of sub-string \a utf8_str travelling forwards from \a idx.
-		- npos if the sub-string could not be found
-
-	\exception std::out_of_range	Thrown if \a idx is invalid for this String.
-	*/
-	size_type	find(const utf8* utf8_str, size_type idx = 0) const
-	{
-		return find(utf8_str, idx, utf_length(utf8_str));
-	}
-
-	/*!
-	\brief
-		Search backwards for a sub-string
-
-	\param utf8_str
-		Buffer containing null-terminated utf8 encoded data describing the sub-string to search for
-
-	\note
-		A basic string literal (cast to utf8*) can be passed to this function, provided that the string is
-		comprised only of code points 0x00..0x7f.  The use of extended ASCII characters (with values >0x7f)
-		would result in incorrect behaviour as the String will attempt to 'decode' the data, with unpredictable
-		results.
-
-	\param idx
-		Index of the code point where the search is to start
-
-	\return
-		- Index of the first occurrence of sub-string \a utf8_str travelling backwards from \a idx.
-		- npos if the sub-string could not be found
-
-	\exception std::out_of_range	Thrown if \a idx is invalid for this String.
-	*/
-	size_type	rfind(const utf8* utf8_str, size_type idx = npos) const
-	{
-		return rfind(utf8_str, idx, utf_length(utf8_str));
-	}
-
-	/*!
-	\brief
-		Search forwards for a sub-string
-
-	\param utf8_str
-		Buffer containing utf8 encoded data describing the sub-string to search for
-
-	\note
-		A basic string literal (cast to utf8*) can be passed to this function, provided that the string is
-		comprised only of code points 0x00..0x7f.  The use of extended ASCII characters (with values >0x7f)
-		would result in incorrect behaviour as the String will attempt to 'decode' the data, with unpredictable
-		results.
-
-	\param idx
-		Index of the code point where the search is to start
-
-	\param str_len
-		Length of the utf8 encoded sub-string in utf8 code units (not code points)
-
-	\return
-		- Index of the first occurrence of sub-string \a utf8_str travelling forwards from \a idx.
-		- npos if the sub-string could not be found
-
-	\exception std::length_error	Thrown if \a str_len is 'npos'
-	*/
-	size_type	find(const utf8* utf8_str, size_type idx, size_type str_len) const
-	{
-		if (str_len == npos)
-			throw std::length_error("Length for utf8 encoded string can not be 'npos'");
-
-		size_type sze = encoded_size(utf8_str, str_len);
-
-		if ((sze == 0) && (idx < d_cplength))
-			return idx;
-
-		if (idx < d_cplength)
-		{
-			// loop while search string could fit in to search area
-			while (d_cplength - idx >= sze)
-			{
-				if (0 == compare(idx, sze, utf8_str, sze))
-					return idx;
-
-				++idx;
-			}
-
-		}
-
-		return npos;
-	}
-
-	/*!
-	\brief
-		Search backwards for a sub-string
-
-	\param utf8_str
-		Buffer containing utf8 encoded data describing the sub-string to search for
-
-	\note
-		A basic string literal (cast to utf8*) can be passed to this function, provided that the string is
-		comprised only of code points 0x00..0x7f.  The use of extended ASCII characters (with values >0x7f)
-		would result in incorrect behaviour as the String will attempt to 'decode' the data, with unpredictable
-		results.
-
-	\param idx
-		Index of the code point where the search is to start
-
-	\param str_len
-		Length of the utf8 encoded sub-string in utf8 code units (not code points)
-
-	\return
-		- Index of the first occurrence of sub-string \a utf8_str travelling backwards from \a idx.
-		- npos if the sub-string could not be found
-
-	\exception std::length_error	Thrown if \a str_len is 'npos'
-	*/
-	size_type	rfind(const utf8* utf8_str, size_type idx, size_type str_len) const
-	{
-		if (str_len == npos)
-			throw std::length_error("Length for utf8 encoded string can not be 'npos'");
-
-		size_type sze = encoded_size(utf8_str, str_len);
-
-		if (sze == 0)
-			return (idx < d_cplength) ? idx : d_cplength;
-
-		if (sze <= d_cplength)
-		{
-			if (idx > (d_cplength - sze))
-				idx = d_cplength - sze;
-
-			do
-			{
-				if (0 == compare(idx, sze, utf8_str, sze))
-					return idx;
-
-			} while (idx-- != 0);
-
-		}
-
-		return npos;
-	}
-
-
-	/*!
-	\brief
-		Search forwards for a sub-string
-
-	\param c_str
-		c-string describing the sub-string to search for
-
-	\param idx
-		Index of the code point where the search is to start
-
-	\return
-		- Index of the first occurrence of sub-string \a c_str travelling forwards from \a idx.
-		- npos if the sub-string could not be found
-
-	\exception std::out_of_range	Thrown if \a idx is invalid for this String.
-	*/
-	size_type	find(const char* cstr, size_type idx = 0) const
-	{
-		return find(cstr, idx, strlen(cstr));
-	}
-
-
-	/*!
-	\brief
-		Search backwards for a sub-string
-
-	\param c_str
-		c-string describing the sub-string to search for
-
-	\param idx
-		Index of the code point where the search is to start
-
-	\return
-		- Index of the first occurrence of sub-string \a c_str travelling backwards from \a idx.
-		- npos if the sub-string could not be found
-
-	\exception std::out_of_range	Thrown if \a idx is invalid for this String.
-	*/
-	size_type	rfind(const char* cstr, size_type idx = npos) const
-	{
-		return rfind(cstr, idx, strlen(cstr));
-	}
-
-
-	/*!
-	\brief
-		Search forwards for a sub-string
-
-	\param chars
-		char array describing the sub-string to search for
-
-	\param idx
-		Index of the code point where the search is to start
-
-	\param chars_len
-		Number of chars in the char array.
-
-	\return
-		- Index of the first occurrence of sub-string \a chars travelling forwards from \a idx.
-		- npos if the sub-string could not be found
-
-	\exception std::length_error	Thrown if \a chars_len is 'npos'
-	*/
-	size_type	find(const char* chars, size_type idx, size_type chars_len) const
-	{
-		if (chars_len == npos)
-			throw std::length_error("Length for char array can not be 'npos'");
-
-		if ((chars_len == 0) && (idx < d_cplength))
-			return idx;
-
-		if (idx < d_cplength)
-		{
-			// loop while search string could fit in to search area
-			while (d_cplength - idx >= chars_len)
-			{
-				if (0 == compare(idx, chars_len, chars, chars_len))
-					return idx;
-
-				++idx;
-			}
-
-		}
-
-		return npos;
-	}
-
-
-	/*!
-	\brief
-		Search backwards for a sub-string
-
-	\param chars
-		char array describing the sub-string to search for
-
-	\param idx
-		Index of the code point where the search is to start
-
-	\param chars_len
-		Number of chars in the char array.
-
-	\return
-		- Index of the first occurrence of sub-string \a chars travelling backwards from \a idx.
-		- npos if the sub-string could not be found
-
-	\exception std::length_error	Thrown if \a chars_len is 'npos'
-	*/
-	size_type	rfind(const char* chars, size_type idx, size_type chars_len) const
-	{
-		if (chars_len == npos)
-			throw std::length_error("Length for char array can not be 'npos'");
-
-		if (chars_len == 0)
-			return (idx < d_cplength) ? idx : d_cplength;
-
-		if (chars_len <= d_cplength)
-		{
-			if (idx > (d_cplength - chars_len))
-				idx = d_cplength - chars_len;
-
-			do
-			{
-				if (0 == compare(idx, chars_len, chars, chars_len))
-					return idx;
-
-			} while (idx-- != 0);
-
-		}
-
-		return npos;
-	}
-
-
-	//////////////////////////////////////////////////////////////////////////
-	// Find first of different code-points
-	//////////////////////////////////////////////////////////////////////////
-	/*!
-	\brief
-		Find the first occurrence of one of a set of code points.
-
-	\param str
-		String object describing the set of code points.
-
-	\param idx
-		Index of the start point for the search
-
-	\return
-		- Index of the first occurrence of any one of the code points in \a str starting from from \a idx.
-		- npos if none of the code points in \a str were found.
-	*/
-	size_type	find_first_of(const String& str, size_type idx = 0) const
-	{
-		if (idx < d_cplength)
-		{
-			const utf32* pt = &ptr()[idx];
-
-			do
-			{
-				if (npos != str.find(*pt++))
-					return idx;
-
-			} while (++idx != d_cplength);
-
-		}
-
-		return npos;
-	}
-
-	/*!
-	\brief
-		Find the first code point that is not one of a set of code points.
-
-	\param str
-		String object describing the set of code points.
-
-	\param idx
-		Index of the start point for the search
-
-	\return
-		- Index of the first code point that does not match any one of the code points in \a str starting from from \a idx.
-		- npos if all code points matched one of the code points in \a str.
-	*/
-	size_type	find_first_not_of(const String& str, size_type idx = 0) const
-	{
-		if (idx < d_cplength)
-		{
-			const utf32* pt = &ptr()[idx];
-
-			do
-			{
-				if (npos == str.find(*pt++))
-					return idx;
-
-			} while (++idx != d_cplength);
-
-		}
-
-		return npos;
-	}
-
-
-	/*!
-	\brief
-		Find the first occurrence of one of a set of code points.
-
-	\param std_str
-		std::string object describing the set of code points.
-
-	\note
-		The characters of \a std_str are taken to be unencoded data which represent Unicode code points 0x00..0xFF.  No translation of
-		the provided data will occur.
-
-	\param idx
-		Index of the start point for the search
-
-	\return
-		- Index of the first occurrence of any one of the code points in \a std_str starting from from \a idx.
-		- npos if none of the code points in \a std_str were found.
-	*/
-	size_type	find_first_of(const std::string& std_str, size_type idx = 0) const
-	{
-		if (idx < d_cplength)
-		{
-			const utf32* pt = &ptr()[idx];
-
-			do
-			{
-				if (npos != find_codepoint(std_str, *pt++))
-					return idx;
-
-			} while (++idx != d_cplength);
-
-		}
-
-		return npos;
-	}
-
-	/*!
-	\brief
-		Find the first code point that is not one of a set of code points.
-
-	\param std_str
-		std::string object describing the set of code points.
-
-	\note
-		The characters of \a std_str are taken to be unencoded data which represent Unicode code points 0x00..0xFF.  No translation of
-		the provided data will occur.
-
-	\param idx
-		Index of the start point for the search
-
-	\return
-		- Index of the first code point that does not match any one of the code points in \a std_str starting from from \a idx.
-		- npos if all code points matched one of the code points in \a std_str.
-	*/
-	size_type	find_first_not_of(const std::string& std_str, size_type idx = 0) const
-	{
-		if (idx < d_cplength)
-		{
-			const utf32* pt = &ptr()[idx];
-
-			do
-			{
-				if (npos == find_codepoint(std_str, *pt++))
-					return idx;
-
-			} while (++idx != d_cplength);
-
-		}
-
-		return npos;
-	}
-
-
-	/*!
-	\brief
-		Find the first occurrence of one of a set of code points.
-
-	\param utf8_str
-		Buffer containing null-terminated utf8 encoded data describing the set of code points.
-
-	\note
-		A basic string literal (cast to utf8*) can be passed to this function, provided that the string is
-		comprised only of code points 0x00..0x7f.  The use of extended ASCII characters (with values >0x7f)
-		would result in incorrect behaviour as the String will attempt to 'decode' the data, with unpredictable
-		results.
-
-	\param idx
-		Index of the start point for the search
-
-	\return
-		- Index of the first occurrence of any one of the code points in \a utf8_str starting from from \a idx.
-		- npos if none of the code points in \a utf8_str were found.
-
-	\exception std::out_of_range	Thrown if \a idx is invalid for this String.
-	*/
-	size_type	find_first_of(const utf8* utf8_str, size_type idx = 0) const
-	{
-		return find_first_of(utf8_str, idx, utf_length(utf8_str));
-	}
-
-	/*!
-	\brief
-		Find the first code point that is not one of a set of code points.
-
-	\param utf8_str
-		Buffer containing null-terminated utf8 encoded data describing the set of code points.
-
-	\note
-		A basic string literal (cast to utf8*) can be passed to this function, provided that the string is
-		comprised only of code points 0x00..0x7f.  The use of extended ASCII characters (with values >0x7f)
-		would result in incorrect behaviour as the String will attempt to 'decode' the data, with unpredictable
-		results.
-
-	\param idx
-		Index of the start point for the search
-
-	\return
-		- Index of the first code point that does not match any one of the code points in \a utf8_str starting from from \a idx.
-		- npos if all code points matched one of the code points in \a utf8_str.
-
-	\exception std::out_of_range	Thrown if \a idx is invalid for this String.
-	*/
-	size_type	find_first_not_of(const utf8* utf8_str, size_type idx = 0) const
-	{
-		return find_first_not_of(utf8_str, idx, utf_length(utf8_str));
-	}
-
-	/*!
-	\brief
-		Find the first occurrence of one of a set of code points.
-
-	\param utf8_str
-		Buffer containing utf8 encoded data describing the set of code points.
-
-	\note
-		A basic string literal (cast to utf8*) can be passed to this function, provided that the string is
-		comprised only of code points 0x00..0x7f.  The use of extended ASCII characters (with values >0x7f)
-		would result in incorrect behaviour as the String will attempt to 'decode' the data, with unpredictable
-		results.
-
-	\param idx
-		Index of the start point for the search
-
-	\param str_len
-		Length of the utf8 encoded data in utf8 code units (not code points).
-
-	\return
-		- Index of the first occurrence of any one of the code points in \a utf8_str starting from from \a idx.
-		- npos if none of the code points in \a utf8_str were found.
-
-	\exception std::length_error	Thrown if \a str_len was 'npos'.
-	*/
-	size_type	find_first_of(const utf8* utf8_str, size_type idx, size_type str_len) const
-	{
-		if (str_len == npos)
-			throw std::length_error("Length for utf8 encoded string can not be 'npos'");
-
-		if (idx < d_cplength)
-		{
-			size_type encsze = encoded_size(utf8_str, str_len);
-
-			const utf32* pt = &ptr()[idx];
-
-			do
-			{
-				if (npos != find_codepoint(utf8_str, encsze, *pt++))
-					return idx;
-
-			} while (++idx != d_cplength);
-
-		}
-
-		return npos;
-	}
-
-	/*!
-	\brief
-		Find the first code point that is not one of a set of code points.
-
-	\param utf8_str
-		Buffer containing utf8 encoded data describing the set of code points.
-
-	\note
-		A basic string literal (cast to utf8*) can be passed to this function, provided that the string is
-		comprised only of code points 0x00..0x7f.  The use of extended ASCII characters (with values >0x7f)
-		would result in incorrect behaviour as the String will attempt to 'decode' the data, with unpredictable
-		results.
-
-	\param idx
-		Index of the start point for the search
-
-	\param str_len
-		Length of the utf8 encoded data in utf8 code units (not code points).
-
-	\return
-		- Index of the first code point that does not match any one of the code points in \a utf8_str starting from from \a idx.
-		- npos if all code points matched one of the code points in \a utf8_str.
-
-	\exception std::length_error	Thrown if \a str_len was 'npos'.
-	*/
-	size_type	find_first_not_of(const utf8* utf8_str, size_type idx, size_type str_len) const
-	{
-		if (str_len == npos)
-			throw std::length_error("Length for utf8 encoded string can not be 'npos'");
-
-		if (idx < d_cplength)
-		{
-			size_type encsze = encoded_size(utf8_str, str_len);
-
-			const utf32* pt = &ptr()[idx];
-
-			do
-			{
-				if (npos == find_codepoint(utf8_str, encsze, *pt++))
-					return idx;
-
-			} while (++idx != d_cplength);
-
-		}
-
-		return npos;
-	}
-
-
-	/*!
-	\brief
-		Search forwards for a given code point
-
-	\param code_point
-		The utf32 code point to search for
-
-	\param idx
-		Index of the code point where the search is to start.
-
-	\return
-		- Index of the first occurrence of \a code_point starting from from \a idx.
-		- npos if the code point could not be found
-	*/
-	size_type	find_first_of(utf32 code_point, size_type idx = 0) const
-	{
-		return find(code_point, idx);
-	}
-
-	/*!
-	\brief
-		Search forwards for the first code point that does not match a given code point
-
-	\param code_point
-		The utf32 code point to search for
-
-	\param idx
-		Index of the code point where the search is to start.
-
-	\return
-		- Index of the first code point that does not match \a code_point starting from from \a idx.
-		- npos if all code points matched \a code_point
-
-	\exception std::out_of_range	Thrown if \a idx is invalid for this String.
-	*/
-	size_type	find_first_not_of(utf32 code_point, size_type idx = 0) const
-	{
-		if (idx < d_cplength)
-		{
-			do
-			{
-				if ((*this)[idx] != code_point)
-					return idx;
-
-			} while(idx++ < d_cplength);
-
-		}
-
-		return npos;
-	}
-
-
-	/*!
-	\brief
-		Find the first occurrence of one of a set of chars.
-
-	\param c_str
-		c-string describing the set of chars.
-
-	\param idx
-		Index of the start point for the search
-
-	\return
-		- Index of the first occurrence of any one of the chars in \a c_str starting from from \a idx.
-		- npos if none of the chars in \a c_str were found.
-
-	\exception std::out_of_range	Thrown if \a idx is invalid for this String.
-	*/
-	size_type	find_first_of(const char* cstr, size_type idx = 0) const
-	{
-		return find_first_of(cstr, idx, strlen(cstr));
-	}
-
-
-	/*!
-	\brief
-		Find the first code point that is not one of a set of chars.
-
-	\param c_str
-		c-string describing the set of chars.
-
-	\param idx
-		Index of the start point for the search
-
-	\return
-		- Index of the first code point that does not match any one of the chars in \a c_str starting from from \a idx.
-		- npos if all code points matched any of the chars in \a c_str.
-
-	\exception std::out_of_range	Thrown if \a idx is invalid for this String.
-	*/
-	size_type	find_first_not_of(const char* cstr, size_type idx = 0) const
-	{
-		return find_first_not_of(cstr, idx, strlen(cstr));
-	}
-
-
-	/*!
-	\brief
-		Find the first occurrence of one of a set of chars.
-
-	\param chars
-		char array containing the set of chars.
-
-	\param idx
-		Index of the start point for the search
-
-	\param chars_len
-		Number of chars in the char array.
-
-	\return
-		- Index of the first occurrence of any one of the chars in \a chars starting from from \a idx.
-		- npos if none of the chars in \a chars were found.
-
-	\exception std::length_error	Thrown if \a chars_len was 'npos'.
-	*/
-	size_type	find_first_of(const char* chars, size_type idx, size_type chars_len) const
-	{
-		if (chars_len == npos)
-			throw std::length_error("Length for char array can not be 'npos'");
-
-		if (idx < d_cplength)
-		{
-			const utf32* pt = &ptr()[idx];
-
-			do
-			{
-				if (npos != find_codepoint(chars, chars_len, *pt++))
-					return idx;
-
-			} while (++idx != d_cplength);
-
-		}
-
-		return npos;
-	}
-
-
-	/*!
-	\brief
-		Find the first code point that is not one of a set of chars.
-
-	\param chars
-		char array containing the set of chars.
-
-	\param idx
-		Index of the start point for the search
-
-	\param chars_len
-		Number of chars in the car array.
-
-	\return
-		- Index of the first code point that does not match any one of the chars in \a chars starting from from \a idx.
-		- npos if all code points matched any of the chars in \a chars.
-
-	\exception std::length_error	Thrown if \a chars_len was 'npos'.
-	*/
-	size_type	find_first_not_of(const char* chars, size_type idx, size_type chars_len) const
-	{
-		if (chars_len == npos)
-			throw std::length_error("Length for char array can not be 'npos'");
-
-		if (idx < d_cplength)
-		{
-			const utf32* pt = &ptr()[idx];
-
-			do
-			{
-				if (npos == find_codepoint(chars, chars_len, *pt++))
-					return idx;
-
-			} while (++idx != d_cplength);
-
-		}
-
-		return npos;
-	}
-
-
-	//////////////////////////////////////////////////////////////////////////
-	// Find last of different code-points
-	//////////////////////////////////////////////////////////////////////////
-	/*!
-	\brief
-		Find the last occurrence of one of a set of code points.
-
-	\param str
-		String object describing the set of code points.
-
-	\param idx
-		Index of the start point for the search
-
-	\return
-		- Index of the last occurrence of any one of the code points in \a str starting from \a idx.
-		- npos if none of the code points in \a str were found.
-	*/
-	size_type	find_last_of(const String& str, size_type idx = npos) const
-	{
-		if (d_cplength > 0)
-		{
-			if (idx >= d_cplength)
-				idx = d_cplength - 1;
-
-			const utf32* pt = &ptr()[idx];
-
-			do
-			{
-				if (npos != str.find(*pt--))
-					return idx;
-
-			} while (idx-- != 0);
-
-		}
-
-		return npos;
-	}
-
-	/*!
-	\brief
-		Find the last code point that is not one of a set of code points.
-
-	\param str
-		String object describing the set of code points.
-
-	\param idx
-		Index of the start point for the search
-
-	\return
-		- Index of the last code point that does not match any one of the code points in \a str starting from \a idx.
-		- npos if all code points matched one of the code points in \a str.
-	*/
-	size_type	find_last_not_of(const String& str, size_type idx = npos) const
-	{
-		if (d_cplength > 0)
-		{
-			if (idx >= d_cplength)
-				idx = d_cplength - 1;
-
-			const utf32* pt = &ptr()[idx];
-
-			do
-			{
-				if (npos == str.find(*pt--))
-					return idx;
-
-			} while (idx-- != 0);
-
-		}
-
-		return npos;
-	}
-
-
-	/*!
-	\brief
-		Find the last occurrence of one of a set of code points.
-
-	\param std_str
-		std::string object describing the set of code points.
-
-	\note
-		The characters of \a std_str are taken to be unencoded data which represent Unicode code points 0x00..0xFF.  No translation of
-		the provided data will occur.
-
-	\param idx
-		Index of the start point for the search
-
-	\return
-		- Index of the last occurrence of any one of the code points in \a std_str starting from \a idx.
-		- npos if none of the code points in \a std_str were found.
-	*/
-	size_type	find_last_of(const std::string& std_str, size_type idx = npos) const
-	{
-		if (d_cplength > 0)
-		{
-			if (idx >= d_cplength)
-				idx = d_cplength - 1;
-
-			const utf32* pt = &ptr()[idx];
-
-			do
-			{
-				if (npos != find_codepoint(std_str, *pt--))
-					return idx;
-
-			} while (idx-- != 0);
-
-		}
-
-		return npos;
-	}
-
-	/*!
-	\brief
-		Find the last code point that is not one of a set of code points.
-
-	\param std_str
-		std::string object describing the set of code points.
-
-	\note
-		The characters of \a std_str are taken to be unencoded data which represent Unicode code points 0x00..0xFF.  No translation of
-		the provided data will occur.
-
-	\param idx
-		Index of the start point for the search
-
-	\return
-		- Index of the last code point that does not match any one of the code points in \a std_str starting from \a idx.
-		- npos if all code points matched one of the code points in \a std_str.
-	*/
-	size_type	find_last_not_of(const std::string& std_str, size_type idx = npos) const
-	{
-		if (d_cplength > 0)
-		{
-			if (idx >= d_cplength)
-				idx = d_cplength - 1;
-
-			const utf32* pt = &ptr()[idx];
-
-			do
-			{
-				if (npos == find_codepoint(std_str, *pt--))
-					return idx;
-
-			} while (idx-- != 0);
-
-		}
-
-		return npos;
-	}
-
-
-	/*!
-	\brief
-		Find the last occurrence of one of a set of code points.
-
-	\param utf8_str
-		Buffer containing null-terminated utf8 encoded data describing the set of code points.
-
-	\note
-		A basic string literal (cast to utf8*) can be passed to this function, provided that the string is
-		comprised only of code points 0x00..0x7f.  The use of extended ASCII characters (with values >0x7f)
-		would result in incorrect behaviour as the String will attempt to 'decode' the data, with unpredictable
-		results.
-
-	\param idx
-		Index of the start point for the search
-
-	\return
-		- Index of the last occurrence of any one of the code points in \a utf8_str starting from \a idx.
-		- npos if none of the code points in \a utf8_str were found.
-
-	\exception std::out_of_range	Thrown if \a idx is invalid for this String.
-	*/
-	size_type	find_last_of(const utf8* utf8_str, size_type idx = npos) const
-	{
-		return find_last_of(utf8_str, idx, utf_length(utf8_str));
-	}
-
-	/*!
-	\brief
-		Find the last code point that is not one of a set of code points.
-
-	\param utf8_str
-		Buffer containing null-terminated utf8 encoded data describing the set of code points.
-
-	\note
-		A basic string literal (cast to utf8*) can be passed to this function, provided that the string is
-		comprised only of code points 0x00..0x7f.  The use of extended ASCII characters (with values >0x7f)
-		would result in incorrect behaviour as the String will attempt to 'decode' the data, with unpredictable
-		results.
-
-	\param idx
-		Index of the start point for the search
-
-	\return
-		- Index of the last code point that does not match any one of the code points in \a utf8_str starting from \a idx.
-		- npos if all code points matched one of the code points in \a utf8_str.
-
-	\exception std::out_of_range	Thrown if \a idx is invalid for this String.
-	*/
-	size_type	find_last_not_of(const utf8* utf8_str, size_type idx = npos) const
-	{
-		return find_last_not_of(utf8_str, idx, utf_length(utf8_str));
-	}
-
-	/*!
-	\brief
-		Find the last occurrence of one of a set of code points.
-
-	\param utf8_str
-		Buffer containing utf8 encoded data describing the set of code points.
-
-	\note
-		A basic string literal (cast to utf8*) can be passed to this function, provided that the string is
-		comprised only of code points 0x00..0x7f.  The use of extended ASCII characters (with values >0x7f)
-		would result in incorrect behaviour as the String will attempt to 'decode' the data, with unpredictable
-		results.
-
-	\param idx
-		Index of the start point for the search
-
-	\param str_len
-		Length of the utf8 encoded data in utf8 code units (not code points).
-
-	\return
-		- Index of the last occurrence of any one of the code points in \a utf8_str starting from from \a idx.
-		- npos if none of the code points in \a utf8_str were found.
-
-	\exception std::length_error	Thrown if \a str_len was 'npos'.
-	*/
-	size_type	find_last_of(const utf8* utf8_str, size_type idx, size_type str_len) const
-	{
-		if (str_len == npos)
-			throw std::length_error("Length for utf8 encoded string can not be 'npos'");
-
-		if (d_cplength > 0)
-		{
-			if (idx >= d_cplength)
-				idx = d_cplength - 1;
-
-			size_type encsze = encoded_size(utf8_str, str_len);
-
-			const utf32* pt = &ptr()[idx];
-
-			do
-			{
-				if (npos != find_codepoint(utf8_str, encsze, *pt--))
-					return idx;
-
-			} while (idx-- != 0);
-
-		}
-
-		return npos;
-	}
-
-	/*!
-	\brief
-		Find the last code point that is not one of a set of code points.
-
-	\param utf8_str
-		Buffer containing utf8 encoded data describing the set of code points.
-
-	\note
-		A basic string literal (cast to utf8*) can be passed to this function, provided that the string is
-		comprised only of code points 0x00..0x7f.  The use of extended ASCII characters (with values >0x7f)
-		would result in incorrect behaviour as the String will attempt to 'decode' the data, with unpredictable
-		results.
-
-	\param idx
-		Index of the start point for the search
-
-	\param str_len
-		Length of the utf8 encoded data in utf8 code units (not code points).
-
-	\return
-		- Index of the last code point that does not match any one of the code points in \a utf8_str starting from from \a idx.
-		- npos if all code points matched one of the code points in \a utf8_str.
-
-	\exception std::length_error	Thrown if \a str_len was 'npos'.
-	*/
-	size_type	find_last_not_of(const utf8* utf8_str, size_type idx, size_type str_len) const
-	{
-		if (str_len == npos)
-			throw std::length_error("Length for utf8 encoded string can not be 'npos'");
-
-		if (d_cplength > 0)
-		{
-			if (idx >= d_cplength)
-				idx = d_cplength - 1;
-
-			size_type encsze = encoded_size(utf8_str, str_len);
-
-			const utf32* pt = &ptr()[idx];
-
-			do
-			{
-				if (npos == find_codepoint(utf8_str, encsze, *pt--))
-					return idx;
-
-			} while (idx-- != 0);
-
-		}
-
-		return npos;
-	}
-
-
-	/*!
-	\brief
-		Search for last occurrence of a given code point
-
-	\param code_point
-		The utf32 code point to search for
-
-	\param idx
-		Index of the code point where the search is to start.
-
-	\return
-		- Index of the last occurrence of \a code_point starting from \a idx.
-		- npos if the code point could not be found
-	*/
-	size_type	find_last_of(utf32 code_point, size_type idx = npos) const
-	{
-		return rfind(code_point, idx);
-	}
-
-	/*!
-	\brief
-		Search for the last code point that does not match a given code point
-
-	\param code_point
-		The utf32 code point to search for
-
-	\param idx
-		Index of the code point where the search is to start.
-
-	\return
-		- Index of the last code point that does not match \a code_point starting from from \a idx.
-		- npos if all code points matched \a code_point
-	*/
-	size_type	find_last_not_of(utf32 code_point, size_type idx = npos) const
-	{
-		if (d_cplength > 0)
-		{
-			if (idx >= d_cplength)
-				idx = d_cplength - 1;
-
-			do
-			{
-				if ((*this)[idx] != code_point)
-					return idx;
-
-			} while(idx-- != 0);
-
-		}
-
-		return npos;
-	}
-
-
-	/*!
-	\brief
-		Find the last occurrence of one of a set of chars.
-
-	\param c_str
-		c-string describing the set of chars.
-
-	\param idx
-		Index of the start point for the search
-
-	\return
-		- Index of the last occurrence of any one of the chars in \a c_str starting from \a idx.
-		- npos if none of the chars in \a c_str were found.
-
-	\exception std::out_of_range	Thrown if \a idx is invalid for this String.
-	*/
-	size_type	find_last_of(const char* cstr, size_type idx = npos) const
-	{
-		return find_last_of(cstr, idx, strlen(cstr));
-	}
-
-
-	/*!
-	\brief
-		Find the last code point that is not one of a set of chars.
-
-	\param c_str
-		c-string describing the set of chars.
-
-	\param idx
-		Index of the start point for the search
-
-	\return
-		- Index of the last code point that does not match any one of the chars in \a c_str starting from \a idx.
-		- npos if all code points matched any of the chars in \a c_str.
-
-	\exception std::out_of_range	Thrown if \a idx is invalid for this String.
-	*/
-	size_type	find_last_not_of(const char* cstr, size_type idx = npos) const
-	{
-		return find_last_not_of(cstr, idx, strlen(cstr));
-	}
-
-
-	/*!
-	\brief
-		Find the last occurrence of one of a set of chars.
-
-	\param chars
-		char array containing the set of chars.
-
-	\param idx
-		Index of the start point for the search
-
-	\param chars_len
-		Number of chars in the char array.
-
-	\return
-		- Index of the last occurrence of any one of the chars in \a chars, starting from from \a idx.
-		- npos if none of the chars in \a chars were found.
-
-	\exception std::length_error	Thrown if \a chars_len was 'npos'.
-	*/
-	size_type	find_last_of(const char* chars, size_type idx, size_type chars_len) const
-	{
-		if (chars_len == npos)
-			throw std::length_error("Length for char array can not be 'npos'");
-
-		if (d_cplength > 0)
-		{
-			if (idx >= d_cplength)
-				idx = d_cplength - 1;
-
-			const utf32* pt = &ptr()[idx];
-
-			do
-			{
-				if (npos != find_codepoint(chars, chars_len, *pt--))
-					return idx;
-
-			} while (idx-- != 0);
-
-		}
-
-		return npos;
-	}
-
-
-	/*!
-	\brief
-		Find the last code point that is not one of a set of chars.
-
-	\param chars
-		char array containing the set of chars.
-
-	\param idx
-		Index of the start point for the search
-
-	\param chars_len
-		Number of chars in the char array.
-
-	\return
-		- Index of the last code point that does not match any one of the chars in \a chars, starting from from \a idx.
-		- npos if all code points matched any of the chars in \a chars.
-
-	\exception std::length_error	Thrown if \a chars_len was 'npos'.
-	*/
-	size_type	find_last_not_of(const char* chars, size_type idx, size_type chars_len) const
-	{
-		if (chars_len == npos)
-			throw std::length_error("Length for char array can not be 'npos'");
-
-		if (d_cplength > 0)
-		{
-			if (idx >= d_cplength)
-				idx = d_cplength - 1;
-
-			const utf32* pt = &ptr()[idx];
-
-			do
-			{
-				if (npos == find_codepoint(chars, chars_len, *pt--))
-					return idx;
-
-			} while (idx-- != 0);
-
-		}
-
-		return npos;
-	}
-
-
-	//////////////////////////////////////////////////////////////////////////
-	// Substring
-	//////////////////////////////////////////////////////////////////////////
-	/*!
-	\brief
-		Returns a substring of this String.
-
-	\param idx
-		Index of the first code point to use for the sub-string.
-
-	\param len
-		Maximum number of code points to use for the sub-string
-
-	\return
-		A String object containing the specified sub-string.
-
-	\exception std::out_of_range	Thrown if \a idx is invalid for this String.
-	*/
-	String	substr(size_type idx = 0, size_type len = npos) const
-	{
-		if (d_cplength < idx)
-			throw std::out_of_range("Index is out of range for this CEGUI::String");
-
-		return String(*this, idx, len);
-	}
-
-	//////////////////////////////////////////////////////////////////////////
-	// Iterator creation
-	//////////////////////////////////////////////////////////////////////////
-	/*!
-	\brief
-		Return a forwards iterator that describes the beginning of the String
-
-	\return
-		iterator object that describes the beginning of the String.
-	*/
-	iterator		begin(void)
-	{
-		return iterator(ptr());
-	}
-
-	/*!
-	\brief
-		Return a constant forwards iterator that describes the beginning of the String
-
-	\return
-		const_iterator object that describes the beginning of the String.
-	*/
-	const_iterator	begin(void) const
-	{
-		return const_iterator(ptr());
-	}
-
-	/*!
-	\brief
-		Return a forwards iterator that describes the end of the String
-
-	\return
-		iterator object that describes the end of the String.
-	*/
-	iterator		end(void)
-	{
-		return iterator(&ptr()[d_cplength]);
-	}
-
-	/*!
-	\brief
-		Return a constant forwards iterator that describes the end of the String
-
-	\return
-		const_iterator object that describes the end of the String.
-	*/
-	const_iterator	end(void) const
-	{
-		return const_iterator(&ptr()[d_cplength]);
-	}
-
-	/*!
-	\brief
-		Return a reverse iterator that describes the beginning of the String
-
-	\return
-		reverse_iterator object that describes the beginning of the String (so is actually at the end)
-	*/
-	reverse_iterator		rbegin(void)
-	{
-		return reverse_iterator(end());
-	}
-
-	/*!
-	\brief
-		Return a constant reverse iterator that describes the beginning of the String
-
-	\return
-		const_reverse_iterator object that describes the beginning of the String (so is actually at the end)
-	*/
-	const_reverse_iterator	rbegin(void) const
-	{
-		return const_reverse_iterator(end());
-	}
-
-	/*!
-	\brief
-		Return a reverse iterator that describes the end of the String
-
-	\return
-		reverse_iterator object that describes the end of the String (so is actually at the beginning)
-	*/
-	reverse_iterator		rend(void)
-	{
-		return reverse_iterator(begin());
-	}
-
-	/*!
-	\brief
-		Return a constant reverse iterator that describes the end of the String
-
-	\return
-		const_reverse_iterator object that describes the end of the String (so is actually at the beginning)
-	*/
-	const_reverse_iterator	rend(void) const
-	{
-		return const_reverse_iterator(begin());
-	}
-
-private:
-	/*************************************************************************
-		Implementation Functions
-	*************************************************************************/
-	// string management
-
-	// change size of allocated buffer so it is at least 'new_size'.
-	// May or may not cause re-allocation and copy of buffer if size is larger
-	// will never re-allocate to make size smaller.  (see trim())
-    bool	grow(size_type new_size);
-
-	// perform re-allocation to remove wasted space.
-    void	trim(void);
-
-	// set the length of the string, and terminate it, according to the given value (will not re-allocate, use grow() first).
-	void	setlen(size_type len)
-	{
-		d_cplength = len;
-		ptr()[len] = (utf32)(0);
-	}
-
-	// initialise string object
-	void	init(void)
-	{
-		d_reserve			= STR_QUICKBUFF_SIZE;
-		d_encodedbuff		= 0;
-		d_encodedbufflen	= 0;
-		d_encodeddatlen		= 0;
-		setlen(0);
-	}
-
-	// return true if the given pointer is inside the string data
-	bool	inside(utf32* inptr)
-	{
-		if (inptr < ptr() || ptr() + d_cplength <= inptr)
-			return false;
-		else
-			return true;
-	}
-
-	// compute distance between two iterators, returning a 'safe' value
-	size_type safe_iter_dif(const const_iterator& iter1, const const_iterator& iter2) const
-	{
-		return (iter1.d_ptr == 0) ? 0 : (iter1 - iter2);
-	}
-	
-	// encoding functions
-	// for all:
-	//	src_len is in code units, or 0 for null terminated string.
-	//	dest_len is in code units.
-	//	returns number of code units put into dest buffer.
-	size_type encode(const utf32* src, utf8* dest, size_type dest_len, size_type src_len = 0) const
-	{
-		// count length for null terminated source...
-		if (src_len == 0)
-		{
-			src_len = utf_length(src);
-		}
-
-		size_type destCapacity = dest_len;
-
-		// while there is data in the source buffer,
-		for (uint idx = 0; idx < src_len; ++idx)
-		{
-			utf32	cp = src[idx];
-
-			// check there is enough destination buffer to receive this encoded unit (exit loop & return if not)
-			if (destCapacity < encoded_size(cp))
-			{
-				break;
-			}
-
-			if (cp < 0x80)
-			{
-				*dest++ = (utf8)cp;
-				--destCapacity;
-			}
-			else if (cp < 0x0800)
-			{
-				*dest++ = (utf8)((cp >> 6) | 0xC0);
-				*dest++ = (utf8)((cp & 0x3F) | 0x80);
-				destCapacity -= 2;
-			}
-			else if (cp < 0x10000)
-			{
-				*dest++ = (utf8)((cp >> 12) | 0xE0);
-				*dest++ = (utf8)(((cp >> 6) & 0x3F) | 0x80);
-				*dest++ = (utf8)((cp & 0x3F) | 0x80);
-				destCapacity -= 3;
-			}
-			else
-			{
-				*dest++ = (utf8)((cp >> 18) | 0xF0);
-				*dest++ = (utf8)(((cp >> 12) & 0x3F) | 0x80);
-				*dest++ = (utf8)(((cp >> 6) & 0x3F) | 0x80);
-				*dest++ = (utf8)((cp & 0x3F) | 0x80);
-				destCapacity -= 4;
-			}
-
-		}
-
-		return dest_len - destCapacity;
-	}
-
-	size_type encode(const utf8* src, utf32* dest, size_type dest_len, size_type src_len = 0) const
-	{
-		// count length for null terminated source...
-		if (src_len == 0)
-		{
-			src_len = utf_length(src);
-		}
-
-		size_type destCapacity = dest_len;
-
-		// while there is data in the source buffer, and space in the dest buffer
-		for (uint idx = 0; ((idx < src_len) && (destCapacity > 0));)
-		{
-			utf32	cp;
-			utf8	cu = src[idx++];
-
-			if (cu < 0x80)
-			{
-				cp = (utf32)(cu);
-			}
-			else if (cu < 0xE0)
-			{
-				cp = ((cu & 0x1F) << 6);
-				cp |= (src[idx++] & 0x3F);
-			}
-			else if (cu < 0xF0)
-			{
-				cp = ((cu & 0x0F) << 12);
-				cp |= ((src[idx++] & 0x3F) << 6);
-				cp |= (src[idx++] & 0x3F);
-			}
-			else
-			{
-				cp = ((cu & 0x07) << 18);
-				cp |= ((src[idx++] & 0x3F) << 12);
-				cp |= ((src[idx++] & 0x3F) << 6);
-				cp |= (src[idx++] & 0x3F);
-			}
-
-			*dest++ = cp;
-			--destCapacity;
-		}
-
-		return dest_len - destCapacity;
-	}
-
-	// return the number of utf8 code units required to encode the given utf32 code point
-	size_type encoded_size(utf32 code_point) const
-	{
-		if (code_point < 0x80)
-			return 1;
-		else if (code_point < 0x0800)
-			return 2;
-		else if (code_point < 0x10000)
-			return 3;
-		else
-			return 4;
-	}
-
-	// return number of code units required to re-encode given null-terminated utf32 data as utf8.  return does not include terminating null.
-	size_type encoded_size(const utf32* buf) const
-	{
-		return encoded_size(buf, utf_length(buf));
-	}
-
-	// return number of code units required to re-encode given utf32 data as utf8.   len is number of code units in 'buf'.
-	size_type encoded_size(const utf32* buf, size_type len) const
-	{
-		size_type count = 0;
-
-		while (len--)
-		{
-			count += encoded_size(*buf++);
-		}
-
-		return count;
-	}
-
-	// return number of utf32 code units required to re-encode given utf8 data as utf32.  return does not include terminating null.
-	size_type encoded_size(const utf8* buf) const
-	{
-		return encoded_size(buf, utf_length(buf));
-	}
-
-	// return number of utf32 code units required to re-encode given utf8 data as utf32.  len is number of code units in 'buf'.
-	size_type encoded_size(const utf8* buf, size_type len) const
-	{
-		utf8 tcp;
-		size_type count = 0;
-
-		while (len--)
-		{
-			tcp = *buf++;
-			++count;
-
-			if (tcp < 0x80)
-			{
-			}
-			else if (tcp < 0xE0)
-			{
-				--len;
-				++buf;
-			}
-			else if (tcp < 0xF0)
-			{
-				len -= 2;
-				buf += 2;
-			}
-			else
-			{
-				len -= 2;
-				buf += 3;
-			}
-
-		}
-
-		return count;
-	}
-
-	// return number of code units in a null terminated string
-	size_type utf_length(const utf8* utf8_str) const
-	{
-		size_type cnt = 0;
-		while (*utf8_str++)
-			cnt++;
-
-		return cnt;
-	}
-
-	// return number of code units in a null terminated string
-	size_type utf_length(const utf32* utf32_str) const
-	{
-		size_type cnt = 0;
-		while (*utf32_str++)
-			cnt++;
-
-		return cnt;
-	}
-
-	// build an internal buffer with the string encoded as utf8 (remains valid until string is modified).
-    utf8* build_utf8_buff(void) const;
-
-	// compare two utf32 buffers
-	int	utf32_comp_utf32(const utf32* buf1, const utf32* buf2, size_type cp_count) const
-	{
-		if (!cp_count)
-			return 0;
-
-		while ((--cp_count) && (*buf1 == *buf2))
-			buf1++, buf2++;
-		
-		return *buf1 - *buf2;
-	}
-
-	// compare utf32 buffer with char buffer (chars are taken to be code-points in the range 0x00-0xFF)
-	int utf32_comp_char(const utf32* buf1, const char* buf2, size_type cp_count) const
-	{
-		if (!cp_count)
-			return 0;
-
-		while ((--cp_count) && (*buf1 == static_cast<utf32>(static_cast<unsigned char>(*buf2))))
-			buf1++, buf2++;
-
-		return *buf1 - static_cast<utf32>(static_cast<unsigned char>(*buf2));
-	}
-
-	// compare utf32 buffer with encoded utf8 data
-	int utf32_comp_utf8(const utf32* buf1, const utf8* buf2, size_type cp_count) const
-	{
-		if (!cp_count)
-			return 0;
-
-		utf32	cp;
-		utf8	cu;
-
-		do
-		{
-			cu = *buf2++;
-
-			if (cu < 0x80)
-			{
-				cp = (utf32)(cu);
-			}
-			else if (cu < 0xE0)
-			{
-				cp = ((cu & 0x1F) << 6);
-				cp |= (*buf2++ & 0x3F);
-			}
-			else if (cu < 0xF0)
-			{
-				cp = ((cu & 0x0F) << 12);
-				cp |= ((*buf2++ & 0x3F) << 6);
-				cp |= (*buf2++ & 0x3F);
-			}
-			else
-			{
-				cp = ((cu & 0x07) << 18);
-				cp |= ((*buf2++ & 0x3F) << 12);
-				cp |= ((*buf2++ & 0x3F) << 6);
-				cp |= (*buf2++ & 0x3F);
-			}
-
-		} while ((*buf1++ == cp) && (--cp_count));
-
-		return (*--buf1) - cp;
-	}
-
-	// return index of first occurrence of 'code_point' in std::string 'str', or npos if none
-	size_type find_codepoint(const std::string& str, utf32 code_point) const
-	{
-		size_type idx = 0, sze = (size_type)str.size();
-
-		while (idx != sze)
-		{
-			if (code_point == static_cast<utf32>(static_cast<unsigned char>(str[idx])))
-				return idx;
-
-			++idx;
-		}
-
-		return npos;
-	}
-
-	// return index of first occurrence of 'code_point' in utf8 encoded string 'str', or npos if none.  len is in code points.
-	size_type find_codepoint(const utf8* str, size_type len, utf32 code_point) const 
-	{
-		size_type idx = 0;
-
-		utf32	cp;
-		utf8	cu;
-
-		while (idx != len) {
-			cu = *str++;
-
-			if (cu < 0x80)
-			{
-				cp = (utf32)(cu);
-			}
-			else if (cu < 0xE0)
-			{
-				cp = ((cu & 0x1F) << 6);
-				cp |= (*str++ & 0x3F);
-			}
-			else if (cu < 0xF0)
-			{
-				cp = ((cu & 0x0F) << 12);
-				cp |= ((*str++ & 0x3F) << 6);
-				cp |= (*str++ & 0x3F);
-			}
-			else
-			{
-				cp = ((cu & 0x07) << 18);
-				cp |= ((*str++ & 0x3F) << 12);
-				cp |= ((*str++ & 0x3F) << 6);
-				cp |= (*str++ & 0x3F);
-			}
-
-			if (code_point == cp)
-				return idx;
-
-			++idx;
-		}
-
-		return npos;
-	}
-
-
-	// return index of first occurrence of 'code_point' in char array 'chars', or npos if none
-	size_type find_codepoint(const char* chars, size_type chars_len, utf32 code_point) const
-	{
-		for (size_type idx = 0; idx != chars_len; ++idx)
-		{
-			if (code_point == static_cast<utf32>(static_cast<unsigned char>(chars[idx])))
-				return idx;
-		}
-
-		return npos;
-	}
-
-};
-
-
-//////////////////////////////////////////////////////////////////////////
-// Comparison operators
-//////////////////////////////////////////////////////////////////////////
-/*!
-\brief
-	Return true if String \a str1 is equal to String \a str2
-*/
-bool CEGUIEXPORT	operator==(const String& str1, const String& str2);
-
-/*!
-\brief
-	Return true if String \a str is equal to std::string \a std_str
-*/
-bool CEGUIEXPORT	operator==(const String& str, const std::string& std_str);
-
-/*!
-\brief
-	Return true if String \a str is equal to std::string \a std_str
-*/
-bool CEGUIEXPORT	operator==(const std::string& std_str, const String& str);
-
-/*!
-\brief
-	Return true if String \a str is equal to null-terminated utf8 data \a utf8_str
-*/
-bool CEGUIEXPORT	operator==(const String& str, const utf8* utf8_str);
-
-/*!
-\brief
-	Return true if String \a str is equal to null-terminated utf8 data \a utf8_str
-*/
-bool CEGUIEXPORT	operator==(const utf8* utf8_str, const String& str);
-
-/*!
-\brief
-	Return true if String \a str1 is not equal to String \a str2
-*/
-bool CEGUIEXPORT	operator!=(const String& str1, const String& str2);
-
-/*!
-\brief
-	Return true if String \a str is not equal to std::string \a std_str
-*/
-bool CEGUIEXPORT	operator!=(const String& str, const std::string& std_str);
-
-/*!
-\brief
-	Return true if String \a str is not equal to std::string \a std_str
-*/
-bool CEGUIEXPORT	operator!=(const std::string& std_str, const String& str);
-
-/*!
-\brief
-	Return true if String \a str is not equal to null-terminated utf8 data \a utf8_str
-*/
-bool CEGUIEXPORT	operator!=(const String& str, const utf8* utf8_str);
-
-/*!
-\brief
-	Return true if String \a str is not equal to null-terminated utf8 data \a utf8_str
-*/
-bool CEGUIEXPORT	operator!=(const utf8* utf8_str, const String& str);
-
-/*!
-\brief
-	Return true if String \a str1 is lexicographically less than String \a str2
-*/
-bool CEGUIEXPORT	operator<(const String& str1, const String& str2);
-
-/*!
-\brief
-	Return true if String \a str is lexicographically less than std::string \a std_str
-*/
-bool CEGUIEXPORT	operator<(const String& str, const std::string& std_str);
-
-/*!
-\brief
-	Return true if String \a str is lexicographically less than std::string \a std_str
-*/
-bool CEGUIEXPORT	operator<(const std::string& std_str, const String& str);
-
-/*!
-\brief
-	Return true if String \a str is lexicographically less than null-terminated utf8 data \a utf8_str
-*/
-bool CEGUIEXPORT	operator<(const String& str, const utf8* utf8_str);
-
-/*!
-\brief
-	Return true if String \a str is lexicographically less than null-terminated utf8 data \a utf8_str
-*/
-bool CEGUIEXPORT	operator<(const utf8* utf8_str, const String& str);
-
-/*!
-\brief
-	Return true if String \a str1 is lexicographically greater than String \a str2
-*/
-bool CEGUIEXPORT	operator>(const String& str1, const String& str2);
-
-/*!
-\brief
-	Return true if String \a str is lexicographically greater than std::string \a std_str
-*/
-bool CEGUIEXPORT	operator>(const String& str, const std::string& std_str);
-
-/*!
-\brief
-	Return true if String \a str is lexicographically greater than std::string \a std_str
-*/
-bool CEGUIEXPORT	operator>(const std::string& std_str, const String& str);
-
-/*!
-\brief
-	Return true if String \a str is lexicographically greater than null-terminated utf8 data \a utf8_str
-*/
-bool CEGUIEXPORT	operator>(const String& str, const utf8* utf8_str);
-
-/*!
-\brief
-	Return true if String \a str is lexicographically greater than null-terminated utf8 data \a utf8_str
-*/
-bool CEGUIEXPORT	operator>(const utf8* utf8_str, const String& str);
-
-/*!
-\brief
-	Return true if String \a str1 is lexicographically less than or equal to String \a str2
-*/
-bool CEGUIEXPORT	operator<=(const String& str1, const String& str2);
-
-/*!
-\brief
-	Return true if String \a str is lexicographically less than or equal to std::string \a std_str
-*/
-bool CEGUIEXPORT	operator<=(const String& str, const std::string& std_str);
-
-/*!
-\brief
-	Return true if String \a str is lexicographically less than or equal to std::string \a std_str
-*/
-bool CEGUIEXPORT	operator<=(const std::string& std_str, const String& str);
-
-/*!
-\brief
-	Return true if String \a str is lexicographically less than or equal to null-terminated utf8 data \a utf8_str
-*/
-bool CEGUIEXPORT	operator<=(const String& str, const utf8* utf8_str);
-
-/*!
-\brief
-	Return true if String \a str is lexicographically less than or equal to null-terminated utf8 data \a utf8_str
-*/
-bool CEGUIEXPORT	operator<=(const utf8* utf8_str, const String& str);
-
-/*!
-\brief
-	Return true if String \a str1 is lexicographically greater than or equal to String \a str2
-*/
-bool CEGUIEXPORT	operator>=(const String& str1, const String& str2);
-
-/*!
-\brief
-	Return true if String \a str is lexicographically greater than or equal to std::string \a std_str
-*/
-bool CEGUIEXPORT	operator>=(const String& str, const std::string& std_str);
-
-/*!
-\brief
-	Return true if String \a str is lexicographically greater than or equal to std::string \a std_str
-*/
-bool CEGUIEXPORT	operator>=(const std::string& std_str, const String& str);
-
-/*!
-\brief
-	Return true if String \a str is lexicographically greater than or equal to null-terminated utf8 data \a utf8_str
-*/
-bool CEGUIEXPORT	operator>=(const String& str, const utf8* utf8_str);
-
-/*!
-\brief
-	Return true if String \a str is lexicographically greater than or equal to null-terminated utf8 data \a utf8_str
-*/
-bool CEGUIEXPORT	operator>=(const utf8* utf8_str, const String& str);
-
-/*!
-\brief
-	Return true if String \a str is equal to c-string \a c_str
-*/
-bool CEGUIEXPORT	operator==(const String& str, const char* c_str);
-
-/*!
-\brief
-	Return true if c-string \a c_str is equal to String \a str
-*/
-bool CEGUIEXPORT	operator==(const char* c_str, const String& str);
-
-/*!
-\brief
-	Return true if String \a str is not equal to c-string \a c_str
-*/
-bool CEGUIEXPORT	operator!=(const String& str, const char* c_str);
-
-/*!
-\brief
-	Return true if c-string \a c_str is not equal to String \a str
-*/
-bool CEGUIEXPORT	operator!=(const char* c_str, const String& str);
-
-/*!
-\brief
-	Return true if String \a str is lexicographically less than c-string \a c_str
-*/
-bool CEGUIEXPORT	operator<(const String& str, const char* c_str);
-
-/*!
-\brief
-	Return true if c-string \a c_str is lexicographically less than String \a str
-*/
-bool CEGUIEXPORT	operator<(const char* c_str, const String& str);
-
-/*!
-\brief
-Return true if String \a str is lexicographically greater than c-string \a c_str
-*/
-bool CEGUIEXPORT	operator>(const String& str, const char* c_str);
-
-/*!
-\brief
-Return true if c-string \a c_str is lexicographically greater than String \a str
-*/
-bool CEGUIEXPORT	operator>(const char* c_str, const String& str);
-
-/*!
-\brief
-	Return true if String \a str is lexicographically less than or equal to c-string \a c_str
-*/
-bool CEGUIEXPORT	operator<=(const String& str, const char* c_str);
-
-/*!
-\brief
-	Return true if c-string \a c_str is lexicographically less than or equal to String \a str
-*/
-bool CEGUIEXPORT	operator<=(const char* c_str, const String& str);
-
-/*!
-\brief
-	Return true if String \a str is lexicographically greater than or equal to c-string \a c_str
-*/
-bool CEGUIEXPORT	operator>=(const String& str, const char* c_str);
-
-/*!
-\brief
-	Return true if c-string \a c_str is lexicographically greater than or equal to String \a str
-*/
-bool CEGUIEXPORT	operator>=(const char* c_str, const String& str);
-
-//////////////////////////////////////////////////////////////////////////
-// Concatenation operator functions
-//////////////////////////////////////////////////////////////////////////
-/*!
-\brief
-	Return String object that is the concatenation of the given inputs
-
-\param str1
-	String object describing first part of the new string
-
-\param str2
-	String object describing the second part of the new string
-
-\return
-	A String object that is the concatenation of \a str1 and \a str2
-
-\exception std::length_error	Thrown if the resulting String would be too large.
-*/
-String CEGUIEXPORT	operator+(const String& str1, const String& str2);
-
-/*!
-\brief
-	Return String object that is the concatenation of the given inputs
-
-\param str
-	String object describing first part of the new string
-
-\param std_str
-	std::string object describing the second part of the new string
-
-\return
-	A String object that is the concatenation of \a str and \a std_str
-
-\exception std::length_error	Thrown if the resulting String would be too large.
-*/
-String CEGUIEXPORT	operator+(const String& str, const std::string& std_str);
-
-/*!
-\brief
-	Return String object that is the concatenation of the given inputs
-
-\param std_str
-	std::string object describing the first part of the new string
-
-\param str
-	String object describing the second part of the new string
-
-\return
-	A String object that is the concatenation of \a std_str and \a str
-
-\exception std::length_error	Thrown if the resulting String would be too large.
-*/
-String CEGUIEXPORT	operator+(const std::string& std_str, const String& str);
-
-/*!
-\brief
-	Return String object that is the concatenation of the given inputs
-
-\param str
-	String object describing first part of the new string
-
-\param utf8_str
-	Buffer containing null-terminated utf8 encoded data describing the second part of the new string
-
-\return
-	A String object that is the concatenation of \a str and \a utf8_str
-
-\exception std::length_error	Thrown if the resulting String would be too large.
-*/
-String CEGUIEXPORT	operator+(const String& str, const utf8* utf8_str);
-
-/*!
-\brief
-	Return String object that is the concatenation of the given inputs
-
-\param utf8_str
-	Buffer containing null-terminated utf8 encoded data describing the first part of the new string
-
-\param str
-	String object describing the second part of the new string
-
-\return
-	A String object that is the concatenation of \a str and \a utf8_str
-
-\exception std::length_error	Thrown if the resulting String would be too large.
-*/
-String CEGUIEXPORT	operator+(const utf8* utf8_str, const String& str);
-
-/*!
-\brief
-	Return String object that is the concatenation of the given inputs
-
-\param str
-	String object describing the first part of the new string
-
-\param code_point
-	utf32 code point describing the second part of the new string
-
-\return
-	A String object that is the concatenation of \a str and \a code_point
-
-\exception std::length_error	Thrown if the resulting String would be too large.
-*/
-String CEGUIEXPORT	operator+(const String& str, utf32 code_point);
-
-/*!
-\brief
-	Return String object that is the concatenation of the given inputs
-
-\param code_point
-	utf32 code point describing the first part of the new string
-
-\param str
-	String object describing the second part of the new string
-
-\return
-	A String object that is the concatenation of \a code_point and \a str
-
-\exception std::length_error	Thrown if the resulting String would be too large.
-*/
-String CEGUIEXPORT	operator+(utf32 code_point, const String& str);
-
-/*!
-\brief
-	Return String object that is the concatenation of the given inputs
-
-\param str
-	String object describing first part of the new string
-
-\param c_str
-	c-string describing the second part of the new string
-
-\return
-	A String object that is the concatenation of \a str and \a c_str
-
-\exception std::length_error	Thrown if the resulting String would be too large.
-*/
-String CEGUIEXPORT	operator+(const String& str, const char* c_str);
-
-/*!
-\brief
-	Return String object that is the concatenation of the given inputs
-
-\param c_str
-	c-string describing the first part of the new string
-
-\param str
-	String object describing the second part of the new string
-
-\return
-	A String object that is the concatenation of \a c_str and \a str
-
-\exception std::length_error	Thrown if the resulting String would be too large.
-*/
-String CEGUIEXPORT	operator+(const char* c_str, const String& str);
-
-
-//////////////////////////////////////////////////////////////////////////
-// Output (stream) functions
-//////////////////////////////////////////////////////////////////////////
-CEGUIEXPORT std::ostream& operator<<(std::ostream& s, const String& str);
-
-
-//////////////////////////////////////////////////////////////////////////
-// Modifying operations
-//////////////////////////////////////////////////////////////////////////
-/*!
-\brief
-	Swap the contents for two String objects
-
-\param str1
-	String object who's contents are to be swapped with \a str2
-
-\param str2
-	String object who's contents are to be swapped with \a str1
-
-\return
-	Nothing
-*/
-void CEGUIEXPORT swap(String& str1, String& str2);
-
-
-} // End of  CEGUI namespace section
-
-
-#endif	// end of guard _CEGUIString_h_
diff --git a/pcr/cegui-0.5/PKGBUILD b/pcr/cegui-0.5/PKGBUILD
deleted file mode 100644
index 7dacec17e..000000000
--- a/pcr/cegui-0.5/PKGBUILD
+++ /dev/null
@@ -1,41 +0,0 @@
-# Contributor (Arch): Jakub Luzny <limoto94@gmail.com>
-# Maintainer : Parabola GNU / Linux-libre Aurelien Desbrieres <aurelien@cwb.io>
-
-pkgname=cegui-0.5
-pkgver=0.5.0b
-pkgrel=1
-pkgdesc="A free library providing windowing and widgets for graphics APIs/engines"
-arch=('i686' 'x86_64' 'mips64el')
-url="http://crayzedsgui.sourceforge.net"
-#options=('!libtool')
-license=("MIT")
-depends=('pcre' 'glew' 'freetype2' 'libxml2' 'devil' 'freeglut' 'silly')
-conflicts=('cegui')
-source=(http://downloads.sourceforge.net/crayzedsgui/CEGUI-$pkgver.tar.gz
-        CEGUIString.h)
-md5sums=('b42322a33c6a06eede76b15f75694a17'
-         'b0859a1316bb25ca4860a5d0052e9a04')
-
-
-build() {
-  cd $srcdir/CEGUI-0.5.0
-
-  cp $srcdir/CEGUIString.h include/
-  sed -i 's/ILvoid/void/' ImageCodecModules/DevILImageCodec/CEGUIDevILImageCodec.cpp
-
-  ./configure  --prefix=/usr --enable-release --enable-shared --disable-expat --disable-tga --disable-samples --disable-xerces-c
-
-  make
-}
-
-package() {
-  cd $srcdir/CEGUI-0.5.0
- 
-  make DESTDIR=${pkgdir} install
-
-  install -Dm644 COPYING ${pkgdir}/usr/share/licenses/$pkgname/LICENSE
-}
-
-#category: lib
-md5sums=('b42322a33c6a06eede76b15f75694a17'
-         'b0859a1316bb25ca4860a5d0052e9a04')
diff --git a/pcr/cegui-0.6/PKGBUILD b/pcr/cegui-0.6/PKGBUILD
deleted file mode 100644
index cb3387e19..000000000
--- a/pcr/cegui-0.6/PKGBUILD
+++ /dev/null
@@ -1,55 +0,0 @@
-# Contributor (Arch): Lucio zara <pennega@gmail.com>
-# Maintainer : Parabola GNU / Linux-libre Aurelien Desbrieres <aurelien@cwb.io>
-
-pkgname=cegui-0.6
-pkgver=0.6.2
-_pkgver=0.6.2b
-pkgrel=13
-
-pkgdesc="A free library providing windowing and widgets for graphics APIs/engines."
-arch=('i686' 'x86_64' 'mips64el')
-url="http://www.cegui.org.uk/"
-license=('MIT')
-depends=('devil' 'freetype2' 'libxml2' 'lua' 'pcre'  'silly' 'glew' 'tinyxml' 'directfb' 'freeglut')
-makedepends=()
-options=('!libtool')
-conflicts=('cegui')
-source=("http://downloads.sourceforge.net/crayzedsgui/CEGUI-${_pkgver}.tar.gz")
-md5sums=('4fbd95e5a2ac1c7acf2a8f5df3ac6b93')
-	
-
-build() {
-  cd ${srcdir}/CEGUI-${pkgver}
-  #PATCH
-  #sed -i '1i#include <cstddef>' include/CEGUIString.h
-  sed -i '/#include <stdexcept>/a\#include <cstddef>' include/CEGUIString.h
-  sed -i '/#include "CEGUIDynamicModule.h"/a\#include <algorithm>' RendererModules/directfbRenderer/directfb-renderer.cpp
-  sed -i 's:TiXmlNode\:\::TiXmlNode\:\:TINYXML_:g' XMLParserModules/TinyXMLParser/CEGUITinyXMLParser.cpp
-  sed -i 's:ILvoid:void:g' ImageCodecModules/DevILImageCodec/CEGUIDevILImageCodec.cpp
-
-  PYTHON=python2 \
-  ./configure --prefix=/usr \
-	      --sysconfdir=/etc \
-	      --localstatedir=/var \
-	      --disable-static \
-	      --disable-xerces-c \
-	      --disable-samples \
-	      --enable-devil \
-	      --enable-silly \
-	      --enable-lua-module \
-	      --enable-python-module \
-	      --with-default-image-codec=SILLYImageCodec
-
-  make || return 1
-}
-
-package() {
-  cd ${srcdir}/CEGUI-${pkgver}
-  install -d ${pkgdir}/usr/share/licenses/${pkgname} || return 1
-
-  make DESTDIR=${pkgdir} install || return 1
-
-  install -m644 COPYING ${pkgdir}/usr/share/licenses/${pkgname}/ || return 1
-}
-md5sums=('4fbd95e5a2ac1c7acf2a8f5df3ac6b93')
-md5sums=('4fbd95e5a2ac1c7acf2a8f5df3ac6b93')
diff --git a/pcr/cegui-0.7/PKGBUILD b/pcr/cegui-0.7/PKGBUILD
deleted file mode 100644
index bbfdd5a7d..000000000
--- a/pcr/cegui-0.7/PKGBUILD
+++ /dev/null
@@ -1,48 +0,0 @@
-# Maintainer: aurelien desbrieres <aurelien@hackers.camp>
-# Contributor: carstene1ns <arch carsten-teibes de> - http://git.io/ctPKG
-# Contributor: josephgbr <rafael.f.f1@gmail.com>
-
-# based on cegui from Arch Linux repository, original credits go to:
-#   Maintainer: Sven-Hendrik Haase <sh@lutzhaase.com>
-#   Contributor: Juergen Hoetzel <juergen@archlinux.org>
-#   Contributor: William Rea <sillywilly@gmail.com>,
-#   Contributor: Bjorn Lindeijer <bjorn@lindeijer.nl>
-
-pkgname=cegui-0.7
-pkgver=0.7.9
-pkgrel=4
-pkgdesc="A free library providing windowing and widgets for graphics APIs/engines (legacy version)"
-arch=('i686' 'x86_64')
-url="http://crayzedsgui.sourceforge.net"
-license=("MIT")
-depends=('glew' 'freetype2' 'libxml2' 'devil' 'freeglut' 'lua51' 'silly' 'mesa' 'glm' 'glfw')
-makedepends=('python2' 'doxygen' 'gtk2' 'boost' 'graphviz') # 'ogre' 'irrlicht')
-optdepends=("python2: python bindings"
-            "boost-libs: null renderer with python2"
-            #"ogre: ogre module"
-            #"irrlicht: irrlicht module"
-            "gtk2: gtk2 module")
-provides=('cegui')
-conflicts=('cegui')
-options=('!libtool')
-source=("http://downloads.sourceforge.net/crayzedsgui/CEGUI-$pkgver.tar.gz")
-
-build() {
-  cd CEGUI-$pkgver
-
-  ./bootstrap
-  Lua_CFLAGS="$(pkg-config --cflags lua5.1)" \
-  Lua_LIBS="$(pkg-config --libs lua5.1)" \
-  PYTHON="/usr/bin/python2" ./configure --prefix=/usr --sysconfdir=/etc \
-    --enable-null-renderer --with-gtk2 --disable-samples \
-    --disable-ogre-renderer --disable-irrlicht-renderer
-  make
-}
-
-package() {
-  cd CEGUI-$pkgver
-
-  make DESTDIR="$pkgdir/" install
-
-  install -Dm644 doc/COPYING "$pkgdir"/usr/share/licenses/$pkgname/LICENSE
-}