irr::core::string< T, TAlloc > Class Template Reference

Very simple string class with some useful features. More...

#include <irrString.h>

Public Types
typedef T	char_type

Public Member Functions
	string ()
	Default constructor. More...
	string (const string< T, TAlloc > &other)
	Constructor. More...
template<class B , class A >
	string (const string< B, A > &other)
	Constructor from other string types. More...
	string (const double number)
	Constructs a string from a float. More...
	string (int number)
	Constructs a string from an int. More...
	string (unsigned int number)
	Constructs a string from an unsigned int. More...
	string (long number)
	Constructs a string from a long. More...
	string (unsigned long number)
	Constructs a string from an unsigned long. More...
template<class B >
	string (const B *const c, u32 length)
	Constructor for copying a string from a pointer with a given length. More...
template<class B >
	string (const B *const c)
	Constructor for Unicode and ASCII strings. More...
	~string ()
	Destructor. More...
string< T, TAlloc > &	operator= (const string< T, TAlloc > &other)
	Assignment operator. More...
template<class B , class A >
string< T, TAlloc > &	operator= (const string< B, A > &other)
	Assignment operator for other string types. More...
template<class B >
string< T, TAlloc > &	operator= (const B *const c)
	Assignment operator for strings, ASCII and Unicode. More...
string< T, TAlloc >	operator+ (const string< T, TAlloc > &other) const
	Append operator for other strings. More...
template<class B >
string< T, TAlloc >	operator+ (const B *const c) const
	Append operator for strings, ASCII and Unicode. More...
T &	operator [] (const u32 index)
	Direct access operator. More...
const T &	operator [] (const u32 index) const
	Direct access operator. More...
bool	operator== (const T *const str) const
	Equality operator. More...
bool	operator== (const string< T, TAlloc > &other) const
	Equality operator. More...
bool	operator< (const string< T, TAlloc > &other) const
	Is smaller comparator. More...
bool	operator!= (const T *const str) const
	Inequality operator. More...
bool	operator!= (const string< T, TAlloc > &other) const
	Inequality operator. More...
u32	size () const
	Returns length of the string's content. More...
bool	empty () const
void	clear (bool releaseMemory=true)
const T *	c_str () const
	Returns character string. More...
string< T, TAlloc > &	make_lower ()
	Makes the string lower case. More...
string< T, TAlloc > &	make_upper ()
	Makes the string upper case. More...
bool	equals_ignore_case (const string< T, TAlloc > &other) const
	Compares the strings ignoring case. More...
bool	equals_substring_ignore_case (const string< T, TAlloc > &other, const s32 sourcePos=0) const
	Compares the strings ignoring case. More...
bool	lower_ignore_case (const string< T, TAlloc > &other) const
	Compares the strings ignoring case. More...
bool	equalsn (const string< T, TAlloc > &other, u32 n) const
	compares the first n characters of the strings More...
bool	equalsn (const T *const str, u32 n) const
	compares the first n characters of the strings More...
string< T, TAlloc > &	append (T character)
	Appends a character to this string. More...
string< T, TAlloc > &	append (const T *const other, u32 length=0xffffffff)
	Appends a char string to this string. More...
string< T, TAlloc > &	append (const string< T, TAlloc > &other)
	Appends a string to this string. More...
string< T, TAlloc > &	append (const string< T, TAlloc > &other, u32 length)
	Appends a string of the length l to this string. More...
string< T, TAlloc > &	insert (u32 pos, const char *s, u32 n)
	Insert a certain amount of characters into the string before the given index. More...
void	reserve (u32 count)
	Reserves some memory. More...
s32	findFirst (T c) const
	finds first occurrence of character in string More...
s32	findFirstChar (const T *const c, u32 count=1) const
	finds first occurrence of a character of a list in string More...
template<class B >
s32	findFirstCharNotInList (const B *const c, u32 count=1) const
	Finds first position of a character not in a given list. More...
template<class B >
s32	findLastCharNotInList (const B *const c, u32 count=1) const
	Finds last position of a character not in a given list. More...
s32	findNext (T c, u32 startPos) const
	finds next occurrence of character in string More...
s32	findLast (T c, s32 start=-1) const
	finds last occurrence of character in string More...
s32	findLastChar (const T *const c, u32 count=1) const
	finds last occurrence of a character of a list in string More...
template<class B >
s32	find (const B *const str, const u32 start=0) const
	finds another string in this string More...
string< T >	subString (u32 begin, s32 length, bool make_lower=false) const
	Returns a substring. More...
string< T, TAlloc > &	operator+= (T c)
	Appends a character to this string. More...
string< T, TAlloc > &	operator+= (const T *const c)
	Appends a char string to this string. More...
string< T, TAlloc > &	operator+= (const string< T, TAlloc > &other)
	Appends a string to this string. More...
string< T, TAlloc > &	operator+= (const int i)
	Appends a string representation of a number to this string. More...
string< T, TAlloc > &	operator+= (const unsigned int i)
	Appends a string representation of a number to this string. More...
string< T, TAlloc > &	operator+= (const long i)
	Appends a string representation of a number to this string. More...
string< T, TAlloc > &	operator+= (const unsigned long i)
	Appends a string representation of a number to this string. More...
string< T, TAlloc > &	operator+= (const double i)
	Appends a string representation of a number to this string. More...
string< T, TAlloc > &	operator+= (const float i)
	Appends a string representation of a number to this string. More...
string< T, TAlloc > &	replace (T toReplace, T replaceWith)
	Replaces all characters of a special type with another one. More...
