(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.1.1.1 and 1.24

version 1.1.1.1, 2001/01/14 19:53:14 version 1.24, 2001/06/16 23:10:05
Line 1 
Line 1 
 //BEGIN_LICENSE  //%/////////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000 The Open Group, BMC Software, Tivoli Systems, IBM  // Copyright (c) 2000, 2001 The Open group, BMC Software, Tivoli Systems, IBM
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a  // Permission is hereby granted, free of charge, to any person obtaining a copy
 // copy of this software and associated documentation files (the "Software"),  // of this software and associated documentation files (the "Software"), to
 // to deal in the Software without restriction, including without limitation  // deal in the Software without restriction, including without limitation the
 // the rights to use, copy, modify, merge, publish, distribute, sublicense,  // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 // and/or sell copies of the Software, and to permit persons to whom the  // sell copies of the Software, and to permit persons to whom the Software is
 // Software is furnished to do so, subject to the following conditions:  // furnished to do so, subject to the following conditions:
 // //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR  // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,  // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL  // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER  // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING  // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER  // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 // DEALINGS IN THE SOFTWARE.  // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
   // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 // //
 //END_LICENSE  //==============================================================================
 //BEGIN_HISTORY  
 // //
 // Author:  // Author: Mike Brasher (mbrasher@bmc.com)
 // //
 // $Log$  // Modified By:
 // Revision 1.1.1.1  2001/01/14 19:53:14  mike  
 // Pegasus import  
 // //
 //  //%/////////////////////////////////////////////////////////////////////////////
 //END_HISTORY  
  
   #include <cctype>
 #include "String.h" #include "String.h"
 #include "Exception.h" #include "Exception.h"
 #include "String.h" #include "String.h"
   #include <iostream>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
   #define PEGASUS_ARRAY_T String
   #include <Pegasus/Common/ArrayImpl.h>
   #undef PEGASUS_ARRAY_T
   
 const String String::EMPTY; const String String::EMPTY;
  
 void ThrowNullPointer()  static inline void _SkipWhitespace(const Char16*& p)
 { {
       while (*p && isspace(*p))
           p++;
   }
   
   inline Uint32 StrLen(const char* str)
   {
       if (!str)
     throw NullPointer();     throw NullPointer();
   
       return strlen(str);
 } }
  
 Uint32 StrLen(const Char16* str)  inline Uint32 StrLen(const Char16* str)
 { {
     if (!str)     if (!str)
         ThrowNullPointer();          throw NullPointer();
  
     Uint32 n = 0;     Uint32 n = 0;
  
Line 148 
Line 161 
  
 char* String::allocateCString(Uint32 extraBytes, Boolean noThrow) const char* String::allocateCString(Uint32 extraBytes, Boolean noThrow) const
 { {
     Uint32 n = getLength() + 1;      Uint32 n = size() + 1;
     char* str = new char[n + extraBytes];     char* str = new char[n + extraBytes];
     char* p = str;     char* p = str;
     const Char16* q = getData();     const Char16* q = getData();
Line 173 
Line 186 
     if (!str)     if (!str)
         throw NullPointer();         throw NullPointer();
  
     Uint32 n = _min(getLength(), length);      Uint32 n = _min(size(), length);
  
     char* p = str + strlen(str);     char* p = str + strlen(str);
     const Char16* q = getData();     const Char16* q = getData();
Line 192 
Line 205 
  
 Char16& String::operator[](Uint32 i) Char16& String::operator[](Uint32 i)
 { {
     if (i > getLength())      if (i > size())
         ThrowOutOfBounds();         ThrowOutOfBounds();
  
     return _rep[i];     return _rep[i];
Line 200 
Line 213 
  
 const Char16 String::operator[](Uint32 i) const const Char16 String::operator[](Uint32 i) const
 { {
     if (i > getLength())      if (i > size())
         ThrowOutOfBounds();         ThrowOutOfBounds();
  
     return _rep[i];     return _rep[i];
Line 209 
Line 222 
 String& String::append(const Char16* str, Uint32 n) String& String::append(const Char16* str, Uint32 n)
 { {
     Uint32 m = _min(StrLen(str), n);     Uint32 m = _min(StrLen(str), n);
     _rep.reserve(_rep.getSize() + m);      _rep.reserve(_rep.size() + m);
     _rep.remove(_rep.getSize() - 1);      _rep.remove(_rep.size() - 1);
     _rep.append(str, m);     _rep.append(str, m);
     _rep.append('\0');     _rep.append('\0');
     return *this;     return *this;
Line 218 
Line 231 
  
 void String::remove(Uint32 pos, Uint32 size) void String::remove(Uint32 pos, Uint32 size)
 { {
     if (size == Uint32(-1))      if (size == PEG_NOT_FOUND)
         size = getLength() - pos;          size = this->size() - pos;
  
     if (pos + size > getLength())      if (pos + size > this->size())
         ThrowOutOfBounds();         ThrowOutOfBounds();
  
     if (size)     if (size)
         _rep.remove(pos, size);         _rep.remove(pos, size);
 } }
  
 Boolean operator==(const String& x, const String& y)  int String::compare(const Char16* s1, const Char16* s2, Uint32 n)
   {
       while (n--)
       {
           int r = *s1++ - *s2++;
   
           if (r)
               return r;
       }
   
       return 0;
   }
   
   int String::compareNoCase(const char* s1, const char* s2, Uint32 n)
   {
       while (n--)
       {
           int r = tolower(*s1++) - tolower(*s2++);
   
           if (r)
               return r;
       }
   
       return 0;
   }
   
   Boolean String::equal(const String& x, const String& y)
 { {
     if (x.getLength() != y.getLength())      if (x.size() != y.size())
         return false;         return false;
  
     return String::compare(x.getData(), y.getData(), x.getLength()) == 0;      return String::compare(x.getData(), y.getData(), x.size()) == 0;
 } }
  
 Boolean operator==(const String& x, const Char16* y)  Boolean String::equal(const String& x, const Char16* y)
 { {
     if (x.getLength() != StrLen(y))      if (x.size() != StrLen(y))
         return false;         return false;
  
     return String::compare(x.getData(), y, x.getLength()) == 0;      return String::compare(x.getData(), y, x.size()) == 0;
 } }
  
 inline Boolean operator==(const Char16* x, const String& y)  Boolean String::equal(const Char16* x, const String& y)
 { {
     return operator==(y, x);      return equal(y, x);
 } }
  
 int String::compare(const Char16* s1, const Char16* s2, Uint32 n)  Boolean String::equal(const String& x, const char* y)
 { {
     while (n--)      return equal(x, String(y));
   }
   
   Boolean String::equal(const char* x, const String& y)
     {     {
         int r = *s1++ - *s2++;      return equal(String(x), y);
   }
  
         if (r)  Boolean String::equalNoCase(const String& x, const String& y)
             return r;  {
       if (x.size() != y.size())
           return false;
   
       const Char16* p = x.getData();
       const Char16* q = y.getData();
   
       Uint32 n = x.size();
   
       while (n--)
       {
           if (*p <= 127 && *q <= 127)
           {
               if (tolower(*p++) != tolower(*q++))
                   return false;
           }
           else if (*p++ != *q++)
               return false;
     }     }
  
     return 0;      return true;
 } }
  
 String String::subString(Uint32 pos, Uint32 length) const String String::subString(Uint32 pos, Uint32 length) const
 { {
     if (pos < getLength())      if (pos < size())
     {     {
         if (length == Uint32(-1))          if (length == PEG_NOT_FOUND)
             length = getLength() - pos;              length = size() - pos;
  
         return String(getData() + pos, length);         return String(getData() + pos, length);
     }     }
Line 285 
Line 345 
             return  p - first;             return  p - first;
     }     }
  
     return Uint32(-1);      return PEG_NOT_FOUND;
   }
   
   Uint32 String::find(const String& s) const
   {
       const Char16* pSubStr = s.getData();
       const Char16* pStr = getData();
       Uint32 subStrLen = s.size();
       Uint32 strLen = size();
   
       // loop to find first char match
       Uint32 loc = 0;
       for( ; loc <= (strLen-subStrLen); loc++)
       {
           if (*pStr++ == *pSubStr)  // match first char
           {
               // point to substr 2nd char
               const Char16* p = pSubStr + 1;
   
               // Test remaining chars for equal
               Uint32 i = 1;
               for (; i < subStrLen; i++)
                   if (*pStr++ != *p++ )
                       {pStr--; break;} // break from loop
               if (i == subStrLen)
                   return loc;
           }
       }
       return PEG_NOT_FOUND;
   }
   
   // ATTN:KS 5 apr 2000 Need to add the Char16* version.
   Uint32 String::find(const char* s) const
   {
       return find(String(s));
   }
   
   Uint32 String::reverseFind(Char16 c) const
   {
       const Char16* first = getData();
       const Char16* last = getData() + size();
   
       while (last != first)
       {
           if (*--last == c)
               return last - first;
       }
   
       return PEG_NOT_FOUND;
   }
   
   void String::toLower()
   {
       for (Char16* p = &_rep[0]; *p; p++)
       {
           if (*p <= 127)
               *p = tolower(*p);
       }
   }
   
   void String::translate(Char16 fromChar, Char16 toChar)
   {
       for (Char16* p = &_rep[0]; *p; p++)
       {
           if (*p == fromChar)
               *p = toChar;
       }
 } }
  
 int String::compare(const Char16* s1, const Char16* s2) int String::compare(const Char16* s1, const Char16* s2)
Line 306 
Line 432 
     return 0;     return 0;
 } }
  
 std::ostream& operator<<(std::ostream& os, const String& x)  PEGASUS_STD(ostream)& operator<<(PEGASUS_STD(ostream)& os, const String& x)
 { {
     for (Uint32 i = 0, n = x.getLength(); i < n; i++)      for (Uint32 i = 0, n = x.size(); i < n; i++)
         os << x[i];         os << x[i];
  
     return os;     return os;
 } }
  
 Boolean operator==(const String& x, const char* y)  void String::toLower(char* str)
 { {
     return operator==(x, String(y));      while (*str)
           tolower(*str++);
   }
   
   String ToLower(const String& str)
   {
       String tmp(str);
   
       for (Uint32 i = 0, n = tmp.size(); i < n; i++)
       {
           Char16 c = tmp[i];
   
           if (c <= 127)
               tmp[i] = tolower(c);
       }
   
       return tmp;
 } }
  
 Boolean operator==(const char* x, const String& y)  int CompareNoCase(const char* s1, const char* s2)
 { {
     return operator==(String(x), y);      while (*s1 && *s2)
       {
           int r = tolower(*s1++) - tolower(*s2++);
   
           if (r)
               return r;
       }
   
       if (*s2)
           return -1;
       else if (*s1)
           return 1;
   
       return 0;
   }
   
   Boolean GetLine(PEGASUS_STD(istream)& is, String& line)
   {
       line.clear();
   
       Boolean gotChar = false;
       char c;
   
       while (is.get(c))
       {
           gotChar = true;
   
           if (c == '\n')
               break;
   
           line.append(c);
       }
   
       return gotChar;
   }
   
   String::~String()
   {
   }
   
   String& String::assign(const String& x)
   {
       _rep = x._rep;
       return *this;
   }
   
   String& String::append(const Char16& c)
   {
       _rep.insert(_rep.size() - 1, c);
       return *this;
   }
   
   void String::clear()
   {
       _rep.clear();
       _rep.append('\0');
   }
   
   void String::reserve(Uint32 capacity)
   {
       _rep.reserve(capacity + 1);
   }
   
   const Array<String>& EmptyStringArray()
   {
       static Array<String> tmp;
       return tmp;
   }
   
   void String::split(const String& line, Array<String>& fields)
   {
       fields.clear();
   
       for (const Char16* p = line.getData(); *p; p++)
       {
           _SkipWhitespace(p);
   
           if (!*p)
               break;
   
           String field;
   
           if (*p == '"')
           {
               p++;
   
               for (; *p && *p != '"'; p++)
               {
                   if (*p == '\\')
                   {
                       p++;
   
                       switch (*p)
                       {
                           case '\0':
                               break;
   
                           case 'n':
                               field.append('\n');
                               break;
   
                           case 't':
                               field.append('\t');
                               break;
   
                           case 'r':
                               field.append('\r');
                               break;
   
                           case 'f':
                               field.append('\f');
                               break;
   
                           default:
                               field.append(*p);
                       }
                   }
                   else
                       field.append(*p);
               }
   
               fields.append(field);
           }
           else
           {
               for (; *p && !isspace(*p); p++)
               {
                   if (*p == '\\')
                   {
                       p++;
   
                       switch (*p)
                       {
                           case '\0':
                               break;
   
                           case 'n':
                               field.append('\n');
                               break;
   
                           case 't':
                               field.append('\t');
                               break;
   
                           case 'r':
                               field.append('\r');
                               break;
   
                           case 'f':
                               field.append('\f');
                               break;
   
                           default:
                               field.append(*p);
                       }
                   }
                   else
                       field.append(*p);
               }
   
               fields.append(field);
           }
   
           if (!*p)
               break;
       }
   }
   
   void String::join(Array<String>& fields, String& line)
   {
       for (Uint32 i = 0, n = fields.size(); i < n; i++)
       {
           String tmp;
           Boolean hasSpaces = escape(fields[i], tmp);
   
           if (hasSpaces || tmp.size() == 0)
               line += '"';
   
           line += tmp;
   
           if (hasSpaces || tmp.size() == 0)
               line += '"';
   
           if (i + 1 != n)
               line += ' ';
       }
   }
   
   Boolean String::escape(const String& in, String& out)
   {
       Boolean hasSpaces = false;
   
       out.reserve(out.size() + (2 * in.size()));
   
       for (Uint32 i = 0, n = in.size(); i < n; i++)
       {
           Char16 c = in[i];
   
           switch (c)
           {
               case '\n':
                   out += "\\n";
                   break;
   
               case '\t':
                   out += "\\t";
                   break;
   
               case '\r':
                   out += "\\r";
                   break;
   
               case '\f':
                   out += "\\f";
                   break;
   
               case '\"':
                   out += "\\\"";
                   break;
   
               default:
                   out += c;
                   if (!hasSpaces)
                       hasSpaces = c == ' ';
                   break;
           }
       }
   
       return hasSpaces;
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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