(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.66 and 1.75

version 1.66, 2003/01/25 14:38:58 version 1.75, 2003/09/02 15:34:44
Line 39 
Line 39 
 #include "System.h"  // for strcasecmp #include "System.h"  // for strcasecmp
 #endif #endif
  
   #include "CommonUTF.h"
   
   #ifdef PEGASUS_HAS_ICU
   #include <unicode/unistr.h>
   #endif
   
 PEGASUS_USING_STD; PEGASUS_USING_STD;
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
Line 201 
Line 207 
     assign(str);     assign(str);
 } }
  
   String::String(const char* str, const char* utfFlag)
   {
       _rep = new StringRep;
   
       if(!memcmp(utfFlag,STRING_FLAG_UTF8,sizeof(STRING_FLAG_UTF8)))
       {
           assignUTF8(str);
       }
       else
       {
           assign(str);
       }
   }
   
 String::String(const char* str, Uint32 n) String::String(const char* str, Uint32 n)
 { {
     _rep = new StringRep;     _rep = new StringRep;
Line 247 
Line 267 
     _rep->c16a.reserveCapacity(n);     _rep->c16a.reserveCapacity(n);
  
     while (n--)     while (n--)
         _rep->c16a.append(*str++);          _rep->c16a.append(Uint8(*str++));
  
     return *this;     return *this;
 } }
Line 260 
Line 280 
     _rep->c16a.reserveCapacity(_n + 1);     _rep->c16a.reserveCapacity(_n + 1);
  
     while (_n--)     while (_n--)
         _rep->c16a.append(*str++);          _rep->c16a.append(Uint8(*str++));
  
     _rep->c16a.append('\0');     _rep->c16a.append('\0');
  
Line 445 
Line 465 
 // ATTN-RK-P3-20020509: Define case-sensitivity for non-English characters // ATTN-RK-P3-20020509: Define case-sensitivity for non-English characters
 void String::toLower() void String::toLower()
 { {
   #ifdef PEGASUS_HAS_ICU
       Char16* utf16str;
       UnicodeString UniStr((const UChar *)_rep->c16a.getData(), (int32_t)size());
       UniStr = UniStr.toLower();
       utf16str = (Char16 *)UniStr.getTerminatedBuffer();
       assign(utf16str);
       //delete utf16str;
   #else
     for (Char16* p = &_rep->c16a[0]; *p; p++)     for (Char16* p = &_rep->c16a[0]; *p; p++)
     {     {
         if (*p <= PEGASUS_MAX_PRINTABLE_CHAR)         if (*p <= PEGASUS_MAX_PRINTABLE_CHAR)
             *p = tolower(*p);             *p = tolower(*p);
     }     }
   #endif
 } }
  
 int String::compare(const String& s1, const String& s2, Uint32 n) int String::compare(const String& s1, const String& s2, Uint32 n)
Line 491 
Line 520 
  
 int String::compareNoCase(const String& s1, const String& s2) int String::compareNoCase(const String& s1, const String& s2)
 { {
   #ifdef PEGASUS_HAS_ICU
       UnicodeString UniStr1((const UChar *)s1.getChar16Data(), (int32_t)s1.size());
       UnicodeString UniStr2((const UChar *)s2.getChar16Data(), (int32_t)s2.size());
       UniStr1 = UniStr1.toLower();
       UniStr2 = UniStr2.toLower();
       return (UniStr2.compare(UniStr1));
   #else
     const Char16* _s1 = s1.getChar16Data();     const Char16* _s1 = s1.getChar16Data();
     const Char16* _s2 = s2.getChar16Data();     const Char16* _s2 = s2.getChar16Data();
  
Line 518 
Line 554 
         return 1;         return 1;
  
     return 0;     return 0;
   #endif
 } }
  
 Boolean String::equal(const String& str1, const String& str2) Boolean String::equal(const String& str1, const String& str2)