string< T, TAlloc > &	replace (const string< T, TAlloc > &toReplace, const string< T, TAlloc > &replaceWith)
	Replaces all instances of a string with another one. More...
string< T, TAlloc > &	remove (T c)
	Removes characters from a string. More...
string< T, TAlloc > &	remove (const string< T, TAlloc > &toRemove)
	Removes a string from the string. More...
string< T, TAlloc > &	removeChars (const string< T, TAlloc > &characters)
	Removes characters from a string. More...
string< T, TAlloc > &	trim (const string< T, TAlloc > &whitespace=" \t\n\r")
	Trims the string. More...
string< T, TAlloc > &	eraseTrailingFloatZeros (char decimalPoint='.')
	Erase 0's at the end when a string ends with a floating point number. More...
string< T, TAlloc > &	erase (u32 index)
	Erases a character from the string. More...
string< T, TAlloc > &	validate ()
	verify the existing string. More...
T	lastChar () const
	gets the last char of a string or null More...
template<class container >
u32	split (container &ret, const T *const delimiter, u32 countDelimiters=1, bool ignoreEmptyTokens=true, bool keepSeparators=false) const
	Split string into parts (tokens). More...

Friends
size_t	multibyteToWString (string< wchar_t > &destination, const char *source, u32 sourceSize)
	Internally used by the other multibyteToWString functions. More...

Detailed Description

template<typename T, typename TAlloc>
class irr::core::string< T, TAlloc >

Very simple string class with some useful features.

string<c8> and string<wchar_t> both accept Unicode AND ASCII/Latin-1, so you can assign Unicode to string<c8> and ASCII/Latin-1 to string<wchar_t> (and the other way round) if you want to.

However, note that the conversation between both is not done using any encoding. This means that c8 strings are treated as ASCII/Latin-1, not UTF-8, and are simply expanded to the equivalent wchar_t, while Unicode/wchar_t characters are truncated to 8-bit ASCII/Latin-1 characters, discarding all other information in the wchar_t.

Helper functions for converting between UTF-8 and wchar_t are provided outside the string class for explicit use.

Definition at line 37 of file irrString.h.

Member Typedef Documentation

char_type

template<typename T, typename TAlloc>

typedef T irr::core::string< T, TAlloc >::char_type

Definition at line 98 of file irrString.h.

Constructor & Destructor Documentation

string() [1/10]

template<typename T, typename TAlloc>

irr::core::string< T, TAlloc >::string ( )

inline

Default constructor.

Definition at line 101 of file irrString.h.

        : array(0), allocated(1), used(1)
        {
                array = allocator.allocate(1); // new T[1];
                array[0] = 0;
        }

string() [2/10]

template<typename T, typename TAlloc>

irr::core::string< T, TAlloc >::string ( const string< T, TAlloc > &  other )

inline

Constructor.

Definition at line 110 of file irrString.h.

        : array(0), allocated(0), used(0)
        {
                *this = other;
        }

string() [3/10]

template<typename T, typename TAlloc>

template<class B , class A >

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

inline

Constructor from other string types.

Definition at line 118 of file irrString.h.

        : array(0), allocated(0), used(0)
        {
                *this = other;
        }

string() [4/10]

template<typename T, typename TAlloc>

irr::core::string< T, TAlloc >::string ( const double  number )

inlineexplicit

Constructs a string from a float.

Definition at line 126 of file irrString.h.

        : array(0), allocated(0), used(0)
        {
                c8 tmpbuf[255];
                snprintf_irr(tmpbuf, 255, "%0.6f", number);
                *this = tmpbuf;
        }

string() [5/10]

template<typename T, typename TAlloc>

irr::core::string< T, TAlloc >::string ( int  number )

inlineexplicit

Constructs a string from an int.

Definition at line 136 of file irrString.h.

        : array(0), allocated(0), used(0)
        {
                // store if negative and make positive

                bool negative = false;
                if (number < 0)
                {
                        number *= -1;
                        negative = true;
                }

                // temporary buffer for 16 numbers

                c8 tmpbuf[16]={0};
                u32 idx = 15;

                // special case '0'

                if (!number)
                {
                        tmpbuf[14] = '0';
                        *this = &tmpbuf[14];
                        return;
                }

                // add numbers

                while(number && idx)
                {
                        --idx;
                        tmpbuf[idx] = (c8)('0' + (number % 10));
                        number /= 10;
                }

                // add sign

                if (negative)
                {
                        --idx;
                        tmpbuf[idx] = '-';
                }

                *this = &tmpbuf[idx];
        }

string() [6/10]

template<typename T, typename TAlloc>

irr::core::string< T, TAlloc >::string ( unsigned int  number )

inlineexplicit

Constructs a string from an unsigned int.

Definition at line 184 of file irrString.h.

        : array(0), allocated(0), used(0)
        {
                // temporary buffer for 16 numbers

                c8 tmpbuf[16]={0};
                u32 idx = 15;

                // special case '0'

                if (!number)
                {
                        tmpbuf[14] = '0';
                        *this = &tmpbuf[14];
                        return;
                }

                // add numbers

                while(number && idx)
                {
                        --idx;
                        tmpbuf[idx] = (c8)('0' + (number % 10));
                        number /= 10;
                }

                *this = &tmpbuf[idx];
        }

string() [7/10]

template<typename T, typename TAlloc>

irr::core::string< T, TAlloc >::string ( long  number )

inlineexplicit

Constructs a string from a long.

