(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.89 and 1.90

version 1.89, 2004/02/20 14:22:01 version 1.90, 2004/04/08 14:45:18
Line 233 
Line 233 
  
     if(!memcmp(utfFlag,STRING_FLAG_UTF8,sizeof(STRING_FLAG_UTF8)))     if(!memcmp(utfFlag,STRING_FLAG_UTF8,sizeof(STRING_FLAG_UTF8)))
     {     {
         assignUTF8(str);          assign(str);
     }     }
     else     else
     {     {
Line 283 
Line 283 
     return *this;     return *this;
 } }
  
 String& String::assign(const char* str)  
 {  
     _rep->c16a.clear();  
   
     Uint32 n = strlen(str) + 1;  
     _rep->c16a.reserveCapacity(n);  
   
     while (n--)  
         _rep->c16a.append(Uint8(*str++));  
   
     return *this;  
 }  
   
 String& String::assign(const char* str, Uint32 n) String& String::assign(const char* str, Uint32 n)
 { {
     _rep->c16a.clear();      char *tmpStr = new char[n+1];
       memset(tmpStr,0x00,n+1);
  
     Uint32 _n = _strnlen(str, n);      strncpy(tmpStr,str,n);
     _rep->c16a.reserveCapacity(_n + 1);      assign(tmpStr);
       delete tmpStr;
     while (_n--)  
         _rep->c16a.append(Uint8(*str++));  
   
     _rep->c16a.append('\0');  
  
     return *this;     return *this;
 } }
Line 332 
Line 316 
     return _rep->c16a.getData();     return _rep->c16a.getData();
 } }
  
 CString String::getCString() const  
 {  
     Uint32 n = size() + 1;  
     char* str = new char[n];  
     char* p = str;  
     const Char16* q = getChar16Data();  
   
     for (Uint32 i = 0; i < n; i++)  
     {  
         Uint16 c = *q++;  
         *p++ = char(c);  
   
         //if (c & 0xff00)  
         //    truncatedCharacters = true;  
     }  
   
     return CString(str);  
 }  
   
 Char16& String::operator[](Uint32 index) Char16& String::operator[](Uint32 index)
 { {
     if (index > size())     if (index > size())
Line 486 
Line 451 
     return PEG_NOT_FOUND;     return PEG_NOT_FOUND;
 } }
  
 // ATTN-RK-P3-20020509: Define case-sensitivity for non-English characters  
 // ATTN-CEC-20030913: ICU code added, but uses the server's locale.  Look at adding  
 // a toLower( ) with Locale parameter - like ICU's toLower( )  
 void String::toLower() void String::toLower()
 { {
       const char * noLocale = NULL;
       String::toLower(noLocale);
   }
   void String::toLower(const char * strLocale)
   {
 #ifdef PEGASUS_HAS_ICU #ifdef PEGASUS_HAS_ICU
     UnicodeString UniStr((const UChar *)_rep->c16a.getData());     UnicodeString UniStr((const UChar *)_rep->c16a.getData());
       if(strLocale == NULL)
       {
     UniStr.toLower();     UniStr.toLower();
       }
       else
       {
           Locale loc(strLocale);
           if(loc.isBogus())
           {
               throw InvalidNameException(String(strLocale));
           }
           UniStr.toLower(loc);
       }
     UniStr.append((UChar)'\0');     UniStr.append((UChar)'\0');
  
     assign((Char16*)UniStr.getBuffer());     assign((Char16*)UniStr.getBuffer());
Line 506 
Line 485 
 #endif #endif
 } }
  
   void String::toUpper(const char * strLocale)
   {
   #ifdef PEGASUS_HAS_ICU
       UnicodeString UniStr((const UChar *)_rep->c16a.getData());
       if(strLocale == NULL)
       {
           UniStr.toUpper();
       }
       else
       {
           Locale loc(strLocale);
           if(loc.isBogus())
           {
               throw InvalidNameException(String(strLocale));
           }
           UniStr.toUpper(loc);
       }
       UniStr.append((UChar)'\0');
   
       assign((Char16*)UniStr.getBuffer());
   #endif
   }
   
 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.getChar16Data();