Line 527 
Line 564 
  
 Boolean String::equalNoCase(const String& str1, const String& str2) Boolean String::equalNoCase(const String& str1, const String& str2)
 { {
   #ifdef PEGASUS_HAS_ICU
       UnicodeString UniStr1((const UChar *)str1.getChar16Data(), (int32_t)str1.size());
       UnicodeString UniStr2((const UChar *)str2.getChar16Data(), (int32_t)str2.size());
       UniStr1 = UniStr1.toLower();
       UniStr2 = UniStr2.toLower();
       return (UniStr1 == UniStr2);
   #else
     if (str1.size() != str2.size())     if (str1.size() != str2.size())
         return false;         return false;
  
Line 548 
Line 592 
     }     }
  
     return true;     return true;
   #endif
   }
   
   // UTF8 specific code:
   String& String::assignUTF8(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); ++count);
   
       _rep->c16a.append(msg16, count);
   
       _rep->c16a.append('\0');
   
       delete [] msg16;
   
       return *this;
   }
   
   CString String::getCStringUTF8() const
   {
       Uint32 n = 3*size();
       char* str = new char[n];
   
       const Char16* msg16 = getChar16Data();
   
       const Uint16 *strsrc = (Uint16 *)msg16;
       Uint16 *endsrc = (Uint16 *)&msg16[size()+1];
   
       Uint8 *strtgt = (Uint8 *)str;
       Uint8 *endtgt = (Uint8 *)&str[n];
   
       UTF16toUTF8 (&strsrc,
                    endsrc,
                    &strtgt,
                    endtgt);
   
           char* str1 = new char[strlen(str)+1];
           strcpy(str1,str);
           delete [] str;
   
       return CString(str1);
   }
   
   Boolean String::isUTF8(const char *legal)
   {
       char numBytes = UTF_8_COUNT_TRAIL_BYTES(*legal)+1;
   
       // Validate that the string is long enough to hold all the expected bytes.
       // Note that if legal[0] == 0, numBytes will be 1.
       for (char i=1; i<numBytes; i++)
       {
           if (legal[i] == 0)
           {
               return false;
           }
 } }
  
       return (isValid_U8((const Uint8 *)legal, numBytes));
   }
  
 #if 0 #if 0
 // ATTN-RK-P3-20020603: This code is not completely correct // ATTN-RK-P3-20020603: This code is not completely correct
Line 576 
Line 693 
  
 inline Uint16 _ToLower(Uint16 ch) inline Uint16 _ToLower(Uint16 ch)
 { {
       // ICU_TODO:  If ICU is available we should do this the correct way.
     return ch <= PEGASUS_MAX_PRINTABLE_CHAR ? tolower(char(ch)) : ch;     return ch <= PEGASUS_MAX_PRINTABLE_CHAR ? tolower(char(ch)) : ch;
 } }
  
 inline Boolean _Equal(MatchChar ch1, MatchChar ch2, int nocase) inline Boolean _Equal(MatchChar ch1, MatchChar ch2, int nocase)
 { {
       // ICU_TODO:  If ICU is available we should do this the correct way.
     if (nocase)     if (nocase)
         return _ToLower(ch1) == _ToLower(ch2);         return _ToLower(ch1) == _ToLower(ch2);
     else     else
Line 747 
Line 866 
  
 PEGASUS_STD(ostream)& operator<<(PEGASUS_STD(ostream)& os, const String& str) PEGASUS_STD(ostream)& operator<<(PEGASUS_STD(ostream)& os, const String& str)
 { {
   
   #if defined(PEGASUS_OS_OS400)
       CString cstr = str.getCStringUTF8();
       const char* utf8str = cstr;
   
       os << utf8str;
   
   /*#elif defined(PEGASUS_HAS_ICU)
   
       char *buf = NULL;
       UnicodeString UniStr((const UChar *)str.getChar16Data(), (int32_t)str.size());
   
       Uint32 bufsize = UniStr.extract(0,0,buf);
       buf = new char[bufsize+1];
       UniStr.extract(0,bufsize,buf);
           cout << "strlen(buf) == " << strlen(buf) << endl;
       os << buf;
       os.flush();
       delete [] buf;
     */
   #else
   
   
     for (Uint32 i = 0, n = str.size(); i < n; i++)     for (Uint32 i = 0, n = str.size(); i < n; i++)
     {     {
         Uint16 code = str[i];         Uint16 code = str[i];
Line 763 
Line 905 
             os << buffer;             os << buffer;
         }         }
     }     }
   #endif // End of PEGASUS_HAS_ICU #else leg.
  
     return os;     return os;
 } }

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