Definition at line 215 of file irrString.h.

        : array(0), allocated(0), used(0)
        {
                // store if negative and make positive

                bool negative = false;
                if (number < 0)
                {
                        number *= -1;
                        negative = true;
                }

                // temporary buffer for 16 numbers

                c8 tmpbuf[16]={0};
                u32 idx = 15;

                // special case '0'

                if (!number)
                {
                        tmpbuf[14] = '0';
                        *this = &tmpbuf[14];
                        return;
                }

                // add numbers

                while(number && idx)
                {
                        --idx;
                        tmpbuf[idx] = (c8)('0' + (number % 10));
                        number /= 10;
                }

                // add sign

                if (negative)
                {
                        --idx;
                        tmpbuf[idx] = '-';
                }

                *this = &tmpbuf[idx];
        }

string() [8/10]

template<typename T, typename TAlloc>

irr::core::string< T, TAlloc >::string ( unsigned long  number )

inlineexplicit

Constructs a string from an unsigned long.

Definition at line 263 of file irrString.h.

        : array(0), allocated(0), used(0)
        {
                // temporary buffer for 16 numbers

                c8 tmpbuf[16]={0};
                u32 idx = 15;

                // special case '0'

                if (!number)
                {
                        tmpbuf[14] = '0';
                        *this = &tmpbuf[14];
                        return;
                }

                // add numbers

                while(number && idx)
                {
                        --idx;
                        tmpbuf[idx] = (c8)('0' + (number % 10));
                        number /= 10;
                }

                *this = &tmpbuf[idx];
        }

string() [9/10]

template<typename T, typename TAlloc>

template<class B >

irr::core::string< T, TAlloc >::string ( const B *const  c, u32  length  )

inline

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

Definition at line 295 of file irrString.h.

        : array(0), allocated(0), used(0)
        {
                if (!c)
                {
                        // correctly init the string to an empty one
                        *this="";
                        return;
                }

                allocated = used = length+1;
                array = allocator.allocate(used); // new T[used];

                for (u32 l = 0; l<length; ++l)
                        array[l] = (T)c[l];

                array[length] = 0;
        }

string() [10/10]

template<typename T, typename TAlloc>

template<class B >

irr::core::string< T, TAlloc >::string ( const B *const  c )

inline

Constructor for Unicode and ASCII strings.

Definition at line 317 of file irrString.h.

        : array(0), allocated(0), used(0)
        {
                *this = c;
        }

~string()

template<typename T, typename TAlloc>

irr::core::string< T, TAlloc >::~string ( )

inline

Destructor.

Definition at line 325 of file irrString.h.

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

Member Function Documentation

append() [1/4]

template<typename T, typename TAlloc>

string<T,TAlloc>& irr::core::string< T, TAlloc >::append ( T  character )

inline

Appends a character to this string.

Parameters

character

Character to append.

Definition at line 634 of file irrString.h.

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

                ++used;

                array[used-2] = character;
                array[used-1] = 0;

                return *this;
        }

append() [2/4]

template<typename T, typename TAlloc>

string<T,TAlloc>& irr::core::string< T, TAlloc >::append ( const T *const  other, u32  length = 0xffffffff  )

inline

Appends a char string to this string.

Parameters

other	Char string to append.
length	The length of the string to append.

Definition at line 651 of file irrString.h.

        {
                if (!other)
                        return *this;

                u32 len = 0;
                const T* p = other;
                while(*p)
                {
                        ++len;
                        ++p;
                }
                if (len > length)
                        len = length;

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

                --used;
                ++len;

                for (u32 l=0; l<len; ++l)
                        array[l+used] = *(other+l);

                used += len;

                return *this;
        }

append() [3/4]

template<typename T, typename TAlloc>

string<T,TAlloc>& irr::core::string< T, TAlloc >::append ( const string< T, TAlloc > &  other )

inline

Appends a string to this string.

Parameters

other

String to append.

Definition at line 683 of file irrString.h.

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

                --used;
                const u32 len = other.size()+1;

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

                for (u32 l=0; l<len; ++l)
                        array[used+l] = other[l];

                used += len;

                return *this;
        }

append() [4/4]

template<typename T, typename TAlloc>

string<T,TAlloc>& irr::core::string< T, TAlloc >::append ( const string< T, TAlloc > &  other, u32  length  )

inline

Appends a string of the length l to this string.

Parameters

other	other String to append to this string.
length	How much characters of the other string to add to this one.

Definition at line 706 of file irrString.h.

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

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

                if (used + length > allocated)
                        reallocate(used + length);

                --used;

                for (u32 l=0; l<length; ++l)
                        array[l+used] = other[l];
                used += length;

                // ensure proper termination
                array[used]=0;
                ++used;

                return *this;
        }

c_str()

template<typename T, typename TAlloc>

const T* irr::core::string< T, TAlloc >::c_str ( ) const

inline

Returns character string.

Returns

pointer to C-style NUL terminated string.

Definition at line 526 of file irrString.h.

        {
                return array;
        }

clear()

template<typename T, typename TAlloc>

void irr::core::string< T, TAlloc >::clear ( bool  releaseMemory = true )

inline

Definition at line 514 of file irrString.h.

        {
                if ( releaseMemory )
                {
                        reallocate(1);
                }
                array[0] = 0;
                used = 1;
        }

empty()

template<typename T, typename TAlloc>

bool irr::core::string< T, TAlloc >::empty ( ) const

inline

Informs if the string is empty or not.

Returns

