(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.7 and 1.28.2.1

version 1.7, 2001/04/10 22:42:55 version 1.28.2.1, 2001/08/02 02:15:49
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.7  2001/04/10 22:42:55  karl  
 // Correct error in String find  
 // //
 // Revision 1.6  2001/04/09 20:18:47  karl  //%/////////////////////////////////////////////////////////////////////////////
 // add find substring function  
 //  
 // Revision 1.5  2001/03/09 19:49:32  karl  
 // long lines  
 //  
 // Revision 1.4  2001/02/26 04:33:28  mike  
 // Fixed many places where cim names compared with operator==(String,String).  
 // Changed all of these to use CIMName::equal()  
 //  
 // Revision 1.3  2001/02/11 17:19:30  mike  
 // added reverseFind() method  
 //  
 // Revision 1.2  2001/02/11 05:42:33  mike  
 // new  
 //  
 // Revision 1.1.1.1  2001/01/14 19:53:14  mike  
 // Pegasus import  
 //  
 //  
 //END_HISTORY  
  
  
 #include <cctype> #include <cctype>
 #include "String.h" #include "String.h"
 #include "Exception.h" #include "Exception.h"
 #include "String.h" #include "String.h"
   
 // For debugging  
 #include <iostream> #include <iostream>
 using namespace std;  
  
   PEGASUS_USING_STD;
  
 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;
  
   static inline void _SkipWhitespace(const Char16*& p)
   {
       while (*p && isspace(*p))
           p++;
   }
   
 inline Uint32 StrLen(const char* str) inline Uint32 StrLen(const char* str)
 { {
     if (!str)     if (!str)
Line 177 
Line 163 
  
 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 202 
Line 188 
     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 221 
Line 207 
  
 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 229 
Line 215 
  
 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 238 
Line 224 
 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 247 
Line 233 
  
 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)
Line 270 
Line 256 
     return 0;     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) 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 String::equal(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;
 } }
  
 Boolean String::equal(const Char16* x, const String& y) Boolean String::equal(const Char16* x, const String& y)
Line 301 
Line 300 
     return equal(String(x), y);     return equal(String(x), y);
 } }
  
   Boolean String::equalNoCase(const String& x, const String& y)
   {
       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 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 325 
Line 347 
             return  p - first;             return  p - first;
     }     }
  
     return Uint32(-1);      return PEG_NOT_FOUND;
 } }
  
 Uint32 String::find(const String& s) const Uint32 String::find(const String& s) const
 { {
     const Char16* pSubStr = s.getData();     const Char16* pSubStr = s.getData();
     const Char16* pStr = getData();     const Char16* pStr = getData();
     Uint32 subStrLen = s.getLength();      Uint32 subStrLen = s.size();
     Uint32 strLen = getLength();      Uint32 strLen = size();
  
     // loop to find first char match     // loop to find first char match
     Uint32 loc = 0;     Uint32 loc = 0;
Line 353 
Line 375 
                 return loc;                 return loc;
         }         }
     }     }
     return -1;      return PEG_NOT_FOUND;
 } }
   
 // ATTN:KS 5 apr 2000 Need to add the Char16* version. // ATTN:KS 5 apr 2000 Need to add the Char16* version.
 Uint32 String::find(const char* s) const Uint32 String::find(const char* s) const
 { {
Line 364 
Line 387 
 Uint32 String::reverseFind(Char16 c) const Uint32 String::reverseFind(Char16 c) const
 { {
     const Char16* first = getData();     const Char16* first = getData();
     const Char16* last = getData() + getLength();      const Char16* last = getData() + size();
  
     while (last != first)     while (last != first)
     {     {
Line 372 
Line 395 
             return last - first;             return last - first;
     }     }
  
     return Uint32(-1);      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 393 
Line 434 
     return 0;     return 0;
 } }
  
 std::ostream& operator<<(std::ostream& os, const String& x)  int String::compareNoCase(const char* s1, const char* s2)
   {
       while (*s1 && *s2)
       {
           int r = tolower(*s1++) - tolower(*s2++);
   
           if (r)
               return r;
       }
   
       if (*s2)
           return -1;
       else if (*s1)
           return 1;
   
       return 0;
   }
   
   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;
Line 411 
Line 470 
 { {
     String tmp(str);     String tmp(str);
  
     for (Uint32 i = 0, n = tmp.getLength(); i < n; i++)      for (Uint32 i = 0, n = tmp.size(); i < n; i++)
     {     {
         Char16 c = tmp[i];         Char16 c = tmp[i];
  
Line 422 
Line 481 
     return tmp;     return tmp;
 } }
  
   int CompareNoCase(const char* s1, const char* s2)
   {
       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::print() const
   {
       cout << *this << endl;
   }
   
   void String::reserve(Uint32 capacity)
   {
       _rep.reserve(capacity + 1);
   }
   
   const Array<String>& EmptyStringArray()
   {
       static Array<String> tmp;
       return tmp;
   }
   
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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