(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.80 and 1.101

version 1.80, 2003/09/26 17:52:18 version 1.101, 2005/04/13 04:33:05
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2005////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,  // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // The Open Group, Tivoli Systems  // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
   // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; VERITAS Software Corporation; The Open Group.
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 24 
Line 30 
 // Author: Mike Brasher (mbrasher@bmc.com) // Author: Mike Brasher (mbrasher@bmc.com)
 // //
 // Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com) // Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
   //              Josephine Eskaline Joyce, IBM (jojustin@in.ibm.com) for Bug#3297
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 35 
Line 42 
 #include "InternalException.h" #include "InternalException.h"
 #include <iostream> #include <iostream>
 #include <fstream> #include <fstream>
 #ifndef PEGASUS_REMOVE_DEPRECATED  
 #include "System.h"  // for strcasecmp  
 #endif  
  
 #include "CommonUTF.h" #include "CommonUTF.h"
  
 #ifdef PEGASUS_HAS_ICU #ifdef PEGASUS_HAS_ICU
 #include <unicode/unistr.h>  #include <unicode/ustring.h>
   #include <unicode/uchar.h>
 #endif #endif
  
 PEGASUS_USING_STD; PEGASUS_USING_STD;
Line 62 
Line 67 
  
 CString::CString(const CString& cstr) CString::CString(const CString& cstr)
 { {
       _rep = 0;
   
       if (cstr._rep)
       {
     _rep = (void*)new char[strlen((char*)cstr._rep)+1];     _rep = (void*)new char[strlen((char*)cstr._rep)+1];
     strcpy((char*)_rep, (char*)cstr._rep);     strcpy((char*)_rep, (char*)cstr._rep);
 } }
   }
  
 CString::CString(char* cstr) CString::CString(char* cstr)
     : _rep(cstr)     : _rep(cstr)
Line 74 
Line 84 
 CString::~CString() CString::~CString()
 { {
     if (_rep)     if (_rep)
       {
         delete [] (char*)_rep;         delete [] (char*)_rep;
 } }
   }
  
 CString& CString::operator=(const CString& cstr) CString& CString::operator=(const CString& cstr)
 { {
       if (&cstr != this)
       {
           if (_rep)
           {
               delete [] (char*)_rep;
               _rep = 0;
           }
           if (cstr._rep)
           {
     _rep = (char*)new char[strlen((char*)cstr._rep)+1];     _rep = (char*)new char[strlen((char*)cstr._rep)+1];
     strcpy((char*)_rep, (char*)cstr._rep);     strcpy((char*)_rep, (char*)cstr._rep);
           }
       }
     return *this;     return *this;
 } }
  
Line 97 
Line 120 
  
 const String String::EMPTY = String(); const String String::EMPTY = String();
  
 Uint32 _strnlen(const char* str, Uint32 n)  
 {  
     if (!str)  
         throw NullPointer();  
   
     for (Uint32 i=0; i<n; i++)  
     {  
         if (!*str)  
         {  
             return i;  
         }  
     }  
   
     return n;  
 }  
   
 Uint32 _strnlen(const Char16* str, Uint32 n)  
 {  
     if (!str)  
         throw NullPointer();  
   
     for (Uint32 i=0; i<n; i++)  
     {  
         if (!*str)  
         {  
             return i;  
         }  
     }  
   
     return n;  
 }  
   
 inline Uint32 _StrLen(const char* str)  
 {  
     if (!str)  
         throw NullPointer();  
   
     return strlen(str);  
 }  
   
 inline Uint32 _StrLen(const Char16* str) inline Uint32 _StrLen(const Char16* str)
 { {
     if (!str)     if (!str)
Line 207 
Line 190 
     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 234 
Line 203 
  
 String& String::operator=(const String& str) String& String::operator=(const String& str)
 { {
     return assign(str);      if (&str != this)
       {
           assign(str);
       }
       return *this;
 } }
  
 String& String::assign(const String& str) String& String::assign(const String& str)
Line 253 
Line 226 
 String& String::assign(const Char16* str, Uint32 n) String& String::assign(const Char16* str, Uint32 n)
 { {
     _rep->c16a.clear();     _rep->c16a.clear();
     Uint32 m = _strnlen(str, n);      _rep->c16a.append(str, n);
     _rep->c16a.append(str, m);  
     _rep->c16a.append('\0');     _rep->c16a.append('\0');
     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);  
     _rep->c16a.reserveCapacity(_n + 1);  
  
     while (_n--)      strncpy(tmpStr,str,n);
         _rep->c16a.append(Uint8(*str++));      assign(tmpStr);
       delete [] tmpStr;
     _rep->c16a.append('\0');  
  
     return *this;     return *this;
 } }
Line 308 
Line 264 
     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 351 
Line 288 
  
 String& String::append(const Char16* str, Uint32 n) String& String::append(const Char16* str, Uint32 n)
 { {
     Uint32 m = _strnlen(str, n);       if (!str)
     _rep->c16a.reserveCapacity(_rep->c16a.size() + m);       {
            throw NullPointer();
        }
       _rep->c16a.reserveCapacity(_rep->c16a.size() + n);
     _rep->c16a.remove(_rep->c16a.size() - 1);     _rep->c16a.remove(_rep->c16a.size() - 1);
     _rep->c16a.append(str, m);      _rep->c16a.append(str, n);
     _rep->c16a.append('\0');     _rep->c16a.append('\0');
     return *this;     return *this;
 } }
Line 440 
Line 380 
             Uint32 i = 1;             Uint32 i = 1;
             for (; i < subStrLen; i++)             for (; i < subStrLen; i++)
                 if (*pStr++ != *p++ )                 if (*pStr++ != *p++ )
                     {pStr--; break;} // break from loop                      {pStr-=i; break;} // break from loop
             if (i == subStrLen)             if (i == subStrLen)
                 return loc;                 return loc;
         }         }