True if the string is empty, false if not.

Definition at line 509 of file irrString.h.

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

equals_ignore_case()

template<typename T, typename TAlloc>

bool irr::core::string< T, TAlloc >::equals_ignore_case ( const string< T, TAlloc > &  other ) const

inline

Compares the strings ignoring case.

Parameters

other

Other string to compare.

Returns

True if the strings are equal ignoring case.

Definition at line 553 of file irrString.h.

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

                return used == other.used;
        }

equals_substring_ignore_case()

template<typename T, typename TAlloc>

bool irr::core::string< T, TAlloc >::equals_substring_ignore_case ( const string< T, TAlloc > &  other, const s32  sourcePos = 0  ) const

inline

Compares the strings ignoring case.

Parameters

other	Other string to compare.
sourcePos	where to start to compare in the string

Returns

True if the strings are equal ignoring case.

Definition at line 566 of file irrString.h.

        {
                if ( (u32) sourcePos >= used )
                        return false;

                u32 i;
                for( i=0; array[sourcePos + i] && other[i]; ++i)
                        if (locale_lower( array[sourcePos + i]) != locale_lower(other[i]))
                                return false;

                return array[sourcePos + i] == 0 && other[i] == 0;
        }

equalsn() [1/2]

template<typename T, typename TAlloc>

bool irr::core::string< T, TAlloc >::equalsn ( const string< T, TAlloc > &  other, u32  n  ) const

inline

compares the first n characters of the strings

Parameters

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

Returns

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

Definition at line 600 of file irrString.h.

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

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

equalsn() [2/2]

template<typename T, typename TAlloc>

bool irr::core::string< T, TAlloc >::equalsn ( const T *const  str, u32  n  ) const

inline

compares the first n characters of the strings

Parameters

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

Returns

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

Definition at line 617 of file irrString.h.

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

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

erase()

template<typename T, typename TAlloc>

string<T,TAlloc>& irr::core::string< T, TAlloc >::erase ( u32  index )

inline

Erases a character from the string.

May be slow, because all elements following after the erased element have to be copied.

Parameters

index

Index of element to be erased.

Definition at line 1326 of file irrString.h.

        {
                _IRR_DEBUG_BREAK_IF(index>=used) // access violation

                for (u32 i=index+1; i<used; ++i)
                        array[i-1] = array[i];

                --used;
                return *this;
        }

eraseTrailingFloatZeros()

template<typename T, typename TAlloc>

string<T,TAlloc>& irr::core::string< T, TAlloc >::eraseTrailingFloatZeros ( char  decimalPoint = '.' )

inline

Erase 0's at the end when a string ends with a floating point number.

After generating strings from floats we often end up with strings ending up with lots of zeros which don't add any value. Erase 'em all. Examples: "0.100000" becomes "0.1" "10.000000" becomes "10" "foo 3.140000" becomes "foo 3.14" "no_num.000" stays "no_num.000" "1." stays "1."

Definition at line 1295 of file irrString.h.

        {
                s32 i=findLastCharNotInList("0", 1);
                if ( i > 0 && (u32)i < used-2 ) // non 0 must be found and not last char (also used is at least 2 when i > 0)
                {
                        u32 eraseStart=i+1;
                        u32 dot=0;
                        if( core::isdigit(array[i]) )
                        {
                                while( --i>0 && core::isdigit(array[i]) );
                                if ( array[i] == decimalPoint )
                                        dot = i;
                        }
                        else if ( array[i] == decimalPoint )
                        {
                                dot = i;
                                eraseStart = i;
                        }
                        if ( dot > 0 && core::isdigit(array[dot-1]) )
                        {
                                array[eraseStart] = 0;
                                used = eraseStart+1;
                        }
                }
                return *this;
        }

find()

template<typename T, typename TAlloc>

template<class B >

s32 irr::core::string< T, TAlloc >::find ( const B *const  str, const u32  start = 0  ) const

inline

finds another string in this string

Parameters

str	Another string
start	Start position of the search

Returns

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

