(file) Return to String.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/String.cpp between version 1.41 and 1.67

version 1.41, 2002/06/01 00:56:38 version 1.67, 2003/04/07 17:50:51
Line 29 
Line 29 
  
  
 #include <cctype> #include <cctype>
   #include <cstring>
 #include "String.h" #include "String.h"
 #include "Exception.h"  #include "Array.h"
   #include "InternalException.h"
 #include <iostream> #include <iostream>
   #include <fstream>
   #ifndef PEGASUS_REMOVE_DEPRECATED
   #include "System.h"  // for strcasecmp
   #endif
  
 PEGASUS_USING_STD; PEGASUS_USING_STD;
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 #define PEGASUS_ARRAY_T String  ///////////////////////////////////////////////////////////////////////////////
 #include <Pegasus/Common/ArrayImpl.h>  //
 #undef PEGASUS_ARRAY_T  // CString
   //
   ///////////////////////////////////////////////////////////////////////////////
   
   CString::CString()
       : _rep(0)
   {
   }
   
   CString::CString(const CString& cstr)
   {
       _rep = (void*)new char[strlen((char*)cstr._rep)+1];
       strcpy((char*)_rep, (char*)cstr._rep);
   }
   
   CString::CString(char* cstr)
       : _rep(cstr)
   {
   }
   
   CString::~CString()
   {
       if (_rep)
           delete [] (char*)_rep;
   }
   
   CString& CString::operator=(const CString& cstr)
   {
       _rep = (char*)new char[strlen((char*)cstr._rep)+1];
       strcpy((char*)_rep, (char*)cstr._rep);
       return *this;
   }
   
   CString::operator const char*() const
   {
       return (char*)_rep;
   }
  
 /////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
 // //
Line 102 
Line 144 
     return n;     return n;
 } }
  
   class StringRep
   {
   public:
       StringRep()
       {}
       StringRep(const StringRep& r)
           : c16a(r.c16a)
       {}
       StringRep(const Char16* str)
           : c16a(str, _StrLen(str) + 1)
       {}
   
       Array<Char16> c16a;
   };
   
 String::String() String::String()
 { {
     _rep.append('\0');      _rep = new StringRep;
       _rep->c16a.append('\0');
 } }
  
 String::String(const String& str) String::String(const String& str)
     : _rep(str._rep)  
 { {
     if (str._rep != NULL)
     {
       _rep = new StringRep(*str._rep);
 } }
     else
     {
       _rep = new StringRep();
     }
   }
   
  
 String::String(const String& str, Uint32 n) String::String(const String& str, Uint32 n)
 { {
     assign(str.getData(), n);      _rep = new StringRep;
       assign(str.getChar16Data(), n);
 } }
  
 String::String(const Char16* str) String::String(const Char16* str)
     : _rep(str, _StrLen(str) + 1)  
 { {
       _rep = new StringRep(str);
 } }
  
 String::String(const Char16* str, Uint32 n) String::String(const Char16* str, Uint32 n)
 { {
       _rep = new StringRep;
     assign(str, n);     assign(str, n);
 } }
  
 String::String(const char* str) String::String(const char* str)
 { {
       _rep = new StringRep;
     assign(str);     assign(str);
 } }
  
 String::String(const char* str, Uint32 n) String::String(const char* str, Uint32 n)
 { {
       _rep = new StringRep;
     assign(str, n);     assign(str, n);
 } }
  
 String::~String() String::~String()
 { {
       delete _rep;
 } }
  
 String& String::operator=(const String& str) String& String::operator=(const String& str)