Line 462 
Line 402 
     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()
 { {
 #ifdef PEGASUS_HAS_ICU #ifdef PEGASUS_HAS_ICU
     UnicodeString UniStr((const UChar *)_rep->c16a.getData());      // This will do a locale-insensitive, but context-sensitive convert.
     UniStr.toLower();      // Context-sensitive prevents any optimizations that try to
     UniStr.append((UChar)'\0');      // convert just the ascii before calling ICU.
       // The string may shrink or expand after the convert.
   
       int32_t sz = size();
       UChar* destbuf = new UChar[sz + 1];
       const UChar* srcbuf = (const UChar *)getChar16Data();
       UErrorCode err = U_ZERO_ERROR;
  
     assign((Char16*)UniStr.getBuffer());      int32_t needed = u_strToLower(destbuf, sz + 1 , srcbuf, sz, NULL, &err);
       if (err == U_BUFFER_OVERFLOW_ERROR)
       {
         delete [] destbuf;
         destbuf = new UChar[needed + 1];
         err = U_ZERO_ERROR;
         u_strToLower(destbuf, needed + 1 , srcbuf, sz, NULL, &err);
       }
       if (U_FAILURE(err))
       {
           delete [] destbuf;
           throw Exception(u_errorName(err));
       }
   
       if (needed == sz)
       {
           Char16* from = (Char16*)destbuf;
           for (Char16* to = &_rep->c16a[0]; *to; to++, from++)
           {
             *to = *from;
           }
       }
       else
       {
           assign((Char16 *)destbuf, needed);
       }
   
       delete [] destbuf;
 #else #else
     for (Char16* p = &_rep->c16a[0]; *p; p++)     for (Char16* p = &_rep->c16a[0]; *p; p++)
     {     {
Line 482 
Line 452 
 #endif #endif
 } }
  
   void String::toUpper()
   {
   #ifdef PEGASUS_HAS_ICU
       // This will do a locale-insensitive, but context-sensitive convert.
       // Context-sensitive prevents any optimizations that try to
       // convert just the ascii before calling ICU.
       // The string may shrink or expand after the convert.
   
       int32_t sz = size();
       UChar* destbuf = new UChar[sz + 1];
       const UChar* srcbuf = (const UChar *)getChar16Data();
       UErrorCode err = U_ZERO_ERROR;
   
       int32_t needed = u_strToUpper(destbuf, sz + 1 , srcbuf, sz, NULL, &err);
       if (err == U_BUFFER_OVERFLOW_ERROR)
       {
         delete [] destbuf;
         destbuf = new UChar[needed + 1];
         err = U_ZERO_ERROR;
         u_strToUpper(destbuf, needed + 1 , srcbuf, sz, NULL, &err);
       }
       if (U_FAILURE(err))
       {
           delete [] destbuf;
           throw Exception(u_errorName(err));
       }
   
       if (needed == sz)
       {
           Char16* from = (Char16*)destbuf;
           for (Char16* to = &_rep->c16a[0]; *to; to++, from++)
           {
             *to = *from;
           }
       }
       else
       {
           assign((Char16 *)destbuf, needed);
       }
   
       delete [] destbuf;
   #else
       for (Char16* p = &_rep->c16a[0]; *p; p++)
       {
               if (*p <= PEGASUS_MAX_PRINTABLE_CHAR)
                   *p = toupper(*p);
       }
   #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 522 
Line 542 
 int String::compareNoCase(const String& s1, const String& s2) int String::compareNoCase(const String& s1, const String& s2)
 { {
 #ifdef PEGASUS_HAS_ICU #ifdef PEGASUS_HAS_ICU
     UnicodeString UniStr1((const UChar *)s1.getChar16Data(), (int32_t)s1.size());      return  u_strcasecmp((const UChar*)s1.getChar16Data(),
     UnicodeString UniStr2((const UChar *)s2.getChar16Data(), (int32_t)s2.size());                            (const UChar*)s2.getChar16Data(),
     UniStr1.toLower();                            U_FOLD_CASE_DEFAULT);
     UniStr2.toLower();  
     return (UniStr2.compare(UniStr1));  
 #else #else
     const Char16* _s1 = s1.getChar16Data();     const Char16* _s1 = s1.getChar16Data();
     const Char16* _s2 = s2.getChar16Data();     const Char16* _s2 = s2.getChar16Data();
Line 566 
Line 584 
 Boolean String::equalNoCase(const String& str1, const String& str2) Boolean String::equalNoCase(const String& str1, const String& str2)
 { {
 #ifdef PEGASUS_HAS_ICU #ifdef PEGASUS_HAS_ICU
     UnicodeString UniStr1((const UChar *)str1.getChar16Data(), (int32_t)str1.size());      return  compareNoCase(str1, str2) == 0;
     UnicodeString UniStr2((const UChar *)str2.getChar16Data(), (int32_t)str2.size());  
     UniStr1.toLower();  
     UniStr2.toLower();  
     return (UniStr1 == UniStr2);  
 #else #else
     if (str1.size() != str2.size())     if (str1.size() != str2.size())
         return false;         return false;
Line 597 
Line 611 
 } }
  
 // UTF8 specific code: // UTF8 specific code:
 String& String::assignUTF8(const char* str)  String& String::assign(const char* str)
 { {
     _rep->c16a.clear();     _rep->c16a.clear();
     Uint32 n = strlen(str) + 1;     Uint32 n = strlen(str) + 1;
Line 616 
Line 630 
  
     Uint32 count;     Uint32 count;
  
     for(count = 0; ((msg16[count]) != Char16(0x00)) && (count <= n); ++count);      for(count = 0; ((msg16[count]) != Char16(0x00)) && (count < (n - 1)); ++count);
  
     _rep->c16a.append(msg16, count);     _rep->c16a.append(msg16, count);
  
Line 627 
Line 641 
     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 652 
Line 666 
     return CString(str1);     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
  // Wildcard String matching function that may be useful in the future  // Wildcard String matching function that may be useful in the future
Line 870 
Line 867 
 { {
  
 #if defined(PEGASUS_OS_OS400) #if defined(PEGASUS_OS_OS400)
     CString cstr = str.getCStringUTF8();      CString cstr = str.getCString();
     const char* utf8str = cstr;     const char* utf8str = cstr;
  
     os << utf8str;     os << utf8str;
  
 #elif defined(PEGASUS_HAS_ICU) #elif defined(PEGASUS_HAS_ICU)
   
     char *buf = NULL;     char *buf = NULL;
     const int size = str.size() * 6;     const int size = str.size() * 6;
     UnicodeString UniStr((const UChar *)str.getChar16Data(), (int32_t)str.size());     UnicodeString UniStr((const UChar *)str.getChar16Data(), (int32_t)str.size());
Line 888 
Line 884 
     os.flush();     os.flush();
     delete [] buf;     delete [] buf;
 #else #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 936 
Line 930 
     return String::compare(str1, str2) >= 0;     return String::compare(str1, str2) >= 0;
 } }
  
 #ifndef PEGASUS_REMOVE_DEPRECATED  
 int CompareNoCase(const char* s1, const char* s2)  
 {  
     return System::strcasecmp(s1, s2);  
 }  
 #endif  
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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