Definition at line 916 of file irrString.h.

        {
                if (str && *str)
                {
                        u32 len = 0;

                        while (str[len])
                                ++len;

                        if (len > used-1)
                                return -1;

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

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

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

                return -1;
        }

findFirst()

template<typename T, typename TAlloc>

s32 irr::core::string< T, TAlloc >::findFirst ( T  c ) const

inline

finds first occurrence of character in string

Parameters

c	Character to search for.

Returns

Position where the character has been found, or -1 if not found.

Definition at line 775 of file irrString.h.

        {
                for (u32 i=0; i<used-1; ++i)
                        if (array[i] == c)
                                return i;

                return -1;
        }

findFirstChar()

template<typename T, typename TAlloc>

s32 irr::core::string< T, TAlloc >::findFirstChar ( const T *const  c, u32  count = 1  ) const

inline

finds first occurrence of a character of a list in string

Parameters

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

Returns

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

Definition at line 791 of file irrString.h.

        {
                if (!c || !count)
                        return -1;

                for (u32 i=0; i<used-1; ++i)
                        for (u32 j=0; j<count; ++j)
                                if (array[i] == c[j])
                                        return i;

                return -1;
        }

findFirstCharNotInList()

template<typename T, typename TAlloc>

template<class B >

s32 irr::core::string< T, TAlloc >::findFirstCharNotInList ( const B *const  c, u32  count = 1  ) const

inline

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

Parameters

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

Returns

Position where the character has been found, or -1 if not found.

Definition at line 813 of file irrString.h.

        {
                if (!c || !count)
                        return -1;

                for (u32 i=0; i<used-1; ++i)
                {
                        u32 j;
                        for (j=0; j<count; ++j)
                                if (array[i] == c[j])
                                        break;

                        if (j==count)
                                return i;
                }

                return -1;
        }

findLast()

template<typename T, typename TAlloc>

s32 irr::core::string< T, TAlloc >::findLast ( T  c, s32  start = -1  ) const

inline

finds last occurrence of character in string

Parameters

c	Character to search for.
start	start to search reverse ( default = -1, on end )

Returns

Position where the character has been found, or -1 if not found.

Definition at line 879 of file irrString.h.

        {
                start = core::clamp ( start < 0 ? (s32)(used) - 2 : start, 0, (s32)(used) - 2 );
                for (s32 i=start; i>=0; --i)
                        if (array[i] == c)
                                return i;

                return -1;
        }

findLastChar()

template<typename T, typename TAlloc>

s32 irr::core::string< T, TAlloc >::findLastChar ( const T *const  c, u32  count = 1  ) const

inline

finds last occurrence of a character of a list in string

Parameters

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

Returns

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

Definition at line 896 of file irrString.h.

        {
                if (!c || !count)
                        return -1;

                for (s32 i=(s32)used-2; i>=0; --i)
                        for (u32 j=0; j<count; ++j)
                                if (array[i] == c[j])
                                        return i;

                return -1;
        }

findLastCharNotInList()

template<typename T, typename TAlloc>

template<class B >

s32 irr::core::string< T, TAlloc >::findLastCharNotInList ( const B *const  c, u32  count = 1  ) const

inline

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

Parameters

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

Returns

Position where the character has been found, or -1 if not found.

Definition at line 840 of file irrString.h.

        {
                if (!c || !count)
                        return -1;

                for (s32 i=(s32)(used-2); i>=0; --i)
                {
                        u32 j;
                        for (j=0; j<count; ++j)
                                if (array[i] == c[j])
                                        break;

                        if (j==count)
                                return i;
                }

                return -1;
        }

findNext()

template<typename T, typename TAlloc>

s32 irr::core::string< T, TAlloc >::findNext ( T  c, u32  startPos  ) const

inline

finds next occurrence of character in string

Parameters

c	Character to search for.
startPos	Position in string to start searching.

Returns

Position where the character has been found, or -1 if not found.

Definition at line 864 of file irrString.h.

        {
                for (u32 i=startPos; i<used-1; ++i)
                        if (array[i] == c)
                                return i;

                return -1;
        }

insert()

template<typename T, typename TAlloc>

string<T,TAlloc>& irr::core::string< T, TAlloc >::insert ( u32  pos, const char *  s, u32  n  )

inline

Insert a certain amount of characters into the string before the given index.

Definition at line 737 of file irrString.h.

        {
                if ( pos < used )
                {
                        reserve(used+n);

                        // move stuff behind insert point
                        const u32 end = used+n-1;
                        for (u32 i=0; i<used-pos; ++i)
                        {
                                array[end-i] = array[end-(i+n)];
                        }
                        used += n;

                        for (u32 i=0; i<n; ++i)
                        {
                                array[pos+i] = s[i];
                        }
                }

                return *this;
        }

lastChar()

template<typename T, typename TAlloc>

T irr::core::string< T, TAlloc >::lastChar ( ) const

inline

gets the last char of a string or null

Definition at line 1365 of file irrString.h.

        {
                return used > 1 ? array[used-2] : 0;
        }

lower_ignore_case()

template<typename T, typename TAlloc>

bool irr::core::string< T, TAlloc >::lower_ignore_case ( const string< T, TAlloc > &  other ) const

inline

Compares the strings ignoring case.

Parameters

other

Other string to compare.

Returns

True if this string is smaller ignoring case.

Definition at line 583 of file irrString.h.

        {
                for(u32 i=0; array[i] && other.array[i]; ++i)
                {
                        s32 diff = (s32) locale_lower ( array[i] ) - (s32) locale_lower ( other.array[i] );
                        if ( diff )
                                return diff < 0;
                }

                return used < other.used;
        }

make_lower()

template<typename T, typename TAlloc>

string<T,TAlloc>& irr::core::string< T, TAlloc >::make_lower ( )

inline

Makes the string lower case.

Definition at line 533 of file irrString.h.

        {
                for (u32 i=0; array[i]; ++i)
                        array[i] = locale_lower ( array[i] );
                return *this;
        }

make_upper()

template<typename T, typename TAlloc>

string<T,TAlloc>& irr::core::string< T, TAlloc >::make_upper ( )

inline

Makes the string upper case.

Definition at line 542 of file irrString.h.

        {
                for (u32 i=0; array[i]; ++i)
                        array[i] = locale_upper ( array[i] );
                return *this;
        }

operator []() [1/2]

template<typename T, typename TAlloc>

T& irr::core::string< T, TAlloc >::operator [] ( const u32  index )

inline

Direct access operator.

Definition at line 430 of file irrString.h.

        {
                _IRR_DEBUG_BREAK_IF(index>=used) // bad index
                return array[index];
        }

operator []() [2/2]

template<typename T, typename TAlloc>

const T& irr::core::string< T, TAlloc >::operator [] ( const u32  index ) const

inline

Direct access operator.

Definition at line 438 of file irrString.h.

        {
                _IRR_DEBUG_BREAK_IF(index>=used) // bad index
                return array[index];
        }

operator!=() [1/2]

template<typename T, typename TAlloc>

bool irr::core::string< T, TAlloc >::operator!= ( const T *const  str ) const

inline

Inequality operator.

Definition at line 486 of file irrString.h.

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

operator!=() [2/2]

template<typename T, typename TAlloc>

bool irr::core::string< T, TAlloc >::operator!= ( const string< T, TAlloc > &  other ) const

inline

Inequality operator.

Definition at line 493 of file irrString.h.

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

operator+() [1/2]

template<typename T, typename TAlloc>

string<T,TAlloc> irr::core::string< T, TAlloc >::operator+ ( const string< T, TAlloc > &  other ) const

inline

Append operator for other strings.

Definition at line 409 of file irrString.h.

        {
                string<T,TAlloc> str(*this);
                str.append(other);

                return str;
        }

operator+() [2/2]

template<typename T, typename TAlloc>

template<class B >

string<T,TAlloc> irr::core::string< T, TAlloc >::operator+ ( const B *const  c ) const

inline

Append operator for strings, ASCII and Unicode.

Definition at line 420 of file irrString.h.

        {
                string<T,TAlloc> str(*this);
                str.append(c);

                return str;
        }

operator+=() [1/9]

template<typename T, typename TAlloc>

string<T,TAlloc>& irr::core::string< T, TAlloc >::operator+= ( T  c )

inline

Appends a character to this string.

Parameters

c	Character to append.

Definition at line 981 of file irrString.h.

        {
                append(c);
                return *this;
        }

operator+=() [2/9]

template<typename T, typename TAlloc>

string<T,TAlloc>& irr::core::string< T, TAlloc >::operator+= ( const T *const  c )

inline

Appends a char string to this string.

Parameters

c	Char string to append.

Definition at line 990 of file irrString.h.

        {
                append(c);
                return *this;
        }

operator+=() [3/9]

template<typename T, typename TAlloc>

string<T,TAlloc>& irr::core::string< T, TAlloc >::operator+= ( const string< T, TAlloc > &  other )

inline

Appends a string to this string.

Parameters

other

String to append.

Definition at line 999 of file irrString.h.

        {
                append(other);
                return *this;
        }

operator+=() [4/9]

template<typename T, typename TAlloc>

string<T,TAlloc>& irr::core::string< T, TAlloc >::operator+= ( const int  i )

inline

Appends a string representation of a number to this string.

Parameters

i	Number to append.

Definition at line 1008 of file irrString.h.

        {
                append(string<T,TAlloc>(i));
                return *this;
        }

operator+=() [5/9]

template<typename T, typename TAlloc>

string<T,TAlloc>& irr::core::string< T, TAlloc >::operator+= ( const unsigned int  i )

inline

Appends a string representation of a number to this string.

Parameters

i	Number to append.

Definition at line 1017 of file irrString.h.

        {
                append(string<T,TAlloc>(i));
                return *this;
        }

operator+=() [6/9]

template<typename T, typename TAlloc>

string<T,TAlloc>& irr::core::string< T, TAlloc >::operator+= ( const long  i )

inline

Appends a string representation of a number to this string.

Parameters

i	Number to append.

Definition at line 1026 of file irrString.h.

        {
                append(string<T,TAlloc>(i));
                return *this;
        }

operator+=() [7/9]

template<typename T, typename TAlloc>

string<T,TAlloc>& irr::core::string< T, TAlloc >::operator+= ( const unsigned long  i )

inline

Appends a string representation of a number to this string.

Parameters

i	Number to append.

Definition at line 1035 of file irrString.h.

        {
                append(string<T,TAlloc>(i));
                return *this;
        }

operator+=() [8/9]

template<typename T, typename TAlloc>

string<T,TAlloc>& irr::core::string< T, TAlloc >::operator+= ( const double  i )

inline

Appends a string representation of a number to this string.

Parameters

i	Number to append.

Definition at line 1044 of file irrString.h.

        {
                append(string<T,TAlloc>(i));
                return *this;
        }

operator+=() [9/9]

template<typename T, typename TAlloc>

string<T,TAlloc>& irr::core::string< T, TAlloc >::operator+= ( const float  i )

inline

Appends a string representation of a number to this string.

Parameters

i	Number to append.

Definition at line 1053 of file irrString.h.

        {
                append(string<T,TAlloc>(i));
                return *this;
        }

operator<()

template<typename T, typename TAlloc>

bool irr::core::string< T, TAlloc >::operator< ( const string< T, TAlloc > &  other ) const

inline

Is smaller comparator.

Definition at line 472 of file irrString.h.

        {
                for (u32 i=0; array[i] && other.array[i]; ++i)
                {
                        const s32 diff = array[i] - other.array[i];
                        if (diff)
                                return (diff < 0);
                }

                return (used < other.used);
        }

operator=() [1/3]

template<typename T, typename TAlloc>

string<T,TAlloc>& irr::core::string< T, TAlloc >::operator= ( const string< T, TAlloc > &  other )

inline

Assignment operator.

Definition at line 332 of file irrString.h.

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

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

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

                return *this;
        }

