(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.34 and 1.98

version 1.34, 2002/04/18 23:33:17 version 1.98, 2005/02/05 22:59:24
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2005////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001 The Open group, BMC Software, Tivoli Systems, IBM  // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
   // 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 22 
Line 29 
 // //
 // Author: Mike Brasher (mbrasher@bmc.com) // Author: Mike Brasher (mbrasher@bmc.com)
 // //
 // Modified By:  // Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
  
 #include <cctype> #include <cctype>
   #include <cstring>
 #include "String.h" #include "String.h"
 #include "Exception.h"  #include "Array.h"
 #include "String.h"  #include "InternalException.h"
 #include <iostream> #include <iostream>
   #include <fstream>
   
   #include "CommonUTF.h"
   
   #ifdef PEGASUS_HAS_ICU
   #include <unicode/unistr.h>
   #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
   //
 const String String::EMPTY;  ///////////////////////////////////////////////////////////////////////////////
  
 #if 0    // Apparently dead code  CString::CString()
 static inline void _SkipWhitespace(const Char16*& p)      : _rep(0)
 { {
     while (*p && isspace(*p))  
         p++;  
 } }
 #endif  
  
 inline Uint32 StrLen(const char* str)  CString::CString(const CString& cstr)
 { {
     if (!str)      _rep = 0;
         throw NullPointer();  
  
     return strlen(str);      if (cstr._rep)
       {
           _rep = (void*)new char[strlen((char*)cstr._rep)+1];
           strcpy((char*)_rep, (char*)cstr._rep);
       }
 } }
  
 inline Uint32 StrLen(const Char16* str)  CString::CString(char* cstr)
       : _rep(cstr)
 { {
     if (!str)  
         throw NullPointer();  
   
     Uint32 n = 0;  
   
     while (*str++)  
         n++;  
   
     return n;  
 } }
  
 String::String()  CString::~CString()
 { {
     _rep.append('\0');      if (_rep)
       {
           delete [] (char*)_rep;
       }
 } }
  
 String::String(const String& x) : _rep(x._rep)  CString& CString::operator=(const CString& cstr)
 { {
       if (&cstr != this)
       {
           if (_rep)
           {
               delete [] (char*)_rep;
               _rep = 0;
 } }
           if (cstr._rep)
 String::String(const String& x, Uint32 n)  
 { {
     _rep.append('\0');              _rep = (char*)new char[strlen((char*)cstr._rep)+1];
     append(x.getData(), n);              strcpy((char*)_rep, (char*)cstr._rep);
           }
       }
       return *this;
 } }
  
 String::String(const Char16* x) : _rep(x, StrLen(x) + 1)  CString::operator const char*() const
 { {
       return (char*)_rep;
 } }
  
 String::String(const Char16* x, Uint32 n)  ///////////////////////////////////////////////////////////////////////////////
   //
   // String
   //
   ///////////////////////////////////////////////////////////////////////////////
   
   const String String::EMPTY = String();
   
   Uint32 _strnlen(const char* str, Uint32 n)
 { {
     assign(x, n);      if (!str)
 }          throw NullPointer();
  
 String::String(const char* str)      for (Uint32 i=0; i<n; i++)
 { {
     Uint32 n = ::strlen(str) + 1;          if (!*str)
     reserve(n);          {
               return i;
           }
       }
  
     while (n--)      return n;
         _rep.append(*str++);  
 } }
  
 String::String(const char* str, Uint32 n_)  Uint32 _strnlen(const Char16* str, Uint32 n)
 { {
     Uint32 n = _pegasusMin(strlen(str), n_);      if (!str)
     reserve(n + 1);          throw NullPointer();
   
     while (n--)  
         _rep.append(*str++);  
  
     _rep.append('\0');      for (Uint32 i=0; i<n; i++)
       {
           if (!*str)
           {
               return i;
           }
 } }
  
 String& String::assign(const Char16* x)      return n;
 {  
     _rep.clear();  
     _rep.append(x, StrLen(x) + 1);  
     return *this;  
 } }
  
 String& String::assign(const Char16* str, Uint32 n)  inline Uint32 _StrLen(const char* str)
 { {
     _rep.clear();      if (!str)
     Uint32 m = _pegasusMin(StrLen(str), n);          throw NullPointer();
     _rep.append(str, m);  
     _rep.append('\0');      return strlen(str);
     return *this;  
 } }
  
 String& String::assign(const char* x)  inline Uint32 _StrLen(const Char16* str)
 { {
     _rep.clear();      if (!str)
     Uint32 n = strlen(x);          throw NullPointer();
     _rep.reserve(n + 1);  
  
     while (n--)      Uint32 n = 0;
         _rep.append(*x++);  
  
     _rep.append('\0');      while (*str++)
           n++;
  
     return *this;      return n;
 } }
  
 String& String::assign(const char* x, Uint32 n_)  class StringRep
 { {
     _rep.clear();  public:
       StringRep()
       {}
       StringRep(const StringRep& r)
           : c16a(r.c16a)
       {}
       StringRep(const Char16* str)
           : c16a(str, _StrLen(str) + 1)
       {}
  
     Uint32 n = _pegasusMin(strlen(x), n_);      Array<Char16> c16a;
     _rep.reserve(n + 1);  };
  
     while (n--)  String::String()
         _rep.append(*x++);  {
       _rep = new StringRep;
     _rep.append('\0');      _rep->c16a.append('\0');
   
     return *this;  
 } }
  
 char* String::allocateCString(Uint32 extraBytes, Boolean noThrow) const  String::String(const String& str)
 { {
     Uint32 n = size() + 1;    if (str._rep != NULL)
     char* str = new char[n + extraBytes];  
     char* p = str;  
     const Char16* q = getData();  
   
     for (Uint32 i = 0; i < n; i++)  
     {     {
         Uint16 c = *q++;      _rep = new StringRep(*str._rep);
         *p++ = char(c);    }
     else
         if ((c & 0xff00) && !noThrow)    {
             throw TruncatedCharacter();      _rep = new StringRep();
     }     }
   
     return str;  
 } }
  
 void String::appendToCString(  
     char* str,  
     Uint32 length,  
     Boolean noThrow) const  
 {  
     if (!str)  
         throw NullPointer();  
  
     Uint32 n = _pegasusMin(size(), length);  String::String(const String& str, Uint32 n)
   {
       _rep = new StringRep;
       assign(str.getChar16Data(), n);
   }
  
     char* p = str + strlen(str);  String::String(const Char16* str)
     const Char16* q = getData();  {
       _rep = new StringRep(str);
   }
  
     for (Uint32 i = 0; i < n; i++)  String::String(const Char16* str, Uint32 n)
     {     {
         Uint16 c = *q++;      _rep = new StringRep;
         *p++ = char(c);      assign(str, n);
   }
  
         if ((c & 0xff00) && !noThrow)  String::String(const char* str)
             throw TruncatedCharacter();  {
       _rep = new StringRep;
       assign(str);
     }     }
  
     *p = '\0';  String::String(const char* str, Uint32 n)
   {
       _rep = new StringRep;
       assign(str, n);
 } }
  
 Char16& String::operator[](Uint32 i)  String::~String()
 { {
     if (i > size())      delete _rep;
         ThrowOutOfBounds();  }
  
     return _rep[i];  String& String::operator=(const String& str)
   {
       if (&str != this)
       {
           assign(str);
       }
       return *this;
 } }
  
 const Char16 String::operator[](Uint32 i) const  String& String::assign(const String& str)
 { {
     if (i > size())      _rep->c16a = str._rep->c16a;
         ThrowOutOfBounds();      return *this;
   }
  
     return _rep[i];  String& String::assign(const Char16* str)
   {
       _rep->c16a.clear();
       _rep->c16a.append(str, _StrLen(str) + 1);
       return *this;
 } }
  
 String& String::append(const Char16* str, Uint32 n)  String& String::assign(const Char16* str, Uint32 n)
 { {
     Uint32 m = _pegasusMin(StrLen(str), n);      _rep->c16a.clear();
     _rep.reserve(_rep.size() + m);      Uint32 m = _strnlen(str, n);
     _rep.remove(_rep.size() - 1);      _rep->c16a.append(str, m);
     _rep.append(str, m);      _rep->c16a.append('\0');
     _rep.append('\0');  
     return *this;     return *this;
 } }
  
 void String::remove(Uint32 pos, Uint32 size)  String& String::assign(const char* str, Uint32 n)
 { {
     if (size == PEG_NOT_FOUND)      char *tmpStr = new char[n+1];
         size = this->size() - pos;      memset(tmpStr,0x00,n+1);
  
     if (pos + size > this->size())      strncpy(tmpStr,str,n);
         ThrowOutOfBounds();      assign(tmpStr);
       delete [] tmpStr;
  
     if (size)      return *this;
         _rep.remove(pos, size);  
 } }
  
 int String::compare(const Char16* s1, const Char16* s2, Uint32 n)  void String::clear()
 {  
     while (n--)  
     {     {
         int r = *s1++ - *s2++;      _rep->c16a.clear();
       _rep->c16a.append('\0');
         if (r)  
             return r;  
     }     }
  
     return 0;  void String::reserveCapacity(Uint32 capacity)
   {
       _rep->c16a.reserveCapacity(capacity + 1);
 } }
  
 int String::compareNoCase(const char* s1, const char* s2, Uint32 n)  Uint32 String::size() const
 { {
     while (n--)      return _rep->c16a.size() - 1;
     {  
         int r = tolower(*s1++) - tolower(*s2++);  
   
         if (r)  
             return r;  
     }     }
  
     return 0;  const Char16* String::getChar16Data() const
   {
       return _rep->c16a.getData();
 } }
  
 Boolean String::equal(const String& x, const String& y)  Char16& String::operator[](Uint32 index)
 { {
     if (x.size() != y.size())      if (index > size())
         return false;          throw IndexOutOfBoundsException();
  
     return String::compare(x.getData(), y.getData(), x.size()) == 0;      return _rep->c16a[index];
 } }
  
 Boolean String::equal(const String& x, const Char16* y)  const Char16 String::operator[](Uint32 index) const
 { {
     if (x.size() != StrLen(y))      if (index > size())
         return false;          throw IndexOutOfBoundsException();
  
     return String::compare(x.getData(), y, x.size()) == 0;      return _rep->c16a[index];
 } }
  
 Boolean String::equal(const Char16* x, const String& y)  String& String::append(const Char16& c)
 { {
     return equal(y, x);      _rep->c16a.insert(_rep->c16a.size() - 1, c);
       return *this;
 } }
  
 Boolean String::equal(const String& x, const char* y)  String& String::append(const Char16* str, Uint32 n)
 { {
     return equal(x, String(y));      Uint32 m = _strnlen(str, n);
       _rep->c16a.reserveCapacity(_rep->c16a.size() + m);
       _rep->c16a.remove(_rep->c16a.size() - 1);
       _rep->c16a.append(str, m);
       _rep->c16a.append('\0');
       return *this;
 } }
  
 Boolean String::equal(const char* x, const String& y)  String& String::append(const String& str)
 { {
     return equal(String(x), y);      return append(str.getChar16Data(), str.size());
 } }
  
 Boolean String::equalNoCase(const String& x, const String& y)  void String::remove(Uint32 index, Uint32 size)
 { {
     if (x.size() != y.size())      if (size == PEG_NOT_FOUND)
         return false;          size = this->size() - index;
   
     const Char16* p = x.getData();  
     const Char16* q = y.getData();  
  
     Uint32 n = x.size();      if (index + size > this->size())
           throw IndexOutOfBoundsException();
  
     while (n--)      if (size)
     {          _rep->c16a.remove(index, size);
 #ifdef PEGASUS_HAS_EBCDIC  
         if (*p <= 255 && *q <= 255)  
 #else  
         if (*p <= 127 && *q <= 127)  
 #endif  
         {  
             if (tolower(*p++) != tolower(*q++))  
                 return false;  
         }  
         else if (*p++ != *q++)  
             return false;  
     }  
   
     return true;  
 } }
  
 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 367 
  
 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 378 
     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 393 
  
 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 394 
Line 416 
             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 402 
Line 424 
     return PEG_NOT_FOUND;     return PEG_NOT_FOUND;
 } }
  
 Uint32 String::find(const char* s) const  
 {  
     return find(String(s));  
 }  
   
 Uint32 String::find(const Char16* 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 428 
Line 440 
  
 void String::toLower() void String::toLower()
 { {
     for (Char16* p = &_rep[0]; *p; p++)      const char * noLocale = NULL;
       String::toLower(noLocale);
   }
   void String::toLower(const char * strLocale)
     {     {
 #ifdef PEGASUS_HAS_EBCDIC  #ifdef PEGASUS_HAS_ICU
         if (*p <= 255)      UnicodeString UniStr((const UChar *)_rep->c16a.getData());
       if(strLocale == NULL)
       {
           UniStr.toLower();
       }
       else
       {
           Locale loc(strLocale);
           if(loc.isBogus())
           {
               throw InvalidNameException(String(strLocale));
           }
           UniStr.toLower(loc);
       }
       UniStr.append((UChar)'\0');
   
       assign((Char16*)UniStr.getBuffer());
 #else #else
         if (*p <= 127)      for (Char16* p = &_rep->c16a[0]; *p; p++)
 #endif      {
           if (*p <= PEGASUS_MAX_PRINTABLE_CHAR)
             *p = tolower(*p);             *p = tolower(*p);
     }     }
   #endif
 } }
  
 void String::translate(Char16 fromChar, Char16 toChar)  void String::toUpper(const char * strLocale)
   {
   #ifdef PEGASUS_HAS_ICU
       UnicodeString UniStr((const UChar *)_rep->c16a.getData());
       if(strLocale == NULL)
       {
           UniStr.toUpper();
       }
       else
 { {
     for (Char16* p = &_rep[0]; *p; p++)          Locale loc(strLocale);
           if(loc.isBogus())
     {     {
         if (*p == fromChar)              throw InvalidNameException(String(strLocale));
             *p = toChar;  
     }     }
           UniStr.toUpper(loc);
 } }
       UniStr.append((UChar)'\0');
  
 int String::compare(const Char16* s1, const Char16* s2)      assign((Char16*)UniStr.getBuffer());
   #else
       for (Char16* p = &_rep->c16a[0]; *p; p++)
 { {
     while (*s1 && *s2)          if (*p <= PEGASUS_MAX_PRINTABLE_CHAR)
               *p = toupper(*p);
       }
   #endif
   }
   
   int String::compare(const String& s1, const String& s2, Uint32 n)
     {     {
         int r = *s1++ - *s2++;      const Char16* s1c16 = s1.getChar16Data();
       const Char16* s2c16 = s2.getChar16Data();
   
       while (n--)
       {
           int r = *s1c16++ - *s2c16++;
  
         if (r)         if (r)
             return r;             return r;
     }     }
  
     if (*s2)      return 0;
   }
   
   int String::compare(const String& s1, const String& s2)
   {
       const Char16* s1c16 = s1.getChar16Data();
       const Char16* s2c16 = s2.getChar16Data();
   
       while (*s1c16 && *s2c16)
       {
           int r = *s1c16++ - *s2c16++;
   
           if (r)
               return r;
       }
   
       if (*s2c16)
         return -1;         return -1;
     else if (*s1)      else if (*s1c16)
         return 1;         return 1;
  
     return 0;     return 0;
 } }
  
 int String::compareNoCase(const char* s1, const char* s2)  int String::compareNoCase(const String& s1, const String& s2)
 { {
     while (*s1 && *s2)      const char * noLocale = NULL;
       return String::compareNoCase(s1, s2, noLocale);
   }
   
   int String::compareNoCase(const String& s1, const String& s2,const char * strLocale)
     {     {
         int r = tolower(*s1++) - tolower(*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());
       if(strLocale == NULL)
       {
           UniStr1.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
       // 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.
       // (ref. bugzilla 1207)
       return (UniStr1.compare(UniStr2));
   #else
       const Char16* _s1 = s1.getChar16Data();
       const Char16* _s2 = s2.getChar16Data();
   
       while (*_s1 && *_s2)
       {
           int r;
   
           if (*_s1 <= PEGASUS_MAX_PRINTABLE_CHAR &&
               *_s2 <= PEGASUS_MAX_PRINTABLE_CHAR)
           {
               r = tolower(*_s1++) - tolower(*_s2++);
           }
           else
           {
               r = *_s1++ - *_s2++;
           }
  
         if (r)         if (r)
             return r;             return r;
     }     }
  
     if (*s2)      if (*_s2)
         return -1;         return -1;
     else if (*s1)      else if (*_s1)
         return 1;         return 1;
  
     return 0;     return 0;
   #endif
 } }
  
 PEGASUS_STD(ostream)& operator<<(PEGASUS_STD(ostream)& os, const String& x)  Boolean String::equal(const String& str1, const String& str2)
 { {
     for (Uint32 i = 0, n = x.size(); i < n; i++)      return String::compare(str1, str2) == 0;
         os << x[i];  
   
     return os;  
 } }
  
 void String::toLower(char* str)  Boolean String::equalNoCase(const String& str1, const String& str2)
 { {
     while (*str)      const char * noLocale = NULL;
         tolower(*str++);      return String::equalNoCase(str1, str2, noLocale);
 } }
  
 String ToLower(const String& str)  Boolean String::equalNoCase(const String& str1, const String& str2,const char * strLocale)
   {
   #ifdef PEGASUS_HAS_ICU
       UnicodeString UniStr1((const UChar *)str1.getChar16Data(), (int32_t)str1.size());
       UnicodeString UniStr2((const UChar *)str2.getChar16Data(), (int32_t)str2.size());
       if(strLocale == NULL)
 { {
     String tmp(str);          UniStr1.toLower();
           UniStr2.toLower();
       }
       else
       {
           Locale loc(strLocale);
           if(loc.isBogus())
           {
               throw InvalidNameException(String(strLocale));
           }
           UniStr1.toLower(loc);
           UniStr2.toLower(loc);
       }
       return (UniStr1 == UniStr2);
   #else
       if (str1.size() != str2.size())
           return false;
   
       const Char16* p = str1.getChar16Data();
       const Char16* q = str2.getChar16Data();
  
     for (Uint32 i = 0, n = tmp.size(); i < n; i++)      Uint32 n = str1.size();
   
       while (n--)
       {
           if (*p <= PEGASUS_MAX_PRINTABLE_CHAR &&
               *q <= PEGASUS_MAX_PRINTABLE_CHAR)
     {     {
         Char16 c = tmp[i];              if (tolower(*p++) != tolower(*q++))
                   return false;
           }
           else if (*p++ != *q++)
               return false;
       }
  
 #ifdef PEGASUS_HAS_EBCDIC      return true;
         if (c <= 255)  
 #else  
         if (c <= 127)  
 #endif #endif
             tmp[i] = tolower(c);  
     }     }
  
     return tmp;  // 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;
 } }
  
 int CompareNoCase(const char* s1, const char* s2)  CString String::getCString() const
 { {
     while (*s1 && *s2)      Uint32 n = 3*size() + 1;
     {      char* str = new char[n];
         int r = tolower(*s1++) - tolower(*s2++);  
  
         if (r)      const Char16* msg16 = getChar16Data();
             return r;  
       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);
     }     }
  
     if (*s2)  #if 0
         return -1;  // ATTN-RK-P3-20020603: This code is not completely correct
     else if (*s1)   // Wildcard String matching function that may be useful in the future
         return 1;  // The following code was provided by Bob Blair.
  
     return 0;  /* _StringMatch Match input MatchString against a GLOB style pattern
          Note that MatchChar is the char type so that this source
          in portable to different string types. This is an internal function
   
     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.
    */
   
   /* MatchChar defined as a separate entity because this function source used
       elsewhere was an unsigned char *. Here we use Uint16 to  maintain 16 bit
       size.
   */
   typedef Uint16 MatchChar;
   
   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;
 } }
  
 Boolean GetLine(PEGASUS_STD(istream)& is, String& line)  inline Boolean _Equal(MatchChar ch1, MatchChar ch2, int nocase)
 { {
     line.clear();      // ICU_TODO:  If ICU is available we should do this the correct way.
       if (nocase)
           return _ToLower(ch1) == _ToLower(ch2);
       else
           return ch1 == ch2;
   }
  
     Boolean gotChar = false;  
     char c;  
  
     while (is.get(c))  static const MatchChar *
   _matchrange(const MatchChar *range, MatchChar c, int nocase)
   {
     const MatchChar *p = range;
     const MatchChar *rstart = range + 1;
     const MatchChar *rend = 0;
     MatchChar compchar;
   
     for (rend = rstart; *rend && *rend != ']'; rend++);
     if (*rend == ']') {  // if there is an end to this pattern
       for (compchar = *rstart; rstart != rend; rstart++) {
         if (_Equal(*rstart, c, nocase))
           return ++rend;
         if (*rstart == '-') {
           rstart++;
           if (c >= compchar && c <= *rstart)
             return ++rend;
         }
       }
     }
     return (const MatchChar *)0;
   }
   
   static int
   _StringMatch(
       const MatchChar *testString,
       const MatchChar *pattern,
       int nocase )                /* Ignore case if this is true */
   {
     const MatchChar *pat = pattern;
     const MatchChar *str = testString;
     unsigned int done = 0;
     unsigned int res = 0;  // the result: 1 == match
   
     while (!done) { // main loop walks through pattern and test string
       //cerr << "Comparing <" << *pat << "> and <" << *str << ">" << endl;
       if (!*pat) {                                         //end of pattern
         done = 1;                                          // we're done
         if (!*str)                                         //end of test, too?
           res = 1;                                         // then we matched
       } else {                                             //Not end of pattern
         if (!*str) {                                       // but end of test
           done = 1;                                        // We're done
           if (*pat == '*')                                 // If pattern openends
             res = 1;                                       //  then we matched
         } else {                                           //Not end of test
           if (*pat == '*') {                               //Ambiguuity found
             if (!*++pat) {                                 //and it ends pattern
               done = 1;                                    //  then we're done
               res = 1;                                     //  and match
             } else {                                       //if it doesn't end
               while (!done) {                              //  until we're done
                 if (_StringMatch(str, pat, nocase)) {      //  we recurse
                   done = 1;                                //if it recurses true
                   res = 1;                                 //  we done and match
                 } else {                                   //it recurses false
                   if (!*str)                               // see if test is done
                     done = 1;                              //  yes: we done
                   else                                     // not done:
                     str++;                                 //   keep testing
                 } // end test on recursive call
               } // end looping on recursive calls
             } // end logic when pattern is ambiguous
           } else {                                         //pattern not ambiguus
             if (*pat == '?') {                             //pattern is 'any'
               pat++, str++;                                //  so move along
             } else if (*pat == '[') {                      //see if it's a range
               pat = _matchrange(pat, *str, nocase);         // and is a match
               if (!pat) {                                  //It is not a match
                 done = 1;                                  //  we're done
                 res = 0;                                   //  no match
               } else {                                     //Range matches
                 str++, pat++;                              //  keep going
               }
             } else {               // only case left is individual characters
               if (!_Equal(*pat++, *str++, nocase))         // if they don't match
                 done = 1;                                  //   bail.
             }
           }  // end ("pattern is not ambiguous (*)" logic
         } // end logic when pattern and string still have data
       } // end logic when pattern still has data
     } // end main loop
     return res;
   }
   
   
       /** 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)
   {
       return _StringMatch(
           (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)
     {     {
         gotChar = true;      return _StringMatch(
           (Uint16*)str.getChar16Data(), (Uint16*)pattern.getChar16Data(), 1) != 0;
   }
   #endif
   
  
         if (c == '\n')  ///////////////////////////////////////////////////////////////////////////////
             break;  //
   // String-related functions
   //
   ///////////////////////////////////////////////////////////////////////////////
  
         line.append(c);  Boolean operator==(const String& str1, const String& str2)
   {
       return String::equal(str1, str2);
     }     }
  
     return gotChar;  Boolean operator==(const String& str1, const char* str2)
   {
       return String::equal(str1, str2);
 } }
  
 String::~String()  Boolean operator==(const char* str1, const String& str2)
 { {
       return String::equal(str1, str2);
 } }
  
 String& String::assign(const String& x)  Boolean operator!=(const String& str1, const String& str2)
 { {
     _rep = x._rep;      return !String::equal(str1, str2);
     return *this;  
 } }
  
 String& String::append(const Char16& c)  PEGASUS_STD(ostream)& operator<<(PEGASUS_STD(ostream)& os, const String& str)
 { {
     _rep.insert(_rep.size() - 1, c);  
     return *this;  #if defined(PEGASUS_OS_OS400)
       CString cstr = str.getCString();
       const char* utf8str = cstr;
   
       os << utf8str;
   
   #elif defined(PEGASUS_HAS_ICU)
           if(os == cout || os == cerr){
               char *buf = NULL;
           const int size = str.size() * 6;
           UnicodeString UniStr((const UChar *)str.getChar16Data(), (int32_t)str.size());
           Uint32 bufsize = UniStr.extract(0,size,buf);
   
           buf = new char[bufsize+1];
           UniStr.extract(0,bufsize,buf);
           os << buf;
           os.flush();
           delete [] buf;
           }else{
                   CString cstr = str.getCString();
           const char* utf8str = cstr;
           os << utf8str;
 } }
  
 void String::clear()  #else
           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:
                   char buffer[8];
                   sprintf(buffer, "\\x%04X", code);
                   os << buffer;
                   }
           }
   #endif // End of PEGASUS_HAS_ICU #else leg.
   
       return os;
   }
   
   String operator+(const String& str1, const String& str2)
   {
       return String(str1).append(str2);
   }
   
   Boolean operator<(const String& str1, const String& str2)
 { {
     _rep.clear();      return String::compare(str1, str2) < 0;
     _rep.append('\0');  
 } }
  
 void String::print() const  Boolean operator<=(const String& str1, const String& str2)
 { {
     cout << *this << endl;      return String::compare(str1, str2) <= 0;
 } }
  
 void String::reserve(Uint32 capacity)  Boolean operator>(const String& str1, const String& str2)
 { {
     _rep.reserve(capacity + 1);      return String::compare(str1, str2) > 0;
 } }
  
 const Array<String>& EmptyStringArray()  Boolean operator>=(const String& str1, const String& str2)
 { {
     static Array<String> tmp;      return String::compare(str1, str2) >= 0;
     return tmp;  
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END


Legend:
Removed from v.1.34  
changed lines
  Added in v.1.98

No CVS admin address has been configured
Powered by
ViewCVS 0.9.2