Line 545 
Line 547 
  
 int String::compareNoCase(const String& s1, const String& s2) int String::compareNoCase(const String& s1, const String& s2)
 { {
       const char * noLocale = NULL;
       return String::compareNoCase(s1, s2, noLocale);
   }
   
   int String::compareNoCase(const String& s1, const String& s2,const char * strLocale)
   {
 #ifdef PEGASUS_HAS_ICU #ifdef PEGASUS_HAS_ICU
     UnicodeString UniStr1((const UChar *)s1.getChar16Data(), (int32_t)s1.size());     UnicodeString UniStr1((const UChar *)s1.getChar16Data(), (int32_t)s1.size());
     UnicodeString UniStr2((const UChar *)s2.getChar16Data(), (int32_t)s2.size());     UnicodeString UniStr2((const UChar *)s2.getChar16Data(), (int32_t)s2.size());
       if(strLocale == NULL)
       {
     UniStr1.toLower();     UniStr1.toLower();
     UniStr2.toLower();     UniStr2.toLower();
       }
       else
       {
           Locale loc(strLocale);
           if(loc.isBogus())
           {
               throw InvalidNameException(String(strLocale));
           }
           UniStr1.toLower(loc);
           UniStr2.toLower(loc);
       }
     // Note:  the ICU 2.6.1 documentation for UnicodeString::compare( ) is     // Note:  the ICU 2.6.1 documentation for UnicodeString::compare( ) is
     // backwards!  The API actually returns +1 if this is greater than text.     // backwards!  The API actually returns +1 if this is greater than text.
     // This is why the line below appears wrong based on the 2.6.1 docs.     // This is why the line below appears wrong based on the 2.6.1 docs.
Line 594 
Line 614 
  
 Boolean String::equalNoCase(const String& str1, const String& str2) Boolean String::equalNoCase(const String& str1, const String& str2)
 { {
       const char * noLocale = NULL;
       return String::equalNoCase(str1, str2, noLocale);
   }
   
   Boolean String::equalNoCase(const String& str1, const String& str2,const char * strLocale)
   {
 #ifdef PEGASUS_HAS_ICU #ifdef PEGASUS_HAS_ICU
     UnicodeString UniStr1((const UChar *)str1.getChar16Data(), (int32_t)str1.size());     UnicodeString UniStr1((const UChar *)str1.getChar16Data(), (int32_t)str1.size());
     UnicodeString UniStr2((const UChar *)str2.getChar16Data(), (int32_t)str2.size());     UnicodeString UniStr2((const UChar *)str2.getChar16Data(), (int32_t)str2.size());
       if(strLocale == NULL)
       {
     UniStr1.toLower();     UniStr1.toLower();
     UniStr2.toLower();     UniStr2.toLower();
       }
       else
       {
           Locale loc(strLocale);
           if(loc.isBogus())
           {
               throw InvalidNameException(String(strLocale));
           }
           UniStr1.toLower(loc);
           UniStr2.toLower(loc);
       }
     return (UniStr1 == UniStr2);     return (UniStr1 == UniStr2);
 #else #else
     if (str1.size() != str2.size())     if (str1.size() != str2.size())
Line 626 
Line 665 
 } }
  
 // UTF8 specific code: // UTF8 specific code:
   String& String::assign(const char* str)
   {
       _rep->c16a.clear();
       Uint32 n = strlen(str) + 1;
   
       const Uint8 *strsrc = (Uint8 *)str;
       Uint8 *endsrc = (Uint8 *)&str[n-1];
   
       Char16 *msg16 = new Char16[n];
       Uint16 *strtgt = (Uint16 *)msg16;
       Uint16 *endtgt = (Uint16 *)&msg16[n];
   
       UTF8toUTF16(&strsrc,
                   endsrc,
                   &strtgt,
                   endtgt);
   
       Uint32 count;
   
       for(count = 0; ((msg16[count]) != Char16(0x00)) && (count < (n - 1)); ++count);
   
       _rep->c16a.append(msg16, count);
   
       _rep->c16a.append('\0');
   
       delete [] msg16;
   
       return *this;
   }
   // UTF8 specific code:
 String& String::assignUTF8(const char* str) String& String::assignUTF8(const char* str)
 { {
     _rep->c16a.clear();     _rep->c16a.clear();
Line 656 
Line 725 
     return *this;     return *this;
 } }
  
 CString String::getCStringUTF8() const  CString String::getCString() const
 { {
     Uint32 n = 3*size() + 1;     Uint32 n = 3*size() + 1;
     char* str = new char[n];     char* str = new char[n];
Line 681 
Line 750 
     return CString(str1);     return CString(str1);
 } }
  
 Boolean String::isUTF8(const char *legal)  CString String::getCStringUTF8() const
 { {
     char numBytes = UTF_8_COUNT_TRAIL_BYTES(*legal)+1;      Uint32 n = 3*size() + 1;
       char* str = new char[n];
  
     // Validate that the string is long enough to hold all the expected bytes.      const Char16* msg16 = getChar16Data();
     // Note that if legal[0] == 0, numBytes will be 1.  
     for (char i=1; i<numBytes; i++)      const Uint16 *strsrc = (Uint16 *)msg16;
     {      Uint16 *endsrc = (Uint16 *)&msg16[size()+1];
         if (legal[i] == 0)  
         {      Uint8 *strtgt = (Uint8 *)str;
             return false;      Uint8 *endtgt = (Uint8 *)&str[n];
         }  
     }      UTF16toUTF8 (&strsrc,
                    endsrc,
                    &strtgt,
                    endtgt);
   
           char* str1 = new char[strlen(str)+1];
           strcpy(str1,str);
           delete [] str;
  
     return (isValid_U8((const Uint8 *)legal, numBytes));      return CString(str1);
 } }
  
   
   
 #if 0 #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

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