operator=() [2/3]

template<typename T, typename TAlloc>

template<class B , class A >

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

inline

Assignment operator for other string types.

Definition at line 354 of file irrString.h.

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

operator=() [3/3]

template<typename T, typename TAlloc>

template<class B >

string<T,TAlloc>& irr::core::string< T, TAlloc >::operator= ( const B *const  c )

inline

Assignment operator for strings, ASCII and Unicode.

Definition at line 363 of file irrString.h.

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

                if ((void*)c == (void*)array)
                        return *this;

                u32 len = 0;
                const B* p = c;
                do
                {
                        ++len;
                } while(*p++);

                // we'll keep the old string for a while, because the new
                // string could be a part of the current string.
                T* oldArray = array;

                used = len;
                if (used>allocated)
                {
                        allocated = used;
                        array = allocator.allocate(used); //new T[used];
                }

                for (u32 l = 0; l<len; ++l)
                        array[l] = (T)c[l];

                if (oldArray != array)
                        allocator.deallocate(oldArray); // delete [] oldArray;

                return *this;
        }

operator==() [1/2]

template<typename T, typename TAlloc>

bool irr::core::string< T, TAlloc >::operator== ( const T *const  str ) const

inline

Equality operator.

Definition at line 446 of file irrString.h.

        {
                if (!str)
                        return false;

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

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

operator==() [2/2]

template<typename T, typename TAlloc>

bool irr::core::string< T, TAlloc >::operator== ( const string< T, TAlloc > &  other ) const

inline

Equality operator.

Definition at line 461 of file irrString.h.

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

                return used == other.used;
        }

