(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.4 and 1.18

version 1.4, 2001/02/26 04:33:28 version 1.18, 2001/05/20 20:34:01
Line 1 
Line 1 
 //BEGIN_LICENSE  //%/////////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000 The Open Group, BMC Software, Tivoli Systems, IBM // Copyright (c) 2000 The Open Group, BMC Software, Tivoli Systems, IBM
 // //
Line 17 
Line 17 
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 // DEALINGS IN THE SOFTWARE. // DEALINGS IN THE SOFTWARE.
 // //
 //END_LICENSE  //==============================================================================
 //BEGIN_HISTORY  
 // //
 // Author:  // Author: Mike Brasher (mbrasher@bmc.com)
 // //
 // $Log$  // Modified By:
 // Revision 1.4  2001/02/26 04:33:28  mike  
 // Fixed many places where cim names were be 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"
   #include <iostream>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
Line 162 
Line 150 
  
 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 187 
Line 175 
     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 206 
Line 194 
  
 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 214 
Line 202 
  
 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 223 
Line 211 
 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 233 
Line 221 
 void String::remove(Uint32 pos, Uint32 size) void String::remove(Uint32 pos, Uint32 size)
 { {
     if (size == Uint32(-1))     if (size == Uint32(-1))
         size = getLength() - pos;          size = this->size() - pos;
  
     if (pos + size > getLength())      if (pos + size > this->size())
         ThrowOutOfBounds();         ThrowOutOfBounds();
  
     if (size)     if (size)
Line 255 
Line 243 
     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 286 
Line 287 
     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 == Uint32(-1))
             length = getLength() - pos;              length = size() - pos;
  
         return String(getData() + pos, length);         return String(getData() + pos, length);
     }     }
Line 313 
Line 337 
     return Uint32(-1);     return Uint32(-1);
 } }
  
   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 Uint32(-1);
   }
   
   // 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 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 327 
Line 385 
     return Uint32(-1);     return Uint32(-1);
 } }
  
   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)
 { {
     while (*s1 && *s2)     while (*s1 && *s2)
Line 345 
Line 421 
     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;
Line 363 
Line 439 
 { {
     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 374 
Line 450 
     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::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.4  
changed lines
  Added in v.1.18
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2