(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.59 and 1.68

version 1.59, 2002/09/05 01:38:47 version 1.68, 2003/04/30 13:50:44
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 "InternalException.h"
 #include <iostream> #include <iostream>
   #include <fstream>
   #ifndef PEGASUS_REMOVE_DEPRECATED
   #include "System.h"  // for strcasecmp
   #endif
  
 PEGASUS_USING_STD; PEGASUS_USING_STD;
  
Line 162 
Line 167 
  
 String::String(const String& str) String::String(const String& str)
 { {
     if (str._rep != NULL)
     {
     _rep = new StringRep(*str._rep);     _rep = new StringRep(*str._rep);
 } }
     else
     {
       _rep = new StringRep();
     }
   }
   
  
 String::String(const String& str, Uint32 n) String::String(const String& str, Uint32 n)
 { {
Line 234 
Line 247 
     _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 247 
Line 260 
     _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 429 
Line 442 
     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 537 
Line 551 
 } }
  
  
   #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 659 
Line 674 
 } }
  
  
       /** 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.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) Boolean String::matchNoCase(const String& str, const String& pattern)
 { {
     return _StringMatch(     return _StringMatch(
         (Uint16*)str.getChar16Data(), (Uint16*)pattern.getChar16Data(), 1) != 0;         (Uint16*)str.getChar16Data(), (Uint16*)pattern.getChar16Data(), 1) != 0;
 } }
   #endif
  
  
 /////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
Line 700 
Line 747 
  
 PEGASUS_STD(ostream)& operator<<(PEGASUS_STD(ostream)& os, const String& str) PEGASUS_STD(ostream)& operator<<(PEGASUS_STD(ostream)& os, const String& str)
 { {
   #ifdef PEGASUS_OS_OS400
       int inc = 0;
       int newbuf = 0;
       char *buffer = NULL;
       char buffer1[201];
       char temp[2];
       if (str.size() > 200)
       {
           buffer = new char[str.size()+1];
           newbuf = 1;
       }
       else
           buffer = buffer1;
   #endif
   
     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];
  
         if (code > 0 && code <= PEGASUS_MAX_PRINTABLE_CHAR)         if (code > 0 && code <= PEGASUS_MAX_PRINTABLE_CHAR)
         {         {
   #ifdef PEGASUS_OS_OS400
               // process so messages don't get displayed as one char per line on OS/400.
               // Uint16 is a 2 byte character where byte 1 is '00' and byte 2 is
               // the character.  Also, the entire string needs to be sent to os instead
               // of one "byte/Unit16" at a time.  Sending one "byte/Uint16" at a time also
               // causes one character per line.  On OS/400 use of os << char(code) is a
               // restriction and no available c/cpp alternative was available. The
               // following was created to compensate for this restriction.
               memcpy(temp, &code, 2);
               memcpy(buffer+inc, &temp[1], 1);  // do not include the '00'
               if ((i+1) == n)  // last character
               {
                   memset(buffer+n, 0x00, 1); // add null terminator
                   os << buffer;  // return 1-byte per character string
                   if (buffer && newbuf != 0)
                       delete [] buffer;  // okay; this is the end of the loop
               }
               inc++;
   #else
             os << char(code);             os << char(code);
   #endif
         }         }
         else         else
         {         {
Line 745 
Line 827 
     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)
 { {
     while (*s1 && *s2)      return System::strcasecmp(s1, s2);
     {  
         int r = tolower(*s1++) - tolower(*s2++);  
   
         if (r)  
             return r;  
     }  
   
     if (*s2)  
         return -1;  
     else if (*s1)  
         return 1;  
   
     return 0;  
 } }
   #endif
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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