remove() [1/2]

template<typename T, typename TAlloc>

string<T,TAlloc>& irr::core::string< T, TAlloc >::remove ( T  c )

inline

Removes characters from a string.

Parameters

c	Character to remove.

Definition at line 1183 of file irrString.h.

        {
                u32 pos = 0;
                u32 found = 0;
                for (u32 i=0; i<used-1; ++i)
                {
                        if (array[i] == c)
                        {
                                ++found;
                                continue;
                        }

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

remove() [2/2]

template<typename T, typename TAlloc>

string<T,TAlloc>& irr::core::string< T, TAlloc >::remove ( const string< T, TAlloc > &  toRemove )

inline

Removes a string from the string.

Parameters

toRemove

String to remove.

Definition at line 1205 of file irrString.h.

        {
                u32 size = toRemove.size();
                if ( size == 0 )
                        return *this;
                u32 pos = 0;
                u32 found = 0;
                for (u32 i=0; i<used-1; ++i)
                {
                        u32 j = 0;
                        while (j < size)
                        {
                                if (array[i + j] != toRemove[j])
                                        break;
                                ++j;
                        }
                        if (j == size)
                        {
                                found += size;
                                i += size - 1;
                                continue;
                        }

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

removeChars()

template<typename T, typename TAlloc>

string<T,TAlloc>& irr::core::string< T, TAlloc >::removeChars ( const string< T, TAlloc > &  characters )

inline

Removes characters from a string.

Parameters

characters

Characters to remove.

Definition at line 1238 of file irrString.h.

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

                u32 pos = 0;
                u32 found = 0;
                for (u32 i=0; i<used-1; ++i)
                {
                        // Don't use characters.findFirst as it finds the \0,
                        // causing used to become incorrect.
                        bool docontinue = false;
                        for (u32 j=0; j<characters.size(); ++j)
                        {
                                if (characters[j] == array[i])
                                {
                                        ++found;
                                        docontinue = true;
                                        break;
                                }
                        }
                        if (docontinue)
                                continue;

                        array[pos++] = array[i];
                }
                used -= found;
                array[used-1] = 0;

                return *this;
        }

replace() [1/2]

template<typename T, typename TAlloc>

string<T,TAlloc>& irr::core::string< T, TAlloc >::replace ( T  toReplace, T  replaceWith  )

inline

Replaces all characters of a special type with another one.

Parameters

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

Definition at line 1063 of file irrString.h.

        {
                for (u32 i=0; i<used-1; ++i)
                        if (array[i] == toReplace)
                                array[i] = replaceWith;
                return *this;
        }

replace() [2/2]

template<typename T, typename TAlloc>

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

inline

Replaces all instances of a string with another one.

Parameters

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

Definition at line 1075 of file irrString.h.

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

                const T* other = toReplace.c_str();
                const T* replace = replaceWith.c_str();
                const u32 other_size = toReplace.size();
                const u32 replace_size = replaceWith.size();

                // Determine the delta.  The algorithm will change depending on the delta.
                s32 delta = replace_size - other_size;

                // A character for character replace.  The string will not shrink or grow.
                if (delta == 0)
                {
                        s32 pos = 0;
                        while ((pos = find(other, pos)) != -1)
                        {
                                for (u32 i = 0; i < replace_size; ++i)
                                        array[pos + i] = replace[i];
                                ++pos;
                        }
                        return *this;
                }

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

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

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

                        return *this;
                }

                // We are going to be adding characters, so the string size will increase.
                // Count the number of times toReplace exists in the string so we can allocate the new size.
                u32 find_count = 0;
                s32 pos = 0;
                while ((pos = find(other, pos)) != -1)
                {
                        ++find_count;
                        ++pos;
                }

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

                // Start replacing.
                pos = 0;
                while ((pos = find(other, pos)) != -1)
                {
                        T* start = array + pos + other_size - 1;
                        T* ptr   = array + used - 1;
                        T* end   = array + delta + used -1;

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

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

                        pos += replace_size;
                        used += delta;
                }

                return *this;
        }

reserve()

template<typename T, typename TAlloc>

void irr::core::string< T, TAlloc >::reserve ( u32  count )

inline

Reserves some memory.

Parameters

count

Amount of characters to reserve.

Definition at line 762 of file irrString.h.

        {
                if (count < allocated)
                        return;

                reallocate(count);
        }

size()

template<typename T, typename TAlloc>

u32 irr::core::string< T, TAlloc >::size ( ) const

inline

Returns length of the string's content.

Returns

Length of the string's content in characters, excluding the trailing NUL.

Definition at line 502 of file irrString.h.

        {
                return used-1;
        }

split()

template<typename T, typename TAlloc>

template<class container >

u32 irr::core::string< T, TAlloc >::split ( container &  ret, const T *const  delimiter, u32  countDelimiters = 1, bool  ignoreEmptyTokens = true, bool  keepSeparators = false  ) const

inline

Split string into parts (tokens).

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

Parameters

ret	The result container. Tokens are added, the container is not cleared.
delimiter	C-style string of delimiter characters
countDelimiters	Number of delimiter characters
ignoreEmptyTokens	Flag to avoid empty substrings in the result container. If two delimiters occur without a character in between or an empty substring would be placed in the result. Or if a delimiter is the last character an empty substring would be added at the end. If this flag is set, only non-empty strings are stored.
keepSeparators	Flag which allows to add the separator to the result string. If this flag is true, the concatenation of the substrings results in the original string. Otherwise, only the characters between the delimiters are returned.

Returns

The number of resulting substrings

Definition at line 1390 of file irrString.h.

        {
                if (!delimiter)
                        return 0;

                const u32 oldSize=ret.size();

                u32 tokenStartIdx = 0;
                for (u32 i=0; i<used; ++i)
                {
                        for (u32 j=0; j<countDelimiters; ++j)
                        {
                                if (array[i] == delimiter[j])
                                {
                                        if (i - tokenStartIdx > 0)
                                                ret.push_back(string<T,TAlloc>(&array[tokenStartIdx], i - tokenStartIdx));
                                        else if ( !ignoreEmptyTokens )
                                                ret.push_back(string<T,TAlloc>());
                                        if ( keepSeparators )
                                        {
                                                ret.push_back(string<T,TAlloc>(&array[i], 1));
                                        }

                                        tokenStartIdx = i+1;
                                        break;
                                }
                        }
                }
                if ((used - 1) > tokenStartIdx)
                        ret.push_back(string<T,TAlloc>(&array[tokenStartIdx], (used - 1) - tokenStartIdx));
                 else if ( !ignoreEmptyTokens )
                ret.push_back(string<T,TAlloc>());

                return ret.size()-oldSize;
        }

subString()

template<typename T, typename TAlloc>

string<T> irr::core::string< T, TAlloc >::subString ( u32  begin, s32  length, bool  make_lower = false  ) const

inline

Returns a substring.

Parameters

begin	Start of substring.
length	Length of substring.
make_lower	copy only lower case

Definition at line 948 of file irrString.h.

        {
                // if start after string
                // or no proper substring length
                if ((length <= 0) || (begin>=size()))
                        return string<T>("");
                // clamp length to maximal value
                if ((length+begin) > size())
                        length = size()-begin;

                string<T> o;
                o.reserve(length+1);

                if ( !make_lower )
                {
                        for (s32 i=0; i<length; ++i)
                                o.array[i] = array[i+begin];
                }
                else
                {
                        for (s32 i=0; i<length; ++i)
                                o.array[i] = locale_lower ( array[i+begin] );
                }

                o.array[length] = 0;
                o.used = length + 1;

                return o;
        }

trim()

template<typename T, typename TAlloc>

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

inline

Trims the string.

Removes the specified characters (by default, Latin-1 whitespace) from the beginning and the end of the string.

Definition at line 1274 of file irrString.h.

        {
                // find start and end of the substring without the specified characters
                const s32 begin = findFirstCharNotInList(whitespace.c_str(), whitespace.used);
                if (begin == -1)
                        return (*this="");

                const s32 end = findLastCharNotInList(whitespace.c_str(), whitespace.used);

                return (*this = subString(begin, (end +1) - begin));
        }

validate()

template<typename T, typename TAlloc>

string<T,TAlloc>& irr::core::string< T, TAlloc >::validate ( )

inline

verify the existing string.

Definition at line 1338 of file irrString.h.

        {
                // terminate on existing null
                for (u32 i=0; i<allocated; ++i)
                {
                        if (array[i] == 0)
                        {
                                used = i + 1;
                                return *this;
                        }
                }

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

                return *this;
        }

Friends And Related Function Documentation

multibyteToWString

template<typename T, typename TAlloc>

size_t multibyteToWString ( string< wchar_t > &  destination, const char *  source, u32  sourceSize  )

friend

Internally used by the other multibyteToWString functions.

Definition at line 1487 of file irrString.h.

{
        if ( sourceSize )
        {
                destination.reserve(sourceSize+1);
#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable: 4996)  // 'mbstowcs': This function or variable may be unsafe. Consider using mbstowcs_s instead.
#endif
                const size_t written = mbstowcs(destination.array, source, (size_t)sourceSize);
#if defined(_MSC_VER)
#pragma warning(pop)
#endif
                if ( written != (size_t)-1 )
                {
                        destination.used = (u32)written+1;
                        destination.array[destination.used-1] = 0;
                }
                else
                {
                        // Likely character which got converted until the invalid character was encountered are in destination now.
                        // And it seems even 0-terminated, but I found no documentation anywhere that this (the 0-termination) is guaranteed :-(
                        destination.clear();
                }
                return written;
        }
        else
        {
                destination.clear();
                return 0;
        }
}

---

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

• include/irrlicht/irrString.h