(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.65 and 1.65.2.1

version 1.65, 2002/09/20 22:11:25 version 1.65.2.1, 2002/10/28 15:43:24
Line 29 
Line 29 
  
  
 #include <cctype> #include <cctype>
 #include <cstring>  
 #include "String.h" #include "String.h"
 #include "Array.h" #include "Array.h"
 #include "InternalException.h"  #include "Exception.h"
 #include <iostream> #include <iostream>
 #include <fstream>  
 #ifndef PEGASUS_REMOVE_DEPRECATED  
 #include "System.h"  // for strcasecmp  
 #endif  
  
 PEGASUS_USING_STD; PEGASUS_USING_STD;
  
Line 45 
Line 40 
  
 /////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
 // //
 // 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;  
 }  
   
 ///////////////////////////////////////////////////////////////////////////////  
 //  
 // String // String
 // //
 /////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
Line 173 
Line 128 
 String::String(const String& str, Uint32 n) String::String(const String& str, Uint32 n)
 { {
     _rep = new StringRep;     _rep = new StringRep;
     assign(str.getChar16Data(), n);      assign(str.getData(), n);
 } }
  
 String::String(const Char16* str) String::String(const Char16* str)
Line 275 
Line 230 
     return _rep->c16a.size() - 1;     return _rep->c16a.size() - 1;
 } }
  
 const Char16* String::getChar16Data() const  const Char16* String::getData() const
 { {
     return _rep->c16a.getData();     return _rep->c16a.getData();
 } }
  
 CString String::getCString() const  char* String::allocateCString(Uint32 extraBytes, Boolean noThrow) const
 { {
     Uint32 n = size() + 1;     Uint32 n = size() + 1;
     char* str = new char[n];      char* str = new char[n + extraBytes];
     char* p = str;     char* p = str;
     const Char16* q = getChar16Data();      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)          if ((c & 0xff00) && !noThrow)
         //    truncatedCharacters = true;              throw TruncatedCharacter();
     }     }
  
     return CString(str);      return str;
 } }
  
 Char16& String::operator[](Uint32 index)  Char16& String::operator[](Uint32 i)
 { {
     if (index > size())      if (i > size())
         throw IndexOutOfBoundsException();          throw OutOfBounds();
  
     return _rep->c16a[index];      return _rep->c16a[i];
 } }
  
 const Char16 String::operator[](Uint32 index) const  const Char16 String::operator[](Uint32 i) const
 { {
     if (index > size())      if (i > size())
         throw IndexOutOfBoundsException();          throw OutOfBounds();
  
     return _rep->c16a[index];      return _rep->c16a[i];
 } }
  
 String& String::append(const Char16& c) String& String::append(const Char16& c)
