diff options
Diffstat (limited to 'pcr/cegui-0.5')
| -rw-r--r-- | pcr/cegui-0.5/CEGUIString.h | 5603 | ||||
| -rw-r--r-- | pcr/cegui-0.5/PKGBUILD | 41 |
2 files changed, 5644 insertions, 0 deletions
diff --git a/pcr/cegui-0.5/CEGUIString.h b/pcr/cegui-0.5/CEGUIString.h new file mode 100644 index 000000000..13a61ba15 --- /dev/null +++ b/pcr/cegui-0.5/CEGUIString.h @@ -0,0 +1,5603 @@ +/*********************************************************************** + 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 new file mode 100644 index 000000000..60c3427cc --- /dev/null +++ b/pcr/cegui-0.5/PKGBUILD @@ -0,0 +1,41 @@ +# Contributor: 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') +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') |