pegasus/src/Pegasus/Common/String.cpp - diff

Return to String.cpp CVS log

Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/String.cpp between version 1.11 and 1.35

version 1.11, 2001/04/14 07:35:05

version 1.35, 2002/04/19 02:27:30

Line 1

//BEGIN_LICENSE

//%/////////////////////////////////////////////////////////////////////////////

// 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.11 2001/04/14 07:35:05 mike

// Added config file loading to OptionManager

// Revision 1.10 2001/04/11 19:53:22 mike

//%/////////////////////////////////////////////////////////////////////////////

// More porting

// Revision 1.9 2001/04/11 07:03:02 mike

// Port to Unix

// 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 "String.h"

#include "Exception.h"

#include "String.h"

// For debugging

#include <iostream>

using namespace std;

PEGASUS_USING_STD;

PEGASUS_NAMESPACE_BEGIN

#define PEGASUS_ARRAY_T String

#include <Pegasus/Common/ArrayImpl.h>

#undef PEGASUS_ARRAY_T

const String String::EMPTY;

#if 0 // Apparently dead code

static inline void _SkipWhitespace(const Char16*& p)

{

while (*p && isspace(*p))

p++;

}

#endif

inline Uint32 StrLen(const char* str)

{

if (!str)

Line 130

Line 109

String::String(const char* str, Uint32 n_)

{

Uint32 n = _min(strlen(str), n_);

Uint32 n = _pegasusMin(strlen(str), n_);

reserve(n + 1);

while (n--)

Line 149

Line 128

String& String::assign(const Char16* str, Uint32 n)

{

_rep.clear();

Uint32 m = _min(StrLen(str), n);

Uint32 m = _pegasusMin(StrLen(str), n);

_rep.append(str, m);

_rep.append('\0');

return *this;

Line 173

Line 152

{

_rep.clear();

Uint32 n = _min(strlen(x), n_);

Uint32 n = _pegasusMin(strlen(x), n_);

_rep.reserve(n + 1);

while (n--)

Line 186

Line 165

char* String::allocateCString(Uint32 extraBytes, Boolean noThrow) const

{

Uint32 n = getLength() + 1;

Uint32 n = size() + 1;

char* str = new char[n + extraBytes];

char* p = str;

const Char16* q = getData();

Line 211

Line 190

if (!str)

throw NullPointer();

Uint32 n = _min(getLength(), length);

Uint32 n = _pegasusMin(size(), length);

char* p = str + strlen(str);

const Char16* q = getData();

Line 230

Line 209

Char16& String::operator[](Uint32 i)

{

if (i > getLength())

if (i > size())

ThrowOutOfBounds();

return _rep[i];

Line 238

Line 217

const Char16 String::operator[](Uint32 i) const

{

if (i > getLength())

if (i > size())

ThrowOutOfBounds();

return _rep[i];

Line 246

Line 225

String& String::append(const Char16* str, Uint32 n)

{

Uint32 m = _min(StrLen(str), n);

Uint32 m = _pegasusMin(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('\0');

return *this;

Line 256

Line 235

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();

if (size)

Line 279

Line 258

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 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)

{

if (x.getLength() != StrLen(y))

if (x.size() != StrLen(y))

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)

Line 310

Line 302

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--)

{

#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

{

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);

}

Line 334

Line 353

return p - first;

}

return Uint32(-1);

return PEG_NOT_FOUND;

}

Uint32 String::find(Uint32 pos, Char16 c) const

{

const Char16* data = getData();

for (Uint32 i = pos, n = size(); i < n; i++)

{

if (data[i] == c)

return i;

}

return PEG_NOT_FOUND;

}

Uint32 String::find(const String& s) const

{

const Char16* pSubStr = s.getData();

const Char16* pStr = getData();

Uint32 subStrLen = s.getLength();

Uint32 subStrLen = s.size();

Uint32 strLen = getLength();

Uint32 strLen = size();

if (subStrLen > strLen)

{

return PEG_NOT_FOUND;

}

// loop to find first char match

Uint32 loc = 0;

Line 362

Line 399

return loc;

}

return Uint32(-1);

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::find(const Char16* s) const

{

return find(String(s));

}

Uint32 String::reverseFind(Char16 c) const

{

const Char16* first = getData();

const Char16* last = getData() + getLength();

const Char16* last = getData() + size();

while (last != first)

{

Line 382

Line 423

return last - first;

}

return Uint32(-1);

return PEG_NOT_FOUND;

}

void String::toLower()

{

for (Char16* p = &_rep[0]; *p; p++)

{

#ifdef PEGASUS_HAS_EBCDIC

if (*p <= 255)

#else

if (*p <= 127)

#endif

*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)

Line 403

Line 466

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];

return os;

Line 421

Line 502

{

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];

#ifdef PEGASUS_HAS_EBCDIC

if (c <= 255)

#else

if (c <= 127)

#endif

tmp[i] = tolower(c);

}

return tmp;

}

int CompareIgnoreCase(const char* s1, const char* s2)

int CompareNoCase(const char* s1, const char* s2)

{

while (*s1 && *s2)

{

Line 450

Line 535

return 0;

}

Boolean GetLine(istream& is, String& line)

Boolean GetLine(PEGASUS_STD(istream)& is, String& line)

{

line.clear();

Line 470

Line 555

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;

}

#if 0 // Wildcard String matching function that may be useful in the future

// The following code was provided by Bob Blair.

// This code needs to be converted to work on Strings instead of const char*'s.

// Match two paths which may contain DOS-type wild-cards.

static const unsigned char *

matchrange(const unsigned char *range, unsigned char c) {

const unsigned char *p = range;

const unsigned char *rstart = range + 1;

const unsigned char *rend = 0;

unsigned char compchar;

for (rend = rstart; *rend && *rend != ']'; rend++);

if (*rend == ']') { // if there is an end to this thing

for (compchar = *rstart; rstart != rend; rstart++) {

if (*rstart == c)

return ++rend;

if (*rstart == '-') {

rstart++;

if (c >= compchar && c <= *rstart)

return ++rend;

}

return (const unsigned char *)0;

}

static int

matchem(const unsigned char *thePattern, const unsigned char *theTest) {

unsigned int done = 0;

unsigned int res = 0; // the result: 1 == match

const unsigned char *pat = thePattern;

const unsigned char *str = theTest;

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 (matchem(pat, str)) { // 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); // and is a match

if (!pat) { //It is not a match

done = 1; // we're done

res = 1; // no match

} else { //Range matches

str++, pat++; // keep going

}

} else { // only case left is individual characters

if (*pat++ != *str++) // 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;

}

int

Match::compare() {

if (!_pattern || !_test)

return 0;

return matchem(_pattern, _test);

}

#endif

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.11
changed lines
	Added in v.1.35

No CVS admin address has been configured