- Main Page
- Namespaces
- Classes
- Files

- File List
- File Members

# D:/Programmation/Sources/Tensor2/Utils/src/frost_utils_str_impl.cpp

Go to the documentation of this file.

    00001 #include "frost_utils_types.h"
    00002
    00003 #include <algorithm>
    00004 #include <sstream>
    00005
    00006 namespace Frost {
    00007
    00008 typedef std::stringstream string_stream;
    00009
    00010 template <class T>
    00011 s_str_t<T>::s_str_t()
    00012 {
    00013 }
    00014
    00015 template <class T>
    00016 s_str_t<T>::s_str_t(const s_str_t& s)
    00017 {
    00018     sValue_ = s.sValue_;
    00019 }
    00020
    00021 template <class T>
    00022 s_str_t<T>::s_str_t(const string& s)
    00023 {
    00024     sValue_ = s;
    00025 }
    00026
    00027 template <class T>
    00028 s_str_t<T>::s_str_t(const character* s)
    00029 {
    00030     sValue_ = s;
    00031 }
    00032
    00033 template <class T>
    00034 s_str_t<T>::s_str_t(character* s)
    00035 {
    00036     sValue_ = s;
    00037 }
    00038
    00039 template <class T>
    00040 s_str_t<T>::s_str_t(const character& c)
    00041 {
    00042     sValue_.push_back(c);
    00043 }
    00044
    00045 template <class T>
    00046 s_str_t<T>::s_str_t(const frost_character& c)
    00047 {
    00048     sValue_.push_back(c.Get());
    00049 }
    00050
    00051 template <class T>
    00052 s_str_t<T>::s_str_t(const s_str_t& s, const s_uint_t<default_uint>& uiNbr)
    00053 {
    00054     if (uiNbr.IsValid())
    00055     {
    00056         for (default_uint uiCounter = 0; uiCounter < uiNbr.Get(); ++uiCounter)
    00057             sValue_ += s.Get();
    00058     }
    00059 }
    00060
    00061 template <class T>
    00062 s_str_t<T>::s_str_t(const character& c, const s_uint_t<default_uint>& uiNbr)
    00063 {
    00064     if (uiNbr.IsValid())
    00065         sValue_ = string(uiNbr.Get(), c);
    00066 }
    00067
    00068 template <class T>
    00069 s_str_t<T>::s_str_t(const frost_character& c, const s_uint_t<default_uint>& uiNbr)
    00070 {
    00071     if (uiNbr.IsValid())
    00072         sValue_ = string(uiNbr.Get(), c.Get());
    00073 }
    00074
    00075 template <class T>
    00076 void s_str_t<T>::CapitalStart(const s_bool& bCapitalStart)
    00077 {
    00078     T cFirst = (*this)[0];
    00079     if (bCapitalStart)
    00080         (*this)[0] = toupper(cFirst);
    00081     else
    00082         (*this)[0] = tolower(cFirst);
    00083 }
    00084
    00085 template <class T>
    00086 void s_str_t<T>::Clear()
    00087 {
    00088     sValue_.clear();
    00089 }
    00090
    00091 template <class T>
    00092 s_ctnr< s_str_t<T> > s_str_t<T>::Cut(const s_str_t& sDelim) const
    00093 {
    00094     s_ctnr<s_str_t> lPieces;
    00095     s_uint_t<default_uint> uiPos = FindPos(sDelim);
    00096     s_uint_t<default_uint> uiLastPos;
    00097     s_uint_t<default_uint> uiCount;
    00098     s_uint_t<default_uint> uiCurSize;
    00099     while (uiPos.IsValid())
    00100     {
    00101         uiCurSize = uiPos - uiLastPos;
    00102         if (!uiCurSize.IsNull())
    00103             lPieces.PushBack(Extract(uiLastPos, uiCurSize));
    00104         uiLastPos = uiPos + sDelim.GetLength();
    00105         uiPos = FindPos(sDelim, uiLastPos);
    00106         ++uiCount;
    00107     }
    00108
    00109     lPieces.PushBack(Extract(uiLastPos));
    00110
    00111     return lPieces;
    00112 }
    00113
    00114 template <class T>
    00115 s_ctnr< s_str_t<T> > s_str_t<T>::Cut(const s_str_t& sDelim, const s_uint_t<default_uint>& uiMaxCut) const
    00116 {
    00117     s_ctnr<s_str_t> lPieces;
    00118     s_uint_t<default_uint> uiPos = FindPos(sDelim);
    00119     s_uint_t<default_uint> uiLastPos;
    00120     s_uint_t<default_uint> uiCount;
    00121     s_uint_t<default_uint> uiCurSize;
    00122     while (uiPos.IsValid())
    00123     {
    00124         uiCurSize = uiPos - uiLastPos;
    00125         if (!uiCurSize.IsNull())
    00126             lPieces.PushBack(Extract(uiLastPos, uiCurSize));
    00127         uiLastPos = uiPos + sDelim.GetLength();
    00128         uiPos = FindPos(sDelim, uiLastPos);
    00129         ++uiCount;
    00130
    00131         if (uiCount >= uiMaxCut)
    00132             break;
    00133     }
    00134
    00135     lPieces.PushBack(Extract(uiLastPos));
    00136
    00137     return lPieces;
    00138 }
    00139
    00140 template <class T>
    00141 s_ctnr< s_str_t<T> > s_str_t<T>::CutEach(const s_str_t& sDelim) const
    00142 {
    00143     s_ctnr<s_str_t> lPieces;
    00144     s_uint_t<default_uint> uiPos = FindPos(sDelim);
    00145     s_uint_t<default_uint> uiLastPos;
    00146     s_uint_t<default_uint> uiCount;
    00147     s_uint_t<default_uint> uiCurSize;
    00148     while (uiPos.IsValid())
    00149     {
    00150         uiCurSize = uiPos - uiLastPos;
    00151         lPieces.PushBack(Extract(uiLastPos, uiCurSize));
    00152         uiLastPos = uiPos + sDelim.GetLength();
    00153         uiPos = FindPos(sDelim, uiLastPos);
    00154         ++uiCount;
    00155     }
    00156
    00157     lPieces.PushBack(Extract(uiLastPos));
    00158
    00159     return lPieces;
    00160 }
    00161
    00162 template <class T>
    00163 s_ctnr< s_str_t<T> > s_str_t<T>::CutEach(const s_str_t& sDelim, const s_uint_t<default_uint>& uiMaxCut) const
    00164 {
    00165     s_ctnr<s_str_t> lPieces;
    00166     s_uint_t<default_uint> uiPos = FindPos(sDelim);
    00167     s_uint_t<default_uint> uiLastPos;
    00168     s_uint_t<default_uint> uiCount;
    00169     s_uint_t<default_uint> uiCurSize;
    00170     while (uiPos.IsValid())
    00171     {
    00172         uiCurSize = uiPos - uiLastPos;
    00173         lPieces.PushBack(Extract(uiLastPos, uiCurSize));
    00174         uiLastPos = uiPos + sDelim.GetLength();
    00175         uiPos = FindPos(sDelim, uiLastPos);
    00176         ++uiCount;
    00177
    00178         if (uiCount >= uiMaxCut)
    00179             break;
    00180     }
    00181
    00182     lPieces.PushBack(Extract(uiLastPos));
    00183
    00184     return lPieces;
    00185 }
    00186
    00187 template <class T>
    00188 s_ctnr< s_str_t<T> > s_str_t<T>::Cut(const s_ctnr<character>& lDelims) const
    00189 {
    00190     s_ctnr<s_str_t> lPieces;
    00191
    00192     string sTemp;
    00193     const_iterator iter;
    00194     for (iter = sValue_.begin(); iter != sValue_.end(); ++iter)
    00195     {
    00196         if (lDelims.Find(*iter))
    00197         {
    00198             if (!sTemp.empty())
    00199             {
    00200                 lPieces.PushBack(sTemp);
    00201                 sTemp.clear();
    00202             }
    00203         }
    00204         else
    00205             sTemp.push_back(*iter);
    00206     }
    00207
    00208     if (!sTemp.empty())
    00209         lPieces.PushBack(sTemp);
    00210
    00211     return lPieces;
    00212 }
    00213
    00214 template <class T>
    00215 s_uint_t<default_uint> s_str_t<T>::CountOccurences(const s_str_t& sPattern) const
    00216 {
    00217     s_uint_t<default_uint> uiCount;
    00218     s_uint_t<default_uint> uiPos = FindPos(sPattern);
    00219     while (uiPos.IsValid())
    00220     {
    00221         ++uiCount;
    00222         ++uiPos;
    00223         uiPos = FindPos(sPattern, uiPos);
    00224     }
    00225
    00226     return uiCount;
    00227 }
    00228
    00229 template <class T>
    00230 void s_str_t<T>::Erase(const s_uint_t<default_uint>& uiStart, const s_uint_t<default_uint>& uiNbr)
    00231 {
    00232     if (uiStart.IsValid())
    00233     {
    00234         if (!uiNbr.IsValid())
    00235             sValue_.erase(uiStart.Get(), string::npos);
    00236         else
    00237             sValue_.erase(uiStart.Get(), uiNbr.Get());
    00238     }
    00239 }
    00240
    00241 template <class T>
    00242 void s_str_t<T>::Erase(const s_uint_t<default_uint>& uiPos)
    00243 {
    00244     if (uiPos.IsValid())
    00245         sValue_.erase(uiPos.Get(), 1);
    00246 }
    00247
    00248 template <class T>
    00249 typename s_str_t<T>::iterator s_str_t<T>::Erase(iterator iter)
    00250 {
    00251     return sValue_.erase(iter);
    00252 }
    00253
    00254 template <class T>
    00255 void s_str_t<T>::EraseFromEnd(const s_uint_t<default_uint>& uiNbr)
    00256 {
    00257     if (uiNbr.IsValid())
    00258         sValue_.erase((GetLength() - uiNbr).Get(), uiNbr.Get());
    00259     else
    00260         sValue_.clear();
    00261 }
    00262
    00263 template <class T>
    00264 void s_str_t<T>::EraseFromStart(const s_uint_t<default_uint>& uiNbr)
    00265 {
    00266     if (uiNbr.IsValid())
    00267         sValue_.erase(0, uiNbr.Get());
    00268     else
    00269         sValue_.clear();
    00270 }
    00271
    00272 template <class T>
    00273 void s_str_t<T>::EraseRange(const s_uint_t<default_uint>& uiStart, const s_uint_t<default_uint>& uiEnd)
    00274 {
    00275     if (uiStart.IsValid())
    00276     {
    00277         if (!uiEnd.IsValid())
    00278             sValue_.erase(uiStart.Get(), string::npos);
    00279         else
    00280             sValue_.erase(uiStart.Get(), (uiEnd-uiStart).Get());
    00281     }
    00282 }
    00283
    00284 template <class T>
    00285 typename s_str_t<T>::iterator s_str_t<T>::EraseRange(iterator iterStart, iterator iterEnd)
    00286 {
    00287     return sValue_.erase(iterStart, iterEnd);
    00288 }
    00289
    00290 template <class T>
    00291 typename s_str_t<T>::iterator s_str_t<T>::EraseRange(range mRange)
    00292 {
    00293     return sValue_.erase(mRange.Begin(), mRange.End());
    00294 }
    00295
    00296 template <class T>
    00297 s_str_t<T> s_str_t<T>::Extract(const s_uint_t<default_uint>& uiStart, const s_uint_t<default_uint>& uiNbr) const
    00298 {
    00299     if (!uiNbr.IsValid())
    00300         return s_str_t(sValue_.substr(uiStart.Get(), string::npos));
    00301     else
    00302         return s_str_t(sValue_.substr(uiStart.Get(), uiNbr.Get()));
    00303 }
    00304
    00305 template <class T>
    00306 s_str_t<T> s_str_t<T>::ExtractRange(const s_uint_t<default_uint>& uiStart, const s_uint_t<default_uint>& uiEnd) const
    00307 {
    00308     if (!uiEnd.IsValid())
    00309         return s_str_t(sValue_.substr(uiStart.Get(), string::npos));
    00310     else
    00311         return s_str_t(sValue_.substr(uiStart.Get(), (uiEnd-uiStart).Get()));
    00312 }
    00313
    00314 template <class T>
    00315 typename s_str_t<T>::iterator s_str_t<T>::Get(const s_str_t& sValue)
    00316 {
    00317     size_t uiResult = sValue_.find(sValue.Get());
    00318     if (uiResult != sValue_.npos)
    00319         return Begin() + uiResult;
    00320     else
    00321         return End();
    00322 }
    00323
    00324 template <class T>
    00325 typename s_str_t<T>::iterator s_str_t<T>::Get(const s_str_t& sValue, const s_uint_t<default_uint>& uiStart)
    00326 {
    00327     if (uiStart.IsValid())
    00328     {
    00329         size_t uiResult = sValue_.find(sValue.Get(), uiStart.Get());
    00330         if (uiResult != sValue_.npos)
    00331             return Begin() + uiResult;
    00332     }
    00333
    00334     return End();
    00335 }
    00336
    00337 template <class T>
    00338 typename s_str_t<T>::const_iterator s_str_t<T>::Get(const s_str_t& sValue) const
    00339 {
    00340     size_t uiResult = sValue_.find(sValue.Get());
    00341     if (uiResult != sValue_.npos)
    00342         return Begin() + uiResult;
    00343     else
    00344         return End();
    00345 }
    00346
    00347 template <class T>
    00348 typename s_str_t<T>::const_iterator s_str_t<T>::Get(const s_str_t& sValue, const s_uint_t<default_uint>& uiStart) const
    00349 {
    00350     if (uiStart.IsValid())
    00351     {
    00352         size_t uiResult = sValue_.find(sValue.Get(), uiStart.Get());
    00353         if (uiResult != sValue_.npos)
    00354             return Begin() + uiResult;
    00355     }
    00356
    00357     return End();
    00358 }
    00359
    00360 template <class T>
    00361 s_uint_t<default_uint> s_str_t<T>::FindPos(const s_str_t& sValue) const
    00362 {
    00363     size_t uiResult = sValue_.find(sValue.Get());
    00364     if (uiResult != sValue_.npos)
    00365         return uiResult;
    00366     else
    00367         return s_uint_t<default_uint>::NaN;
    00368 }
    00369
    00370 template <class T>
    00371 s_uint_t<default_uint> s_str_t<T>::FindPos(const s_str_t& sValue, const s_uint_t<default_uint>& uiStart) const
    00372 {
    00373     if (uiStart.IsValid())
    00374     {
    00375         size_t uiResult = sValue_.find(sValue.Get(), uiStart.Get());
    00376         if (uiResult != sValue_.npos)
    00377             return uiResult;
    00378     }
    00379
    00380     return s_uint_t<default_uint>::NaN;
    00381 }
    00382
    00383 template <class T>
    00384 s_ctnr< s_uint_t<default_uint> > s_str_t<T>::FindAllPos(const s_str_t& sPattern)
    00385 {
    00386     s_ctnr< s_uint_t<default_uint> > lList;
    00387     s_uint_t<default_uint> ui = FindPos(sPattern);
    00388     while (ui.IsValid())
    00389     {
    00390         lList.PushBack(ui);
    00391         ui = FindPos(sPattern, ui + sPattern.GetSize());
    00392     }
    00393
    00394     return lList;
    00395 }
    00396
    00397 template <class T>
    00398 s_ctnr< s_uint_t<default_uint> > s_str_t<T>::FindAllPos(const s_str_t& sPattern, const s_uint_t<default_uint>& uiStart)
    00399 {
    00400     s_ctnr< s_uint_t<default_uint> > lList;
    00401
    00402     if (uiStart.IsValid())
    00403     {
    00404         s_uint_t<default_uint> ui = FindPos(sPattern, uiStart);
    00405         while (ui.IsValid())
    00406         {
    00407             lList.PushBack(ui);
    00408             ui = FindPos(sPattern, ui + sPattern.GetSize());
    00409         }
    00410     }
    00411
    00412     return lList;
    00413 }
    00414
    00415 template <class T>
    00416 s_bool s_str_t<T>::Find(const s_str_t& sValue) const
    00417 {
    00418     size_t uiResult = sValue_.find(sValue.Get());
    00419     if (uiResult != sValue_.npos)
    00420         return true;
    00421     else
    00422         return false;
    00423 }
    00424
    00425 template <class T>
    00426 s_bool s_str_t<T>::Find(const s_str_t& sValue, const s_uint_t<default_uint>& uiStart) const
    00427 {
    00428     if (uiStart.IsValid())
    00429     {
    00430         size_t uiResult = sValue_.find(sValue.Get(), uiStart.Get());
    00431         if (uiResult != sValue_.npos)
    00432             return true;
    00433     }
    00434
    00435     return false;
    00436 }
    00437
    00438 template <class T>
    00439 s_bool s_str_t<T>::IsEmpty(const s_bool& bIgnoreSpaces) const
    00440 {
    00441     if (sValue_.empty())
    00442     {
    00443         return true;
    00444     }
    00445     else
    00446     {
    00447         if (bIgnoreSpaces)
    00448         {
    00449             s_bool bEmpty = true;
    00450             for (uint i = 0; i < sValue_.length(); ++i)
    00451             {
    00452                 if ( (sValue_[i] != ' ') && (sValue_[i] != '    ') )
    00453                 {
    00454                     bEmpty = false;
    00455                     break;
    00456                 }
    00457             }
    00458
    00459             return bEmpty;
    00460         }
    00461         else
    00462         {
    00463             return false;
    00464         }
    00465     }
    00466 }
    00467
    00468 template <class T>
    00469 s_bool s_str_t<T>::IsNumber() const
    00470 {
    00471     string_stream mTemp(StringConverter<string_element, string>::Convert(sValue_));
    00472     double dValue;
    00473     mTemp >> dValue;
    00474     return !mTemp.fail();
    00475 }
    00476
    00477 template <class T>
    00478 s_bool s_str_t<T>::IsBoolean() const
    00479 {
    00480     return ((*this) == "false") || ((*this) == "true") ||
    00481            ((*this) == "0")     || ((*this) == "1")    ||
    00482            ((*this) == "no")    || ((*this) == "yes");
    00483 }
    00484
    00485 template <class T>
    00486 s_uint_t<default_uint> s_str_t<T>::GetLength() const
    00487 {
    00488     return sValue_.length();
    00489 }
    00490
    00491 template <class T>
    00492 s_uint_t<default_uint> s_str_t<T>::GetSize() const
    00493 {
    00494     return sValue_.size();
    00495 }
    00496
    00497 template <class T>
    00498 void s_str_t<T>::ToLower()
    00499 {
    00500     typename s_str_t<string_element>::string sTemp = StringConverter<string_element, string>::Convert(sValue_);
    00501     std::transform(sTemp.begin(), sTemp.end(), sTemp.begin(), ::tolower);
    00502     sValue_ = StringConverter<character, typename s_str_t<string_element>::string>::Convert(sTemp);
    00503 }
    00504
    00505 template <class T>
    00506 void s_str_t<T>::ToUpper()
    00507 {
    00508     typename s_str_t<string_element>::string sTemp = StringConverter<string_element, string>::Convert(sValue_);
    00509     std::transform(sTemp.begin(), sTemp.end(), sTemp.begin(), ::toupper);
    00510     sValue_ = StringConverter<character, typename s_str_t<string_element>::string>::Convert(sTemp);
    00511 }
    00512
    00513 template <class T>
    00514 s_uint_t<default_uint> s_str_t<T>::Trim(const character& cPattern)
    00515 {
    00516     default_uint uiCount = 0;
    00517
    00518     while (!IsEmpty() && (*this)[0] == cPattern)
    00519     {
    00520         EraseFromStart(1);
    00521         ++uiCount;
    00522     }
    00523
    00524     while (!IsEmpty() && (*this)[GetLength().Get()-1] == cPattern)
    00525     {
    00526         EraseFromEnd(1);
    00527         ++uiCount;
    00528     }
    00529
    00530     return uiCount;
    00531 }
    00532
    00533 template <class T>
    00534 s_uint_t<default_uint> s_str_t<T>::Replace(const s_str_t& sPattern, const s_str_t& sReplacement)
    00535 {
    00536     default_uint uiCount = 0;
    00537     s_uint_t<default_uint> uiPos = FindPos(sPattern);
    00538
    00539     while (uiPos.IsValid())
    00540     {
    00541         sValue_.replace(uiPos.Get(), sPattern.GetLength().Get(), sReplacement.Get());
    00542         uiPos = FindPos(sPattern, uiPos + sReplacement.GetLength());
    00543         ++uiCount;
    00544     }
    00545
    00546     return uiCount;
    00547 }
    00548
    00549 template <class T>
    00550 void s_str_t<T>::PushBack(const character& cChar)
    00551 {
    00552     sValue_.push_back(cChar);
    00553 }
    00554
    00555 template <class T>
    00556 void s_str_t<T>::PushBack(const s_str_t& sValue)
    00557 {
    00558     sValue_.append(sValue.sValue_);
    00559 }
    00560
    00561 template <class T>
    00562 void s_str_t<T>::PopBack()
    00563 {
    00564     if (!sValue_.empty())
    00565         sValue_.erase(sValue_.length()-1, 1);
    00566 }
    00567
    00568 template <class T>
    00569 T& s_str_t<T>::Back()
    00570 {
    00571     return sValue_[sValue_.length()-1];
    00572 }
    00573
    00574 template <class T>
    00575 const T& s_str_t<T>::Back() const
    00576 {
    00577     return sValue_[sValue_.length()-1];
    00578 }
    00579
    00580 template <class T>
    00581 void s_str_t<T>::PushFront(const character& cChar)
    00582 {
    00583     sValue_.insert(0, 1, cChar);
    00584 }
    00585
    00586 template <class T>
    00587 void s_str_t<T>::PushFront(const s_str_t& sValue)
    00588 {
    00589     sValue_.insert(0, sValue.sValue_);
    00590 }
    00591
    00592 template <class T>
    00593 void s_str_t<T>::PopFront()
    00594 {
    00595     if (!sValue_.empty())
    00596         sValue_.erase(0, 1);
    00597 }
    00598
    00599 template <class T>
    00600 T& s_str_t<T>::Front()
    00601 {
    00602     return sValue_[0];
    00603 }
    00604
    00605 template <class T>
    00606 const T& s_str_t<T>::Front() const
    00607 {
    00608     return sValue_[0];
    00609 }
    00610
    00611 template <class T>
    00612 void s_str_t<T>::Insert(const character& cChar, const s_uint_t<default_uint>& uiPos)
    00613 {
    00614     if (uiPos.IsValid())
    00615         sValue_.insert(uiPos.Get(), 1, cChar);
    00616     else
    00617         sValue_.push_back(cChar);
    00618 }
    00619
    00620 template <class T>
    00621 typename s_str_t<T>::iterator s_str_t<T>::Insert(const character& cChar, iterator iter)
    00622 {
    00623     return sValue_.insert(iter, cChar)+1;
    00624 }
    00625
    00626 template <class T>
    00627 void s_str_t<T>::Insert(const s_str_t& sValue, const s_uint_t<default_uint>& uiPos)
    00628 {
    00629     if (uiPos.IsValid())
    00630         sValue_.insert(uiPos.Get(), sValue.sValue_);
    00631     else
    00632         sValue_.append(sValue.sValue_);
    00633 }
    00634
    00635 template <class T>
    00636 typename s_str_t<T>::iterator s_str_t<T>::Insert(const s_str_t& sValue, iterator iter)
    00637 {
    00638     if (iter == sValue_.end())
    00639     {
    00640         sValue_.append(sValue.sValue_);
    00641         return sValue_.end();
    00642     }
    00643     else
    00644     {
    00645         size_t uiPos = iter - sValue_.begin();
    00646         sValue_.insert(uiPos, sValue.sValue_);
    00647         return sValue_.begin() + uiPos + sValue.sValue_.size();
    00648     }
    00649 }
    00650
    00651 template <class T>
    00652 void s_str_t<T>::Reverse()
    00653 {
    00654     std::reverse(sValue_.begin(), sValue_.end());
    00655 }
    00656
    00657 template <class T>
    00658 s_bool s_str_t<T>::StartsWith(const s_str_t& sPattern) const
    00659 {
    00660     if (sPattern.GetSize() <= GetSize())
    00661     {
    00662         const_iterator iterSelf = Begin();
    00663         const_iterator iterPattern;
    00664         for (iterPattern = sPattern.Begin(); iterPattern != sPattern.End(); ++iterPattern)
    00665         {
    00666             if (*iterPattern != *iterSelf)
    00667                 return false;
    00668
    00669             ++iterSelf;
    00670         }
    00671
    00672         return true;
    00673     }
    00674     else
    00675         return false;
    00676 }
    00677
    00678 template <class T>
    00679 s_bool s_str_t<T>::EndsWith(const s_str_t& sPattern) const
    00680 {
    00681     if (sPattern.GetSize() <= GetSize())
    00682     {
    00683         const_iterator iterSelf = End() - sPattern.GetSize().Get();
    00684         const_iterator iterPattern;
    00685         for (iterPattern = sPattern.Begin(); iterPattern != sPattern.End(); ++iterPattern)
    00686         {
    00687             if (*iterPattern != *iterSelf)
    00688                 return false;
    00689
    00690             ++iterSelf;
    00691         }
    00692
    00693         return true;
    00694     }
    00695     else
    00696         return false;
    00697 }
    00698
    00699 template <class T>
    00700 typename s_str_t<T>::iterator s_str_t<T>::begin()
    00701 {
    00702     return sValue_.begin();
    00703 }
    00704
    00705 template <class T>
    00706 typename s_str_t<T>::const_iterator s_str_t<T>::begin() const
    00707 {
    00708     return sValue_.begin();
    00709 }
    00710
    00711 template <class T>
    00712 typename s_str_t<T>::iterator s_str_t<T>::end()
    00713 {
    00714     return sValue_.end();
    00715 }
    00716
    00717 template <class T>
    00718 typename s_str_t<T>::const_iterator s_str_t<T>::end() const
    00719 {
    00720     return sValue_.end();
    00721 }
    00722
    00723 template <class T>
    00724 typename s_str_t<T>::iterator s_str_t<T>::Begin()
    00725 {
    00726     return sValue_.begin();
    00727 }
    00728
    00729 template <class T>
    00730 typename s_str_t<T>::const_iterator s_str_t<T>::Begin() const
    00731 {
    00732     return sValue_.begin();
    00733 }
    00734
    00735 template <class T>
    00736 typename s_str_t<T>::iterator s_str_t<T>::End()
    00737 {
    00738     return sValue_.end();
    00739 }
    00740
    00741 template <class T>
    00742 typename s_str_t<T>::const_iterator s_str_t<T>::End() const
    00743 {
    00744     return sValue_.end();
    00745 }
    00746
    00747 template <class T>
    00748 T& s_str_t<T>::operator [] (const s_uint_t<default_uint>& uiIndex)
    00749 {
    00750     return sValue_[uiIndex.Get()];
    00751 }
    00752
    00753 template <class T>
    00754 const T& s_str_t<T>::operator [] (const s_uint_t<default_uint>& uiIndex) const
    00755 {
    00756     return sValue_[uiIndex.Get()];
    00757 }
    00758
    00759 template <class T>
    00760 T& s_str_t<T>::operator [] (const default_uint& uiIndex)
    00761 {
    00762     return sValue_[uiIndex];
    00763 }
    00764
    00765 template <class T>
    00766 const T& s_str_t<T>::operator [] (const default_uint& uiIndex) const
    00767 {
    00768     return sValue_[uiIndex];
    00769 }
    00770
    00771 template <class T>
    00772 s_bool s_str_t<T>::operator == (const s_str_t& mValue) const
    00773 {
    00774     return (sValue_ == mValue.sValue_);
    00775 }
    00776
    00777 template <class T>
    00778 s_bool s_str_t<T>::operator != (const s_str_t& mValue) const
    00779 {
    00780     return (sValue_ != mValue.sValue_);
    00781 }
    00782
    00783 template <class T>
    00784 s_bool s_str_t<T>::operator < (const s_str_t& mValue) const
    00785 {
    00786     return (sValue_ < mValue.sValue_);
    00787 }
    00788
    00789 template <class T>
    00790 s_bool s_str_t<T>::operator > (const s_str_t& mValue) const
    00791 {
    00792     return (sValue_ > mValue.sValue_);
    00793 }
    00794
    00795 template <class T>
    00796 s_bool s_str_t<T>::operator <= (const s_str_t& mValue) const
    00797 {
    00798     return (sValue_ <= mValue.sValue_);
    00799 }
    00800
    00801 template <class T>
    00802 s_bool s_str_t<T>::operator >= (const s_str_t& mValue) const
    00803 {
    00804     return (sValue_ >= mValue.sValue_);
    00805 }
    00806
    00807 template <class T>
    00808 s_str_t<T> s_str_t<T>::ToLower(const s_str_t& sValue)
    00809 {
    00810     s_str_t sCopy = sValue;
    00811     sCopy.ToLower();
    00812     return sCopy;
    00813 }
    00814
    00815 template <class T>
    00816 s_str_t<T> s_str_t<T>::ToUpper(const s_str_t& sValue)
    00817 {
    00818     s_str_t sCopy = sValue;
    00819     sCopy.ToUpper();
    00820     return sCopy;
    00821 }
    00822
    00823 template <class T>
    00824 s_str_t<T> s_str_t<T>::Reverse(const s_str_t& sValue)
    00825 {
    00826     s_str_t sCopy = sValue;
    00827     sCopy.Reverse();
    00828     return sCopy;
    00829 }
    00830
    00831 template <class T>
    00832 s_bool s_str_t<T>::IsNumber(const character& cValue)
    00833 {
    00834     string_stream mTemp(typename s_str_t<string_element>::string(1, StringConverter<string_element, character>::ConvertChar(cValue)));
    00835     double dValue;
    00836     mTemp >> dValue;
    00837     return !mTemp.fail();
    00838 }
    00839
    00840 template <class T>
    00841 s_bool s_str_t<T>::IsNumber(const frost_character& cValue)
    00842 {
    00843     string_stream mTemp(typename s_str_t<string_element>::string(1, StringConverter<string_element, frost_character>::ConvertChar(cValue).Get()));
    00844     double dValue;
    00845     mTemp >> dValue;
    00846     return !mTemp.fail();
    00847 }
    00848
    00849 template <class T>
    00850 s_bool s_str_t<T>::IsAlphaNumeric(const character& cValue)
    00851 {
    00852     return isalnum(StringConverter<string_element, character>::ConvertChar(cValue));
    00853 }
    00854
    00855 template <class T>
    00856 s_bool s_str_t<T>::IsAlphaNumeric(const frost_character& cValue)
    00857 {
    00858     return isalnum(StringConverter<string_element, frost_character>::ConvertChar(cValue).Get());
    00859 }
    00860
    00861 template<class T>
    00862 const s_str_t<T> s_str_t<T>::EMPTY = "";
    00863
    00864 template<class T>
    00865 s_str_t<T> operator + (const T* sLeft, const s_str_t<T>& sRight)
    00866 {
    00867     return s_str_t<T>(sLeft) + sRight;
    00868 }
    00869
    00870 template<class T>
    00871 s_str_t<T> operator + (const std::basic_string<T> sLeft, const s_str_t<T>& sRight)
    00872 {
    00873     return s_str_t<T>(sLeft) + sRight;
    00874 }
    00875
    00876 template class s_str_t<string_element>;
    00877 template class s_str_t<uint>;
    00878
    00879 typedef s_str_t<string_element> s_str;
    00880 typedef s_str_t<uint>           s_ustr;
    00881
    00882 template s_str operator + (const string_element* sLeft, const s_str& sRight);
    00883 template s_str operator + (const std::basic_string<string_element> sLeft, const s_str& sRight);
    00884
    00885 template s_ustr operator + (const uint* sLeft, const s_ustr& sRight);
    00886 template s_ustr operator + (const std::basic_string<uint> sLeft, const s_ustr& sRight);
    00887
    00888 }