Line 333 
Line 288 
  
 String& String::append(const String& str) String& String::append(const String& str)
 { {
     return append(str.getChar16Data(), str.size());      return append(str.getData(), str.size());
   }
   
   String& String::operator+=(const String& str)
   {
       return append(str);
   }
   
   String& String::operator+=(Char16 c)
   {
       return append(c);
 } }
  
 void String::remove(Uint32 index, Uint32 size)  String& String::operator+=(char c)
   {
       return append(Char16(c));
   }
   
   void String::remove(Uint32 pos, Uint32 size)
 { {
     if (size == PEG_NOT_FOUND)     if (size == PEG_NOT_FOUND)
         size = this->size() - index;          size = this->size() - pos;
  
     if (index + size > this->size())      if (pos + size > this->size())
         throw IndexOutOfBoundsException();          throw OutOfBounds();
  
     if (size)     if (size)
         _rep->c16a.remove(index, size);          _rep->c16a.remove(pos, size);
 } }
  
 String String::subString(Uint32 index, Uint32 length) const  String String::subString(Uint32 pos, Uint32 length) const
 { {
     if (index < size())      if (pos < size())
     {     {
         if ((length == PEG_NOT_FOUND) || (length > size() - index))          if (length == PEG_NOT_FOUND)
             length = size() - index;              length = size() - pos;
  
         return String(getChar16Data() + index, length);          return String(getData() + pos, length);
     }     }
     else     else
         return String();         return String();
Line 363 
Line 333 
  
 Uint32 String::find(Char16 c) const Uint32 String::find(Char16 c) const
 { {
     const Char16* first = getChar16Data();      const Char16* first = getData();
  
     for (const Char16* p = first; *p; p++)     for (const Char16* p = first; *p; p++)
     {     {
Line 374 
Line 344 
     return PEG_NOT_FOUND;     return PEG_NOT_FOUND;
 } }
  
 Uint32 String::find(Uint32 index, Char16 c) const  Uint32 String::find(Uint32 pos, Char16 c) const
 { {
     const Char16* data = getChar16Data();      const Char16* data = getData();
  
     for (Uint32 i = index, n = size(); i < n; i++)      for (Uint32 i = pos, n = size(); i < n; i++)
     {     {
         if (data[i] == c)         if (data[i] == c)
             return i;             return i;
Line 389 
Line 359 
  
 Uint32 String::find(const String& s) const Uint32 String::find(const String& s) const
 { {
     const Char16* pSubStr = s.getChar16Data();      const Char16* pSubStr = s.getData();
     const Char16* pStr = getChar16Data();      const Char16* pStr = getData();
     Uint32 subStrLen = s.size();     Uint32 subStrLen = s.size();
     Uint32 strLen = size();     Uint32 strLen = size();
  
Line 422 
Line 392 
  
 Uint32 String::reverseFind(Char16 c) const Uint32 String::reverseFind(Char16 c) const
 { {
     const Char16* first = getChar16Data();      const Char16* first = getData();
     const Char16* last = getChar16Data() + size();      const Char16* last = getData() + size();
  
     while (last != first)     while (last != first)
     {     {
Line 434 
Line 404 
     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->c16a[0]; *p; p++)     for (Char16* p = &_rep->c16a[0]; *p; p++)
Line 446 
Line 415 
  
 int String::compare(const String& s1, const String& s2, Uint32 n) int String::compare(const String& s1, const String& s2, Uint32 n)
 { {
     const Char16* s1c16 = s1.getChar16Data();      const Char16* s1c16 = s1.getData();
     const Char16* s2c16 = s2.getChar16Data();      const Char16* s2c16 = s2.getData();
  
     while (n--)     while (n--)
     {     {
Line 462 
Line 431 
  
 int String::compare(const String& s1, const String& s2) int String::compare(const String& s1, const String& s2)
 { {
     const Char16* s1c16 = s1.getChar16Data();      const Char16* s1c16 = s1.getData();
     const Char16* s2c16 = s2.getChar16Data();      const Char16* s2c16 = s2.getData();
  
     while (*s1c16 && *s2c16)     while (*s1c16 && *s2c16)
     {     {
Line 481 
Line 450 
     return 0;     return 0;
 } }
  
   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 = tolower(*s1++) - tolower(*s2++);
   
           if (r)
               return r;
       }
   
       if (*s2)
           return -1;
       else if (*s1)
           return 1;
   
       return 0;
   }
   
 int String::compareNoCase(const String& s1, const String& s2) int String::compareNoCase(const String& s1, const String& s2)
 { {
     const Char16* _s1 = s1.getChar16Data();      const Char16* _s1 = s1.getData();
     const Char16* _s2 = s2.getChar16Data();      const Char16* _s2 = s2.getData();
  
     while (*_s1 && *_s2)     while (*_s1 && *_s2)
     {     {
Line 522 
Line 522 
     if (str1.size() != str2.size())     if (str1.size() != str2.size())
         return false;         return false;
  
     const Char16* p = str1.getChar16Data();      const Char16* p = str1.getData();
     const Char16* q = str2.getChar16Data();      const Char16* q = str2.getData();
  
     Uint32 n = str1.size();     Uint32 n = str1.size();
  
Line 543 
Line 543 
 } }
  
  
 #if 0  
 // ATTN-RK-P3-20020603: This code is not completely correct // 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 666 
Line 665 
 } }
  
  
     /** match matches a string against a GLOB style pattern.  
         Return trues if the String parameter matches the pattern. C-Shell style  
         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>  
     */  
 Boolean String::match(const String& str, const String& pattern) Boolean String::match(const String& str, const String& pattern)
 { {
     return _StringMatch(     return _StringMatch(
         (Uint16*)str.getChar16Data(), (Uint16*)pattern.getChar16Data(), 0) != 0;          (Uint16*)str.getData(), (Uint16*)pattern.getData(), 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.getChar16Data(), (Uint16*)pattern.getChar16Data(), 1) != 0;          (Uint16*)str.getData(), (Uint16*)pattern.getData(), 1) != 0;
 } }
 #endif  
  
  
 /////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
Line 737 
Line 704 
     return !String::equal(str1, str2);     return !String::equal(str1, str2);
 } }
  
 PEGASUS_STD(ostream)& operator<<(PEGASUS_STD(ostream)& os, const String& str)  PEGASUS_STD(ostream)& operator<<(PEGASUS_STD(ostream)& os, const String& str1)
 {  
     for (Uint32 i = 0, n = str.size(); i < n; i++)  
     {  
         Uint16 code = str[i];  
   
         if (code > 0 && code <= PEGASUS_MAX_PRINTABLE_CHAR)  
         {  
             os << char(code);  
         }  
         else  
         {         {
             // Print in hex format:      for (Uint32 i = 0, n = str1.size(); i < n; i++)
             char buffer[8];          os << str1[i];
             sprintf(buffer, "\\x%04X", code);  
             os << buffer;  
         }  
     }  
  
     return os;     return os;
 } }
Line 784 
Line 737 
     return String::compare(str1, str2) >= 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)
 { {
     return System::strcasecmp(s1, s2);      while (*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.65  
changed lines
  Added in v.1.65.2.1
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2