Line 146 
Line 217 
     return assign(str);     return assign(str);
 } }
  
 String& String::operator=(const Char16* str)  
 {  
     return assign(str);  
 }  
   
 String& String::assign(const String& str) String& String::assign(const String& str)
 { {
     _rep = str._rep;      _rep->c16a = str._rep->c16a;
     return *this;     return *this;
 } }
  
 String& String::assign(const Char16* str) String& String::assign(const Char16* str)
 { {
     _rep.clear();      _rep->c16a.clear();
     _rep.append(str, _StrLen(str) + 1);      _rep->c16a.append(str, _StrLen(str) + 1);
     return *this;     return *this;
 } }
  
 String& String::assign(const Char16* str, Uint32 n) String& String::assign(const Char16* str, Uint32 n)
 { {
     _rep.clear();      _rep->c16a.clear();
     Uint32 m = _strnlen(str, n);     Uint32 m = _strnlen(str, n);
     _rep.append(str, m);      _rep->c16a.append(str, m);
     _rep.append('\0');      _rep->c16a.append('\0');
     return *this;     return *this;
 } }
  
 String& String::assign(const char* str) String& String::assign(const char* str)
 { {
     _rep.clear();      _rep->c16a.clear();
  
     Uint32 n = strlen(str) + 1;     Uint32 n = strlen(str) + 1;
     _rep.reserve(n);      _rep->c16a.reserveCapacity(n);
  
     while (n--)     while (n--)
         _rep.append(*str++);          _rep->c16a.append(Uint8(*str++));
  
     return *this;     return *this;
 } }
  
 String& String::assign(const char* str, Uint32 n) String& String::assign(const char* str, Uint32 n)
 { {
     _rep.clear();      _rep->c16a.clear();
  
     Uint32 _n = _strnlen(str, n);     Uint32 _n = _strnlen(str, n);
     _rep.reserve(_n + 1);      _rep->c16a.reserveCapacity(_n + 1);
  
     while (_n--)     while (_n--)
         _rep.append(*str++);          _rep->c16a.append(Uint8(*str++));
  
     _rep.append('\0');      _rep->c16a.append('\0');
  
     return *this;     return *this;
 } }
  
 void String::clear() void String::clear()
 { {
     _rep.clear();      _rep->c16a.clear();
     _rep.append('\0');      _rep->c16a.append('\0');
 } }
  
 void String::reserve(Uint32 capacity)  void String::reserveCapacity(Uint32 capacity)
 { {
     _rep.reserve(capacity + 1);      _rep->c16a.reserveCapacity(capacity + 1);
 } }
  
 Uint32 String::size() const Uint32 String::size() const
 { {
     return _rep.size() - 1;      return _rep->c16a.size() - 1;
 } }
  
 const Char16* String::getData() const  const Char16* String::getChar16Data() const
 { {
     return _rep.getData();      return _rep->c16a.getData();
 } }
  
 char* String::allocateCString(Uint32 extraBytes, Boolean noThrow) const  CString String::getCString() const
 { {
     Uint32 n = size() + 1;     Uint32 n = size() + 1;
     char* str = new char[n + extraBytes];      char* str = new char[n];
     char* p = str;     char* p = str;
     const Char16* q = getData();      const Char16* q = getChar16Data();
   
     for (Uint32 i = 0; i < n; i++)  
     {  
         Uint16 c = *q++;  
         *p++ = char(c);  
   
         if ((c & 0xff00) && !noThrow)  
             throw TruncatedCharacter();  
     }  
   
     return str;  
 }  
   
 void String::appendToCString(  
     char* str,  
     Uint32 length,  
     Boolean noThrow) const  
 {  
     if (!str)  
         throw NullPointer();  
   
     Uint32 n = (size() < length)? size() : length;  
   
     char* p = str + strlen(str);  
     const Char16* q = getData();  
  
     for (Uint32 i = 0; i < n; i++)     for (Uint32 i = 0; i < n; i++)
     {     {
         Uint16 c = *q++;         Uint16 c = *q++;
         *p++ = char(c);         *p++ = char(c);
  
         if ((c & 0xff00) && !noThrow)          //if (c & 0xff00)
             throw TruncatedCharacter();          //    truncatedCharacters = true;
     }     }
  
     *p = '\0';      return CString(str);
 } }
  
 Char16& String::operator[](Uint32 i)  Char16& String::operator[](Uint32 index)
 { {
     if (i > size())      if (index > size())
         ThrowOutOfBounds();          throw IndexOutOfBoundsException();
  
     return _rep[i];      return _rep->c16a[index];
 } }
  
 const Char16 String::operator[](Uint32 i) const  const Char16 String::operator[](Uint32 index) const
 { {
     if (i > size())      if (index > size())
         ThrowOutOfBounds();          throw IndexOutOfBoundsException();
  
     return _rep[i];      return _rep->c16a[index];
 } }
  
 String& String::append(const Char16& c) String& String::append(const Char16& c)
 { {
     _rep.insert(_rep.size() - 1, c);      _rep->c16a.insert(_rep->c16a.size() - 1, c);
     return *this;     return *this;
 } }
  
 String& String::append(const Char16* str, Uint32 n) String& String::append(const Char16* str, Uint32 n)
 { {
     Uint32 m = _strnlen(str, n);     Uint32 m = _strnlen(str, n);
     _rep.reserve(_rep.size() + m);      _rep->c16a.reserveCapacity(_rep->c16a.size() + m);
     _rep.remove(_rep.size() - 1);      _rep->c16a.remove(_rep->c16a.size() - 1);
     _rep.append(str, m);      _rep->c16a.append(str, m);
     _rep.append('\0');      _rep->c16a.append('\0');
     return *this;     return *this;
 } }
  
 String& String::append(const String& str) String& String::append(const String& str)
 { {
     return append(str.getData(), str.size());      return append(str.getChar16Data(), str.size());
 }  
   
 String& String::operator+=(const String& str)  
 {  
     return append(str);  
 }  
   
 String& String::operator+=(Char16 c)  
 {  
     return append(c);  
 }  
   
 String& String::operator+=(char c)  
 {  
     return append(Char16(c));  
 } }
  
 void String::remove(Uint32 pos, Uint32 size)  void String::remove(Uint32 index, Uint32 size)
 { {
     if (size == PEG_NOT_FOUND)     if (size == PEG_NOT_FOUND)
         size = this->size() - pos;          size = this->size() - index;
  
     if (pos + size > this->size())      if (index + size > this->size())
         ThrowOutOfBounds();          throw IndexOutOfBoundsException();
  
     if (size)     if (size)
         _rep.remove(pos, size);          _rep->c16a.remove(index, size);
 } }
  
 String String::subString(Uint32 pos, Uint32 length) const  String String::subString(Uint32 index, Uint32 length) const
 { {
     if (pos < size())      if (index < size())
     {     {
         if (length == PEG_NOT_FOUND)          if ((length == PEG_NOT_FOUND) || (length > size() - index))
             length = size() - pos;              length = size() - index;
  
         return String(getData() + pos, length);          return String(getChar16Data() + index, length);
     }     }
     else     else
         return String();         return String();
Line 345 
Line 371 
  
 Uint32 String::find(Char16 c) const Uint32 String::find(Char16 c) const
 { {
     const Char16* first = getData();      const Char16* first = getChar16Data();
  
     for (const Char16* p = first; *p; p++)     for (const Char16* p = first; *p; p++)
     {     {
Line 356 
Line 382 
     return PEG_NOT_FOUND;     return PEG_NOT_FOUND;
 } }
  
 Uint32 String::find(Uint32 pos, Char16 c) const  Uint32 String::find(Uint32 index, Char16 c) const
 { {
     const Char16* data = getData();      const Char16* data = getChar16Data();
  
     for (Uint32 i = pos, n = size(); i < n; i++)      for (Uint32 i = index, n = size(); i < n; i++)
     {     {
         if (data[i] == c)         if (data[i] == c)
             return i;             return i;
Line 371 
Line 397 
  
 Uint32 String::find(const String& s) const Uint32 String::find(const String& s) const
 { {
     const Char16* pSubStr = s.getData();      const Char16* pSubStr = s.getChar16Data();
     const Char16* pStr = getData();      const Char16* pStr = getChar16Data();
     Uint32 subStrLen = s.size();     Uint32 subStrLen = s.size();
     Uint32 strLen = size();     Uint32 strLen = size();
  
Line 402 
Line 428 
     return PEG_NOT_FOUND;     return PEG_NOT_FOUND;
 } }
  
 Uint32 String::find(const Char16* s) const  
 {  
     return find(String(s));  
 }  
   
 Uint32 String::find(const char* s) const  
 {  
     return find(String(s));  
 }  
   
 Uint32 String::reverseFind(Char16 c) const Uint32 String::reverseFind(Char16 c) const
 { {
     const Char16* first = getData();      const Char16* first = getChar16Data();
     const Char16* last = getData() + size();      const Char16* last = getChar16Data() + size();
  
     while (last != first)     while (last != first)
     {     {
Line 426 
Line 442 
     return PEG_NOT_FOUND;     return PEG_NOT_FOUND;
 } }
  
   // ATTN-RK-P3-20020509: Define case-sensitivity for non-English characters
 void String::toLower() void String::toLower()
 { {
     for (Char16* p = &_rep[0]; *p; p++)      for (Char16* p = &_rep->c16a[0]; *p; p++)
     {     {
 #ifdef PEGASUS_HAS_EBCDIC          if (*p <= PEGASUS_MAX_PRINTABLE_CHAR)
         if (*p <= 255)  
 #else  
         if (*p <= 127)  
 #endif  
             *p = tolower(*p);             *p = tolower(*p);
     }     }
 } }
  
 void String::toLower(char* str)  int String::compare(const String& s1, const String& s2, Uint32 n)
 { {
     while (*str)      const Char16* s1c16 = s1.getChar16Data();
         tolower(*str++);      const Char16* s2c16 = s2.getChar16Data();
 }  
  
 void String::translate(Char16 fromChar, Char16 toChar)  
 {  
     for (Char16* p = &_rep[0]; *p; p++)  
     {  
         if (*p == fromChar)  
             *p = toChar;  
     }  
 }  
   
 void String::print() const  
 {  
     cout << *this << endl;  
 }  
   
 int String::compare(const Char16* s1, const Char16* s2, Uint32 n)  
 {  
     while (n--)     while (n--)
     {     {
         int r = *s1++ - *s2++;          int r = *s1c16++ - *s2c16++;
  
         if (r)         if (r)
             return r;             return r;
Line 472 
Line 468 
     return 0;     return 0;
 } }
  
 int String::compare(const Char16* s1, const Char16* s2)  int String::compare(const String& s1, const String& s2)
 {  
     while (*s1 && *s2)  
     {     {
         int r = *s1++ - *s2++;      const Char16* s1c16 = s1.getChar16Data();
       const Char16* s2c16 = s2.getChar16Data();
         if (r)  
             return r;  
     }  
   
     if (*s2)  
         return -1;  
     else if (*s1)  
         return 1;  
  
     return 0;      while (*s1c16 && *s2c16)
 }  
   
 int String::compareNoCase(const char* s1, const char* s2, Uint32 n)  
 {  
     while (n--)  
     {  
         int r = tolower(*s1++) - tolower(*s2++);  
   
         if (r)  
             return r;  
     }  
   
     return 0;  
 }  
   
 int String::compareNoCase(const char* s1, const char* s2)  
 { {
     while (*s1 && *s2)          int r = *s1c16++ - *s2c16++;
     {  
         int r = tolower(*s1++) - tolower(*s2++);  
  
         if (r)         if (r)
             return r;             return r;
     }     }
  
     if (*s2)      if (*s2c16)
         return -1;         return -1;
     else if (*s1)      else if (*s1c16)
         return 1;         return 1;
  
     return 0;     return 0;
Line 523 
Line 491 
  
 int String::compareNoCase(const String& s1, const String& s2) int String::compareNoCase(const String& s1, const String& s2)
 { {
     const Char16* _s1 = s1.getData();      const Char16* _s1 = s1.getChar16Data();
     const Char16* _s2 = s2.getData();      const Char16* _s2 = s2.getChar16Data();
  
     while (*_s1 && *_s2)     while (*_s1 && *_s2)
     {     {
         int r;         int r;
  
 #ifdef PEGASUS_HAS_EBCDIC          if (*_s1 <= PEGASUS_MAX_PRINTABLE_CHAR &&
         if (*_s1 <= 255 && *_s2 <= 255)              *_s2 <= PEGASUS_MAX_PRINTABLE_CHAR)
 #else  
         if (*_s1 <= 127 && *_s2 <= 127)  
 #endif  
         {         {
             r = tolower(*_s1++) - tolower(*_s2++);             r = tolower(*_s1++) - tolower(*_s2++);
         }         }
Line 557 
Line 522 
  
 Boolean String::equal(const String& str1, const String& str2) Boolean String::equal(const String& str1, const String& str2)
 { {
     if (str1.size() != str2.size())      return String::compare(str1, str2) == 0;
         return false;  
   
     return String::compare(str1.getData(), str2.getData(), str1.size()) == 0;  
 }  
   
 Boolean String::equal(const String& str1, const Char16* str2)  
 {  
     if (str1.size() != _StrLen(str2))  
         return false;  
   
     return String::compare(str1.getData(), str2, str1.size()) == 0;  
 }  
   
 Boolean String::equal(const Char16* str1, const String& str2)  
 {  
     return equal(str2, str1);  
 }  
   
 Boolean String::equal(const String& str1, const char* str2)  
 {  
     return equal(str1, String(str2));  
 }  
   
 Boolean String::equal(const char* str1, const String& str2)  
 {  
     return equal(String(str1), str2);  
 } }
  
 Boolean String::equalNoCase(const String& str1, const String& str2) Boolean String::equalNoCase(const String& str1, const String& str2)
Line 591 
Line 530 
     if (str1.size() != str2.size())     if (str1.size() != str2.size())
         return false;         return false;
  
     const Char16* p = str1.getData();      const Char16* p = str1.getChar16Data();
     const Char16* q = str2.getData();      const Char16* q = str2.getChar16Data();
  
     Uint32 n = str1.size();     Uint32 n = str1.size();
  
     while (n--)     while (n--)
     {     {
 #ifdef PEGASUS_HAS_EBCDIC          if (*p <= PEGASUS_MAX_PRINTABLE_CHAR &&
         if (*p <= 255 && *q <= 255)              *q <= PEGASUS_MAX_PRINTABLE_CHAR)
 #else  
         if (*p <= 127 && *q <= 127)  
 #endif  
         {         {
             if (tolower(*p++) != tolower(*q++))             if (tolower(*p++) != tolower(*q++))
                 return false;                 return false;
Line 614 
Line 550 
     return true;     return true;
 } }
  
 //#define NEWMATCHFUNCTION  
 #if defined NEWMATCHFUNCTION  #if 0
   // ATTN-RK-P3-20020603: This code is not completely correct
  // Wildcard String matching function that may be useful in the future  // Wildcard String matching function that may be useful in the future
 // The following code was provided by Bob Blair. // The following code was provided by Bob Blair.
  
Line 639 
Line 576 
  
 inline Uint16 _ToLower(Uint16 ch) inline Uint16 _ToLower(Uint16 ch)
 { {
 #ifdef PEGASUS_HAS_EBCDIC      return ch <= PEGASUS_MAX_PRINTABLE_CHAR ? tolower(char(ch)) : ch;
     return ch <= 255 ? tolower(char(ch)) : ch;  
 #else  
     return ch <= 127 ? tolower(char(ch)) : ch;  
 #endif  
 } }
  
 inline Boolean _Equal(MatchChar ch1, MatchChar ch2, int nocase) inline Boolean _Equal(MatchChar ch1, MatchChar ch2, int nocase)
Line 725 
Line 658 
             pat = _matchrange(pat, *str, nocase);         // and is a match             pat = _matchrange(pat, *str, nocase);         // and is a match
             if (!pat) {                                  //It is not a match             if (!pat) {                                  //It is not a match
               done = 1;                                  //  we're done               done = 1;                                  //  we're done
               res = 1;                                   //  no match                res = 0;                                   //  no match
             } else {                                     //Range matches             } else {                                     //Range matches
               str++, pat++;                              //  keep going               str++, pat++;                              //  keep going
             }             }
Line 740 
Line 673 
   return res;   return res;
 } }
  
 #else  
 ////////////////////////////////////////////////////////////////////////////////  
 //  
 // String matching routines borrowed from Tcl 8.0:  
 //  
 ////////////////////////////////////////////////////////////////////////////////  
   
 ////////////////////////////////////////////////////////////////////////////////  
 //  
 // This software is copyrighted by the Regents of the University of  
 // California, Sun Microsystems, Inc., and other parties.  The following  
 // terms apply to all files associated with the software unless explicitly  
 // disclaimed in individual files.  
 //  
 // The authors hereby grant permission to use, copy, modify, distribute,  
 // and license this software and its documentation for any purpose, provided  
 // that existing copyright notices are retained in all copies and that this  
 // notice is included verbatim in any distributions. No written agreement,  
 // license, or royalty fee is required for any of the authorized uses.  
 // Modifications to this software may be copyrighted by their authors  
 // and need not follow the licensing terms described here, provided that  
 // the new terms are clearly indicated on the first page of each file where  
 // they apply.  
 //  
 // IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY  
 // FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES  
 // ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY  
 // DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE  
 // POSSIBILITY OF SUCH DAMAGE.  
 //  
 // THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,  
 // INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,  
 // FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.  THIS SOFTWARE  
 // IS PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE  
 // NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR  
 // MODIFICATIONS.  
 //  
 // GOVERNMENT USE: If you are acquiring this software on behalf of the  
 // U.S. government, the Government shall have only "Restricted Rights"  
 // in the software and related documentation as defined in the Federal  
 // Acquisition Regulations (FARs) in Clause 52.227.19 (c) (2).  If you  
 // are acquiring the software on behalf of the Department of Defense, the  
 // software shall be classified as "Commercial Computer Software" and the  
 // Government shall have only "Restricted Rights" as defined in Clause  
 // 252.227-7013 (c) (1) of DFARs.  Notwithstanding the foregoing, the  
 // authors grant the U.S. Government and others acting in its behalf  
 // permission to use and distribute the software in accordance with the  
 // terms specified in this license.  
 //  
 ////////////////////////////////////////////////////////////////////////////////  
   
   
 /*  
  *----------------------------------------------------------------------  
  *  
  * Tcl_StringMatch --  
  *  
  *      See if a particular string matches a particular pattern.  
  *  
  * Results:  
  *      The return value is 1 if string matches pattern, and  
  *      0 otherwise.  The matching operation permits the following  
  *      special characters in the pattern: *?\[] (see the manual  
  *      entry for details on what these mean).  
  *  
  * Side effects:  
  *      None.  
  *  
  *----------------------------------------------------------------------  
  */  
   
 typedef Uint16 MatchChar;  
   
 inline Uint16 _ToLower(Uint16 ch)  
 {  
 #ifdef PEGASUS_HAS_EBCDIC  
     return ch <= 255 ? tolower(char(ch)) : ch;  
 #else  
     return ch <= 127 ? tolower(char(ch)) : ch;  
 #endif  
 }  
   
 inline Boolean _Equal(Uint16 ch1, Uint16 ch2, int nocase)  
 {  
     if (nocase)  
         return _ToLower(ch1) == _ToLower(ch2);  
     else  
         return ch1 == ch2;  
 }  
   
 int _StringMatch(  
     MatchChar *string,          /* String. */  
     MatchChar *pattern,         /* Pattern, which may contain special  
                                  * characters. */  
     int nocase)                 /* Ignore case if this is true */  
 {  
     MatchChar c2;  
   
     while (1) {  
         /* See if we're at the end of both the pattern and the string.  
          * If so, we succeeded.  If we're at the end of the pattern  
          * but not at the end of the string, we failed.  
          */  
   
         if (*pattern == 0) {  
             if (*string == 0) {  
                 return 1;  
             } else {  
                 return 0;  
             }  
         }  
         if ((*string == 0) && (*pattern != '*')) {  
             return 0;  
         }  
   
         /* Check for a "*" as the next pattern character.  It matches  
          * any substring.  We handle this by calling ourselves  
          * recursively for each postfix of string, until either we  
          * match or we reach the end of the string.  
          */  
   
         if (*pattern == '*') {  
             pattern += 1;  
             if (*pattern == 0) {  
                 return 1;  
             }  
             while (1) {  
                 if (_StringMatch(string, pattern, nocase)) {  
                     return 1;  
                 }  
                 if (*string == 0) {  
                     return 0;  
                 }  
                 string += 1;  
             }  
         }  
   
         /* Check for a "?" as the next pattern character.  It matches  
          * any single character.  
          */  
   
         if (*pattern == '?') {  
             goto thisCharOK;  
         }  
  
         /* Check for a "[" as the next pattern character.  It is followed      /** match matches a string against a GLOB style pattern.
          * by a list of characters that are acceptable, or by a range          Return trues if the String parameter matches the pattern. C-Shell style
          * (two characters separated by "-").          glob matching is used.
           @param str String to be matched against the pattern
           @param pattern Pattern to use in the match
           @return Boolean true if str matches pattern
           The pattern definition is as follows:
           <pre>
           *             Matches any number of any characters
           ?             Match exactly one character
           [chars]       Match any character in chars
           [chara-charb] Match any character in the range between chara and charb
           </pre>
           The literal characters *, ?, [, ] can be included in a string by
           escaping them with backslash "\".  Ranges of characters can be concatenated.
           <pre>
           examples:
           Boolean result = String::match("This is a test", "*is*");
           Boolean works =  String::match("abcdef123", "*[0-9]");
           </pre>
          */          */
   
         if (*pattern == '[') {  
             pattern += 1;  
             while (1) {  
                 if ((*pattern == ']') || (*pattern == 0)) {  
                     return 0;  
                 }  
                 if (_Equal(*pattern, *string, nocase)) {  
                     break;  
                 }  
                 if (pattern[1] == '-') {  
                     c2 = pattern[2];  
                     if (c2 == 0) {  
                         return 0;  
                     }  
                     if ((*pattern <= *string) && (c2 >= *string)) {  
                         break;  
                     }  
                     if ((*pattern >= *string) && (c2 <= *string)) {  
                         break;  
                     }  
                     pattern += 2;  
                 }  
                 pattern += 1;  
             }  
             while (*pattern != ']') {  
                 if (*pattern == 0) {  
                     pattern--;  
                     break;  
                 }  
                 pattern += 1;  
             }  
             goto thisCharOK;  
         }  
   
         /* If the next pattern character is '/', just strip off the '/'  
          * so we do exact matching on the character that follows.  
          */  
   
         if (*pattern == '\\') {  
             pattern += 1;  
             if (*pattern == 0) {  
                 return 0;  
             }  
         }  
   
         /* There's no special character.  Just make sure that the next  
          * characters of each string match.  
          */  
   
         if (!_Equal(*pattern, *string, nocase)) {  
             return 0;  
         }  
   
         thisCharOK: pattern += 1;  
         string += 1;  
     }  
 }  
 #endif  
   
 Boolean String::match(const String& str, const String& pattern) Boolean String::match(const String& str, const String& pattern)
 { {
     return _StringMatch(     return _StringMatch(
         (Uint16*)str.getData(), (Uint16*)pattern.getData(), 0) != 0;          (Uint16*)str.getChar16Data(), (Uint16*)pattern.getChar16Data(), 0) != 0;
 } }
  
       /** matchNoCase Matches a String against a GLOB style pattern independent
           of case.
           Returns true if the str parameter matches the pattern. C-Shell style
           glob matching is used. Ignore case in all comparisons. Case is
           ignored in the match.
           @parm str String containing the string to be matched\
           @parm pattern GLOB style patterh to use in the match.
           @return Boolean true if str matches patterh
           @SeeAlso match
       */
 Boolean String::matchNoCase(const String& str, const String& pattern) Boolean String::matchNoCase(const String& str, const String& pattern)
 { {
     return _StringMatch(     return _StringMatch(
         (Uint16*)str.getData(), (Uint16*)pattern.getData(), 1) != 0;          (Uint16*)str.getChar16Data(), (Uint16*)pattern.getChar16Data(), 1) != 0;
 } }
   #endif
  
  
 /////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
Line 988 
Line 745 
     return !String::equal(str1, str2);     return !String::equal(str1, str2);
 } }
  
 PEGASUS_STD(ostream)& operator<<(PEGASUS_STD(ostream)& os, const String& str1)  PEGASUS_STD(ostream)& operator<<(PEGASUS_STD(ostream)& os, const String& str)
   {
       for (Uint32 i = 0, n = str.size(); i < n; i++)
       {
           Uint16 code = str[i];
   
           if (code > 0 && code <= PEGASUS_MAX_PRINTABLE_CHAR)
 { {
     for (Uint32 i = 0, n = str1.size(); i < n; i++)              os << char(code);
         os << str1[i];          }
           else
           {
               // Print in hex format:
               char buffer[8];
               sprintf(buffer, "\\x%04X", code);
               os << buffer;
           }
       }
  
     return os;     return os;
 } }
Line 1003 
Line 774 
  
 Boolean operator<(const String& str1, const String& str2) Boolean operator<(const String& str1, const String& str2)
 { {
     return String::compare(str1.getData(), str2.getData()) < 0;      return String::compare(str1, str2) < 0;
 } }
  
 Boolean operator<=(const String& str1, const String& str2) Boolean operator<=(const String& str1, const String& str2)
 { {
     return String::compare(str1.getData(), str2.getData()) <= 0;      return String::compare(str1, str2) <= 0;
 } }
  
 Boolean operator>(const String& str1, const String& str2) Boolean operator>(const String& str1, const String& str2)
 { {
     return String::compare(str1.getData(), str2.getData()) > 0;      return String::compare(str1, str2) > 0;
 } }
  
 Boolean operator>=(const String& str1, const String& str2) Boolean operator>=(const String& str1, const String& str2)
 { {
     return String::compare(str1.getData(), str2.getData()) >= 0;      return String::compare(str1, str2) >= 0;
 } }
  
   #ifndef PEGASUS_REMOVE_DEPRECATED
 int CompareNoCase(const char* s1, const char* s2) int CompareNoCase(const char* s1, const char* s2)
 { {
     while (*s1 && *s2)      return System::strcasecmp(s1, s2);
     {  
         int r = tolower(*s1++) - tolower(*s2++);  
   
         if (r)  
             return r;  
     }  
   
     if (*s2)  
         return -1;  
     else if (*s1)  
         return 1;  
   
     return 0;  
 }  
   
 int EqualNoCase(const char* s1, const char* s2)  
 {  
     return CompareNoCase(s1, s2) == 0;  
 } }
   #endif
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

Legend:
Removed from v.1.41  
changed lines
  Added in v.1.67
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2