Home | Namespaces | Hierarchy | Alphabetical List | Class list | Files | Namespace Members | Class members | File members | Tutorials

# irrString.h

Go to the documentation of this file.

    00001 // Copyright (C) 2002-2009 Nikolaus Gebhardt
    00002 // This file is part of the "Irrlicht Engine" and the "irrXML" project.
    00003 // For conditions of distribution and use, see copyright notice in irrlicht.h and irrXML.h
    00004
    00005 #ifndef __IRR_STRING_H_INCLUDED__
    00006 #define __IRR_STRING_H_INCLUDED__
    00007
    00008 #include "irrTypes.h"
    00009 #include "irrAllocator.h"
    00010 #include "irrMath.h"
    00011 #include <stdio.h>
    00012 #include <string.h>
    00013 #include <stdlib.h>
    00014
    00015 namespace irr
    00016 {
    00017 namespace core
    00018 {
    00019
    00021
    00032 enum eLocaleID
    00033 {
    00034         IRR_LOCALE_ANSI = 0,
    00035         IRR_LOCALE_GERMAN = 1
    00036 };
    00037
    00038 static eLocaleID locale_current = IRR_LOCALE_ANSI;
    00039 static inline void locale_set ( eLocaleID id )
    00040 {
    00041         locale_current = id;
    00042 }
    00043
    00045 static inline u32 locale_lower ( u32 x )
    00046 {
    00047         switch ( locale_current )
    00048         {
    00049                 case IRR_LOCALE_GERMAN:
    00050                 case IRR_LOCALE_ANSI:
    00051                         break;
    00052         }
    00053         // ansi
    00054         return x >= 'A' && x <= 'Z' ? x + 0x20 : x;
    00055 }
    00056
    00058 static inline u32 locale_upper ( u32 x )
    00059 {
    00060         switch ( locale_current )
    00061         {
    00062                 case IRR_LOCALE_GERMAN:
    00063                 case IRR_LOCALE_ANSI:
    00064                         break;
    00065         }
    00066
    00067         // ansi
    00068         return x >= 'a' && x <= 'z' ? x + ( 'A' - 'a' ) : x;
    00069 }
    00070
    00071
    00072 template <typename T, typename TAlloc = irrAllocator<T> >
    00073 class string
    00074 {
    00075 public:
    00076
    00078         string()
    00079         : array(0), allocated(1), used(1)
    00080         {
    00081                 array = allocator.allocate(1); // new T[1];
    00082                 array[0] = 0x0;
    00083         }
    00084
    00085
    00087         string(const string<T,TAlloc>& other)
    00088         : array(0), allocated(0), used(0)
    00089         {
    00090                 *this = other;
    00091         }
    00092
    00094         template <class B, class A>
    00095         string(const string<B, A>& other)
    00096         : array(0), allocated(0), used(0)
    00097         {
    00098                 *this = other;
    00099         }
    00100
    00101
    00103         explicit string(const double number)
    00104         : array(0), allocated(0), used(0)
    00105         {
    00106                 c8 tmpbuf[255];
    00107                 snprintf(tmpbuf, 255, "%0.6f", number);
    00108                 *this = tmpbuf;
    00109         }
    00110
    00111
    00113         explicit string(int number)
    00114         : array(0), allocated(0), used(0)
    00115         {
    00116                 // store if negative and make positive
    00117
    00118                 bool negative = false;
    00119                 if (number < 0)
    00120                 {
    00121                         number *= -1;
    00122                         negative = true;
    00123                 }
    00124
    00125                 // temporary buffer for 16 numbers
    00126
    00127                 c8 tmpbuf[16]={0};
    00128                 u32 idx = 15;
    00129
    00130                 // special case '0'
    00131
    00132                 if (!number)
    00133                 {
    00134                         tmpbuf[14] = '0';
    00135                         *this = &tmpbuf[14];
    00136                         return;
    00137                 }
    00138
    00139                 // add numbers
    00140
    00141                 while(number && idx)
    00142                 {
    00143                         --idx;
    00144                         tmpbuf[idx] = (c8)('0' + (number % 10));
    00145                         number /= 10;
    00146                 }
    00147
    00148                 // add sign
    00149
    00150                 if (negative)
    00151                 {
    00152                         --idx;
    00153                         tmpbuf[idx] = '-';
    00154                 }
    00155
    00156                 *this = &tmpbuf[idx];
    00157         }
    00158
    00159
    00161         explicit string(unsigned int number)
    00162         : array(0), allocated(0), used(0)
    00163         {
    00164                 // temporary buffer for 16 numbers
    00165
    00166                 c8 tmpbuf[16]={0};
    00167                 u32 idx = 15;
    00168
    00169                 // special case '0'
    00170
    00171                 if (!number)
    00172                 {
    00173                         tmpbuf[14] = '0';
    00174                         *this = &tmpbuf[14];
    00175                         return;
    00176                 }
    00177
    00178                 // add numbers
    00179
    00180                 while(number && idx)
    00181                 {
    00182                         --idx;
    00183                         tmpbuf[idx] = (c8)('0' + (number % 10));
    00184                         number /= 10;
    00185                 }
    00186
    00187                 *this = &tmpbuf[idx];
    00188         }
    00189
    00190
    00192         template <class B>
    00193         string(const B* const c, u32 length)
    00194         : array(0), allocated(0), used(0)
    00195         {
    00196                 if (!c)
    00197                 {
    00198                         // correctly init the string to an empty one
    00199                         *this="";
    00200                         return;
    00201                 }
    00202
    00203                 allocated = used = length+1;
    00204                 array = allocator.allocate(used); // new T[used];
    00205
    00206                 for (u32 l = 0; l<length; ++l)
    00207                         array[l] = (T)c[l];
    00208
    00209                 array[length] = 0;
    00210         }
    00211
    00212
    00214         template <class B>
    00215         string(const B* const c)
    00216         : array(0), allocated(0), used(0)
    00217         {
    00218                 *this = c;
    00219         }
    00220
    00221
    00223         ~string()
    00224         {
    00225                 allocator.deallocate(array); // delete [] array;
    00226         }
    00227
    00228
    00230         string<T,TAlloc>& operator=(const string<T,TAlloc>& other)
    00231         {
    00232                 if (this == &other)
    00233                         return *this;
    00234
    00235                 used = other.size()+1;
    00236                 if (used>allocated)
    00237                 {
    00238                         allocator.deallocate(array); // delete [] array;
    00239                         allocated = used;
    00240                         array = allocator.allocate(used); //new T[used];
    00241                 }
    00242
    00243                 const T* p = other.c_str();
    00244                 for (u32 i=0; i<used; ++i, ++p)
    00245                         array[i] = *p;
    00246
    00247                 return *this;
    00248         }
    00249
    00251         template <class B, class A>
    00252         string<T,TAlloc>& operator=(const string<B,A>& other)
    00253         {
    00254                 *this = other.c_str();
    00255                 return *this;
    00256         }
    00257
    00258
    00260         template <class B>
    00261         string<T,TAlloc>& operator=(const B* const c)
    00262         {
    00263                 if (!c)
    00264                 {
    00265                         if (!array)
    00266                         {
    00267                                 array = allocator.allocate(1); //new T[1];
    00268                                 allocated = 1;
    00269                         }
    00270                         used = 1;
    00271                         array[0] = 0x0;
    00272                         return *this;
    00273                 }
    00274
    00275                 if ((void*)c == (void*)array)
    00276                         return *this;
    00277
    00278                 u32 len = 0;
    00279                 const B* p = c;
    00280                 do
    00281                 {
    00282                         ++len;
    00283                 } while(*p++);
    00284
    00285                 // we'll keep the old string for a while, because the new
    00286                 // string could be a part of the current string.
    00287                 T* oldArray = array;
    00288
    00289                 used = len;
    00290                 if (used>allocated)
    00291                 {
    00292                         allocated = used;
    00293                         array = allocator.allocate(used); //new T[used];
    00294                 }
    00295
    00296                 for (u32 l = 0; l<len; ++l)
    00297                         array[l] = (T)c[l];
    00298
    00299                 if (oldArray != array)
    00300                         allocator.deallocate(oldArray); // delete [] oldArray;
    00301
    00302                 return *this;
    00303         }
    00304
    00305
    00307         string<T,TAlloc> operator+(const string<T,TAlloc>& other) const
    00308         {
    00309                 string<T,TAlloc> str(*this);
    00310                 str.append(other);
    00311
    00312                 return str;
    00313         }
    00314
    00315
    00317         template <class B>
    00318         string<T,TAlloc> operator+(const B* const c) const
    00319         {
    00320                 string<T,TAlloc> str(*this);
    00321                 str.append(c);
    00322
    00323                 return str;
    00324         }
    00325
    00326
    00328         T& operator [](const u32 index)
    00329         {
    00330                 _IRR_DEBUG_BREAK_IF(index>=used) // bad index
    00331                 return array[index];
    00332         }
    00333
    00334
    00336         const T& operator [](const u32 index) const
    00337         {
    00338                 _IRR_DEBUG_BREAK_IF(index>=used) // bad index
    00339                 return array[index];
    00340         }
    00341
    00342
    00344         bool operator ==(const T* const str) const
    00345         {
    00346                 if (!str)
    00347                         return false;
    00348
    00349                 u32 i;
    00350                 for(i=0; array[i] && str[i]; ++i)
    00351                         if (array[i] != str[i])
    00352                                 return false;
    00353
    00354                 return !array[i] && !str[i];
    00355         }
    00356
    00357
    00359         bool operator ==(const string<T,TAlloc>& other) const
    00360         {
    00361                 for(u32 i=0; array[i] && other.array[i]; ++i)
    00362                         if (array[i] != other.array[i])
    00363                                 return false;
    00364
    00365                 return used == other.used;
    00366         }
    00367
    00368
    00370         bool operator <(const string<T,TAlloc>& other) const
    00371         {
    00372                 for(u32 i=0; array[i] && other.array[i]; ++i)
    00373                 {
    00374                         s32 diff = array[i] - other.array[i];
    00375                         if ( diff )
    00376                                 return diff < 0;
    00377                 }
    00378
    00379                 return used < other.used;
    00380         }
    00381
    00382
    00384         bool operator !=(const T* const str) const
    00385         {
    00386                 return !(*this == str);
    00387         }
    00388
    00389
    00391         bool operator !=(const string<T,TAlloc>& other) const
    00392         {
    00393                 return !(*this == other);
    00394         }
    00395
    00396
    00398
    00400         u32 size() const
    00401         {
    00402                 return used-1;
    00403         }
    00404
    00405
    00407
    00408         const T* c_str() const
    00409         {
    00410                 return array;
    00411         }
    00412
    00413
    00415         void make_lower()
    00416         {
    00417                 for (u32 i=0; i<used; ++i)
    00418                         array[i] = locale_lower ( array[i] );
    00419         }
    00420
    00421
    00423         void make_upper()
    00424         {
    00425                 for (u32 i=0; i<used; ++i)
    00426                         array[i] = locale_upper ( array[i] );
    00427         }
    00428
    00429
    00431
    00433         bool equals_ignore_case(const string<T,TAlloc>& other) const
    00434         {
    00435                 for(u32 i=0; array[i] && other[i]; ++i)
    00436                         if (locale_lower( array[i]) != locale_lower(other[i]))
    00437                                 return false;
    00438
    00439                 return used == other.used;
    00440         }
    00441
    00443
    00446         bool equals_substring_ignore_case(const string<T,TAlloc>&other, const s32 sourcePos = 0 ) const
    00447         {
    00448                 if ( (u32) sourcePos > used )
    00449                         return false;
    00450
    00451                 u32 i;
    00452                 for( i=0; array[sourcePos + i] && other[i]; ++i)
    00453                         if (locale_lower( array[sourcePos + i]) != locale_lower(other[i]))
    00454                                 return false;
    00455
    00456                 return array[sourcePos + i] == 0 && other[i] == 0;
    00457         }
    00458
    00459
    00461
    00463         bool lower_ignore_case(const string<T,TAlloc>& other) const
    00464         {
    00465                 for(u32 i=0; array[i] && other.array[i]; ++i)
    00466                 {
    00467                         s32 diff = (s32) locale_lower ( array[i] ) - (s32) locale_lower ( other.array[i] );
    00468                         if ( diff )
    00469                                 return diff < 0;
    00470                 }
    00471
    00472                 return used < other.used;
    00473         }
    00474
    00475
    00477
    00480         bool equalsn(const string<T,TAlloc>& other, u32 n) const
    00481         {
    00482                 u32 i;
    00483                 for(i=0; array[i] && other[i] && i < n; ++i)
    00484                         if (array[i] != other[i])
    00485                                 return false;
    00486
    00487                 // if one (or both) of the strings was smaller then they
    00488                 // are only equal if they have the same length
    00489                 return (i == n) || (used == other.used);
    00490         }
    00491
    00492
    00494
    00497         bool equalsn(const T* const str, u32 n) const
    00498         {
    00499                 if (!str)
    00500                         return false;
    00501                 u32 i;
    00502                 for(i=0; array[i] && str[i] && i < n; ++i)
    00503                         if (array[i] != str[i])
    00504                                 return false;
    00505
    00506                 // if one (or both) of the strings was smaller then they
    00507                 // are only equal if they have the same length
    00508                 return (i == n) || (array[i] == 0 && str[i] == 0);
    00509         }
    00510
    00511
    00513
    00514         void append(T character)
    00515         {
    00516                 if (used + 1 > allocated)
    00517                         reallocate(used + 1);
    00518
    00519                 ++used;
    00520
    00521                 array[used-2] = character;
    00522                 array[used-1] = 0;
    00523         }
    00524
    00525
    00527
    00528         void append(const T* const other)
    00529         {
    00530                 if (!other)
    00531                         return;
    00532
    00533                 u32 len = 0;
    00534                 const T* p = other;
    00535                 while(*p)
    00536                 {
    00537                         ++len;
    00538                         ++p;
    00539                 }
    00540
    00541                 if (used + len > allocated)
    00542                         reallocate(used + len);
    00543
    00544                 --used;
    00545                 ++len;
    00546
    00547                 for (u32 l=0; l<len; ++l)
    00548                         array[l+used] = *(other+l);
    00549
    00550                 used += len;
    00551         }
    00552
    00553
    00555
    00556         void append(const string<T,TAlloc>& other)
    00557         {
    00558                 --used;
    00559                 u32 len = other.size()+1;
    00560
    00561                 if (used + len > allocated)
    00562                         reallocate(used + len);
    00563
    00564                 for (u32 l=0; l<len; ++l)
    00565                         array[used+l] = other[l];
    00566
    00567                 used += len;
    00568         }
    00569
    00570
    00572
    00574         void append(const string<T,TAlloc>& other, u32 length)
    00575         {
    00576                 if (other.size() < length)
    00577                 {
    00578                         append(other);
    00579                         return;
    00580                 }
    00581
    00582                 if (used + length > allocated)
    00583                         reallocate(used + length);
    00584
    00585                 --used;
    00586
    00587                 for (u32 l=0; l<length; ++l)
    00588                         array[l+used] = other[l];
    00589                 used += length;
    00590
    00591                 // ensure proper termination
    00592                 array[used]=0;
    00593                 ++used;
    00594         }
    00595
    00596
    00598
    00599         void reserve(u32 count)
    00600         {
    00601                 if (count < allocated)
    00602                         return;
    00603
    00604                 reallocate(count);
    00605         }
    00606
    00607
    00609
    00612         s32 findFirst(T c) const
    00613         {
    00614                 for (u32 i=0; i<used; ++i)
    00615                         if (array[i] == c)
    00616                                 return i;
    00617
    00618                 return -1;
    00619         }
    00620
    00622
    00628         s32 findFirstChar(const T* const c, u32 count) const
    00629         {
    00630                 if (!c)
    00631                         return -1;
    00632
    00633                 for (u32 i=0; i<used; ++i)
    00634                         for (u32 j=0; j<count; ++j)
    00635                                 if (array[i] == c[j])
    00636                                         return i;
    00637
    00638                 return -1;
    00639         }
    00640
    00641
    00643
    00649         template <class B>
    00650         s32 findFirstCharNotInList(const B* const c, u32 count) const
    00651         {
    00652                 for (u32 i=0; i<used-1; ++i)
    00653                 {
    00654                         u32 j;
    00655                         for (j=0; j<count; ++j)
    00656                                 if (array[i] == c[j])
    00657                                         break;
    00658
    00659                         if (j==count)
    00660                                 return i;
    00661                 }
    00662
    00663                 return -1;
    00664         }
    00665
    00667
    00673         template <class B>
    00674         s32 findLastCharNotInList(const B* const c, u32 count) const
    00675         {
    00676                 for (s32 i=(s32)(used-2); i>=0; --i)
    00677                 {
    00678                         u32 j;
    00679                         for (j=0; j<count; ++j)
    00680                                 if (array[i] == c[j])
    00681                                         break;
    00682
    00683                         if (j==count)
    00684                                 return i;
    00685                 }
    00686
    00687                 return -1;
    00688         }
    00689
    00691
    00695         s32 findNext(T c, u32 startPos) const
    00696         {
    00697                 for (u32 i=startPos; i<used; ++i)
    00698                         if (array[i] == c)
    00699                                 return i;
    00700
    00701                 return -1;
    00702         }
    00703
    00704
    00706
    00710         s32 findLast(T c, s32 start = -1) const
    00711         {
    00712                 start = core::clamp ( start < 0 ? (s32)(used) - 1 : start, 0, (s32)(used) - 1 );
    00713                 for (s32 i=start; i>=0; --i)
    00714                         if (array[i] == c)
    00715                                 return i;
    00716
    00717                 return -1;
    00718         }
    00719
    00721
    00727         s32 findLastChar(const T* const c, u32 count) const
    00728         {
    00729                 if (!c)
    00730                         return -1;
    00731
    00732                 for (s32 i=used-1; i>=0; --i)
    00733                         for (u32 j=0; j<count; ++j)
    00734                                 if (array[i] == c[j])
    00735                                         return i;
    00736
    00737                 return -1;
    00738         }
    00739
    00740
    00742
    00746         template <class B>
    00747         s32 find(const B* const str, const u32 start = 0) const
    00748         {
    00749                 if (str && *str)
    00750                 {
    00751                         u32 len = 0;
    00752
    00753                         while (str[len])
    00754                                 ++len;
    00755
    00756                         if (len > used-1)
    00757                                 return -1;
    00758
    00759                         for (u32 i=start; i<used-len; ++i)
    00760                         {
    00761                                 u32 j=0;
    00762
    00763                                 while(str[j] && array[i+j] == str[j])
    00764                                         ++j;
    00765
    00766                                 if (!str[j])
    00767                                         return i;
    00768                         }
    00769                 }
    00770
    00771                 return -1;
    00772         }
    00773
    00774
    00776
    00778         string<T,TAlloc> subString(u32 begin, s32 length) const
    00779         {
    00780                 // if start after string
    00781                 // or no proper substring length
    00782                 if ((length <= 0) || (begin>=size()))
    00783                         return string<T,TAlloc>("");
    00784                 // clamp length to maximal value
    00785                 if ((length+begin) > size())
    00786                         length = size()-begin;
    00787
    00788                 string<T,TAlloc> o;
    00789                 o.reserve(length+1);
    00790
    00791                 for (s32 i=0; i<length; ++i)
    00792                         o.array[i] = array[i+begin];
    00793
    00794                 o.array[length] = 0;
    00795                 o.used = o.allocated;
    00796
    00797                 return o;
    00798         }
    00799
    00800
    00802
    00803         string<T,TAlloc>& operator += (T c)
    00804         {
    00805                 append(c);
    00806                 return *this;
    00807         }
    00808
    00809
    00811
    00812         string<T,TAlloc>& operator += (const T* const c)
    00813         {
    00814                 append(c);
    00815                 return *this;
    00816         }
    00817
    00818
    00820
    00821         string<T,TAlloc>& operator += (const string<T,TAlloc>& other)
    00822         {
    00823                 append(other);
    00824                 return *this;
    00825         }
    00826
    00827
    00829
    00830         string<T,TAlloc>& operator += (const int i)
    00831         {
    00832                 append(string<T,TAlloc>(i));
    00833                 return *this;
    00834         }
    00835
    00836
    00838
    00839         string<T,TAlloc>& operator += (const unsigned int i)
    00840         {
    00841                 append(string<T,TAlloc>(i));
    00842                 return *this;
    00843         }
    00844
    00845
    00847
    00848         string<T,TAlloc>& operator += (const long i)
    00849         {
    00850                 append(string<T,TAlloc>(i));
    00851                 return *this;
    00852         }
    00853
    00854
    00856
    00857         string<T,TAlloc>& operator += (const unsigned long& i)
    00858         {
    00859                 append(string<T,TAlloc>(i));
    00860                 return *this;
    00861         }
    00862
    00863
    00865
    00866         string<T,TAlloc>& operator += (const double i)
    00867         {
    00868                 append(string<T,TAlloc>(i));
    00869                 return *this;
    00870         }
    00871
    00872
    00874
    00875         string<T,TAlloc>& operator += (const float i)
    00876         {
    00877                 append(string<T,TAlloc>(i));
    00878                 return *this;
    00879         }
    00880
    00881
    00883
    00885         void replace(T toReplace, T replaceWith)
    00886         {
    00887                 for (u32 i=0; i<used; ++i)
    00888                         if (array[i] == toReplace)
    00889                                 array[i] = replaceWith;
    00890         }
    00891
    00892
    00894
    00895         void remove(T c)
    00896         {
    00897                 u32 pos = 0;
    00898                 u32 found = 0;
    00899                 for (u32 i=0; i<used; ++i)
    00900                 {
    00901                         if (array[i] == c)
    00902                         {
    00903                                 ++found;
    00904                                 continue;
    00905                         }
    00906
    00907                         array[pos++] = array[i];
    00908                 }
    00909                 used -= found;
    00910                 array[used] = 0;
    00911         }
    00912
    00913
    00915
    00916         void remove(const string<T,TAlloc> toRemove)
    00917         {
    00918                 u32 size = toRemove.size();
    00919                 if ( size == 0 )
    00920                         return;
    00921                 u32 pos = 0;
    00922                 u32 found = 0;
    00923                 for (u32 i=0; i<used; ++i)
    00924                 {
    00925                         u32 j = 0;
    00926                         while (j < size)
    00927                         {
    00928                                 if (array[i + j] != toRemove[j])
    00929                                         break;
    00930                                 ++j;
    00931                         }
    00932                         if (j == size)
    00933                         {
    00934                                 found += size;
    00935                                 i += size - 1;
    00936                                 continue;
    00937                         }
    00938
    00939                         array[pos++] = array[i];
    00940                 }
    00941                 used -= found;
    00942                 array[used] = 0;
    00943         }
    00944
    00945
    00947
    00948         void removeChars(const string<T,TAlloc> & characters)
    00949         {
    00950                 u32 pos = 0;
    00951                 u32 found = 0;
    00952                 for (u32 i=0; i<used; ++i)
    00953                 {
    00954                         // Don't use characters.findFirst as it finds the \0,
    00955                         // causing used to become incorrect.
    00956                         bool docontinue = false;
    00957                         for (u32 j=0; j<characters.size(); ++j)
    00958                         {
    00959                                 if (characters[j] == array[i])
    00960                                 {
    00961                                         ++found;
    00962                                         docontinue = true;
    00963                                         break;
    00964                                 }
    00965                         }
    00966                         if (docontinue)
    00967                                 continue;
    00968
    00969                         array[pos++] = array[i];
    00970                 }
    00971                 used -= found;
    00972                 array[used] = 0;
    00973         }
    00974
    00975
    00977
    00979         string<T,TAlloc>& trim(const string<T,TAlloc> & whitespace = " \t\n\r")
    00980         {
    00981                 // find start and end of the substring without the specified characters
    00982                 const s32 begin = findFirstCharNotInList(whitespace.c_str(), whitespace.used);
    00983                 if (begin == -1)
    00984                         return (*this="");
    00985
    00986                 const s32 end = findLastCharNotInList(whitespace.c_str(), whitespace.used);
    00987
    00988                 return (*this = subString(begin, (end +1) - begin));
    00989         }
    00990
    00991
    00993
    00996         void erase(u32 index)
    00997         {
    00998                 _IRR_DEBUG_BREAK_IF(index>=used) // access violation
    00999
    01000                 for (u32 i=index+1; i<used; ++i)
    01001                         array[i-1] = array[i];
    01002
    01003                 --used;
    01004         }
    01005
    01007         void validate()
    01008         {
    01009                 // terminate on existing null
    01010                 for (u32 i=0; i<allocated; ++i)
    01011                 {
    01012                         if (array[i] == 0)
    01013                         {
    01014                                 used = i + 1;
    01015                                 return;
    01016                         }
    01017                 }
    01018
    01019                 // terminate
    01020                 if ( allocated > 0 )
    01021                 {
    01022                         used = allocated - 1;
    01023                         array[used] = 0;
    01024                 }
    01025                 else
    01026                 {
    01027                         used = 0;
    01028                 }
    01029         }
    01030
    01032         T lastChar() const
    01033         {
    01034                 return used > 1 ? array[used-2] : 0;
    01035         }
    01036
    01038
    01055         template<class container>
    01056         u32 split(container& ret, const T* const c, u32 count=1, bool ignoreEmptyTokens=true, bool keepSeparators=false) const
    01057         {
    01058                 if (!c)
    01059                         return 0;
    01060
    01061                 const u32 oldSize=ret.size();
    01062                 u32 lastpos = 0;
    01063                 bool lastWasSeparator = false;
    01064                 for (u32 i=0; i<used; ++i)
    01065                 {
    01066                         bool foundSeparator = false;
    01067                         for (u32 j=0; j<count; ++j)
    01068                         {
    01069                                 if (array[i] == c[j])
    01070                                 {
    01071                                         if ((!ignoreEmptyTokens || i - lastpos != 0) &&
    01072                                                         !lastWasSeparator)
    01073                                                 ret.push_back(string<T,TAlloc>(&array[lastpos], i - lastpos));
    01074                                         foundSeparator = true;
    01075                                         lastpos = (keepSeparators ? i : i + 1);
    01076                                         break;
    01077                                 }
    01078                         }
    01079                         lastWasSeparator = foundSeparator;
    01080                 }
    01081                 if ((used - 1) > lastpos)
    01082                         ret.push_back(string<T,TAlloc>(&array[lastpos], (used - 1) - lastpos));
    01083                 return ret.size()-oldSize;
    01084         }
    01085
    01086 private:
    01087
    01089         void reallocate(u32 new_size)
    01090         {
    01091                 T* old_array = array;
    01092
    01093                 array = allocator.allocate(new_size); //new T[new_size];
    01094                 allocated = new_size;
    01095
    01096                 u32 amount = used < new_size ? used : new_size;
    01097                 for (u32 i=0; i<amount; ++i)
    01098                         array[i] = old_array[i];
    01099
    01100                 if (allocated < used)
    01101                         used = allocated;
    01102
    01103                 allocator.deallocate(old_array); // delete [] old_array;
    01104         }
    01105
    01106         //--- member variables
    01107
    01108         T* array;
    01109         u32 allocated;
    01110         u32 used;
    01111         TAlloc allocator;
    01112 };
    01113
    01114
    01116 typedef string<c8> stringc;
    01117
    01119 typedef string<wchar_t> stringw;
    01120
    01121
    01122 } // end namespace core
    01123 } // end namespace irr
    01124
    01125 #endif
    01126

| The Irrlicht Engine Documentation © 2003-2010 by Nikolaus Gebhardt. Generated on Sun Feb 14 13:06:57 2010 by Doxygen (1.6.2)