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.4 and 1.40

version 1.4, 2001/02/26 04:33:28

version 1.40, 2002/05/09 22:29:54

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: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)

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

#include "Exception.h"

#include "String.h"

#include <iostream>

PEGASUS_USING_STD;

PEGASUS_NAMESPACE_BEGIN

const String String::EMPTY;

#define PEGASUS_ARRAY_T String

#include <Pegasus/Common/ArrayImpl.h>

#undef PEGASUS_ARRAY_T

///////////////////////////////////////////////////////////////////////////////

// String

///////////////////////////////////////////////////////////////////////////////

const String String::EMPTY = String();

Uint32 _strnlen(const char* str, Uint32 n)

{

if (!str)

throw NullPointer();

for (Uint32 i=0; i<n; i++)

{

if (!*str)

{

return i;

}

return n;

}

inline Uint32 StrLen(const char* str)

Uint32 _strnlen(const Char16* str, Uint32 n)

{

if (!str)

throw NullPointer();

for (Uint32 i=0; i<n; i++)

{

if (!*str)

{

return i;

}

return n;

}

inline Uint32 _StrLen(const char* str)

{

if (!str)

throw NullPointer();

Line 56

Line 88

return strlen(str);

}

inline Uint32 StrLen(const Char16* str)

inline Uint32 _StrLen(const Char16* str)

{

if (!str)

throw NullPointer();

Line 74

Line 106

_rep.append('\0');

}

String::String(const String& x) : _rep(x._rep)

String::String(const String& str)

: _rep(str._rep)

{

}

String::String(const String& x, Uint32 n)

String::String(const String& str, Uint32 n)

{

_rep.append('\0');

assign(str.getData(), n);

append(x.getData(), n);

}

String::String(const Char16* x) : _rep(x, StrLen(x) + 1)

String::String(const Char16* str)

: _rep(str, _StrLen(str) + 1)

{

}

String::String(const Char16* x, Uint32 n)

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

{

assign(x, n);

assign(str, n);

}

String::String(const char* str)

{

Uint32 n = ::strlen(str) + 1;

assign(str);

reserve(n);

}

while (n--)

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

_rep.append(*str++);

{

assign(str, n);

}

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

String::~String()

{

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

}

reserve(n + 1);

while (n--)

String& String::operator=(const String& str)

_rep.append(*str++);

{

return assign(str);

}

_rep.append('\0');

String& String::operator=(const Char16* str)

{

return assign(str);

}

String& String::assign(const String& str)

{

_rep = str._rep;

return *this;

}

String& String::assign(const Char16* x)

String& String::assign(const Char16* str)

{

_rep.clear();

_rep.append(x, StrLen(x) + 1);

_rep.append(str, _StrLen(str) + 1);

return *this;

}

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

{

_rep.clear();

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

Uint32 m = _strnlen(str, n);

_rep.append(str, m);

_rep.append('\0');

return *this;

}

String& String::assign(const char* x)

String& String::assign(const char* str)

{

_rep.clear();

Uint32 n = strlen(x);

_rep.reserve(n + 1);

while (n--)

Uint32 n = strlen(str) + 1;

_rep.append(*x++);

_rep.reserve(n);

_rep.append('\0');

while (n--)

_rep.append(*str++);

return *this;

}

String& String::assign(const char* x, Uint32 n_)

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

{

_rep.clear();

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

Uint32 _n = _strnlen(str, n);

_rep.reserve(n + 1);

_rep.reserve(_n + 1);

while (n--)

while (_n--)

_rep.append(*x++);

_rep.append(*str++);

_rep.append('\0');

return *this;

}

void String::clear()

{

_rep.clear();

_rep.append('\0');

}

void String::reserve(Uint32 capacity)

{

_rep.reserve(capacity + 1);

}

Uint32 String::size() const

{

return _rep.size() - 1;

}

const Char16* String::getData() const

{

return _rep.getData();

}

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 187

Line 248

if (!str)

throw NullPointer();

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

Uint32 n = (size() < length)? size() : length;

char* p = str + strlen(str);

const Char16* q = getData();

Line 206

Line 267

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

{

if (i > getLength())

if (i > size())

ThrowOutOfBounds();

return _rep[i];

Line 214

Line 275

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

{

if (i > getLength())

if (i > size())

ThrowOutOfBounds();

return _rep[i];

}

String& String::append(const Char16& c)

{

_rep.insert(_rep.size() - 1, c);

return *this;

}

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

{

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

Uint32 m = _strnlen(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;

}

String& String::append(const String& str)

{

return append(str.getData(), str.size());

}

String& String::operator+=(const String& str)

{

return append(str);

}

String& String::operator+=(Char16 c)

{

return append(c);

}

String& String::operator+=(char c)

{

return append(Char16(c));

}

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)

_rep.remove(pos, size);

}

int String::compare(const Char16* s1, const Char16* s2, Uint32 n)

String String::subString(Uint32 pos, Uint32 length) const

{

while (n--)

if (pos < size())

{

int r = *s1++ - *s2++;

if (length == PEG_NOT_FOUND)

length = size() - pos;

if (r)

return String(getData() + pos, length);

return r;

}

else

return 0;

return String();

}

Boolean String::equal(const String& x, const String& y)

Uint32 String::find(Char16 c) const

{

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

const Char16* first = getData();

return false;

return String::compare(x.getData(), y.getData(), x.getLength()) == 0;

for (const Char16* p = first; *p; p++)

{

if (*p == c)

return p - first;

}

return PEG_NOT_FOUND;

}

Boolean String::equal(const String& x, const Char16* y)

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

{

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

const Char16* data = getData();

return false;

return String::compare(x.getData(), y, x.getLength()) == 0;

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

{

if (data[i] == c)

return i;

}

Boolean String::equal(const Char16* x, const String& y)

return PEG_NOT_FOUND;

{

return equal(y, x);

}

Boolean String::equal(const String& x, const char* y)

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

{

return equal(x, String(y));

const Char16* pSubStr = s.getData();

}

const Char16* pStr = getData();

Uint32 subStrLen = s.size();

Uint32 strLen = size();

Boolean String::equal(const char* x, const String& y)

if (subStrLen > strLen)

{

return equal(String(x), y);

return PEG_NOT_FOUND;

}

// loop to find first char match

String String::subString(Uint32 pos, Uint32 length) const

Uint32 loc = 0;

for( ; loc <= (strLen-subStrLen); loc++)

{

if (pos < getLength())

if (*pStr++ == *pSubStr) // match first char

{

if (length == Uint32(-1))

// point to substr 2nd char

length = getLength() - pos;

const Char16* p = pSubStr + 1;

return String(getData() + pos, length);

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

}

else

}

return String();

return PEG_NOT_FOUND;

}

Uint32 String::find(Char16 c) const

Uint32 String::find(const Char16* s) const

{

const Char16* first = getData();

for (const Char16* p = first; *p; p++)

{

if (*p == c)

return find(String(s));

return p - first;

}

return Uint32(-1);

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

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

while (last != first)

{

Line 324

Line 422

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::toLower(char* str)

{

while (*str)

tolower(*str++);

}

void String::translate(Char16 fromChar, Char16 toChar)

{

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

{

if (*p == fromChar)

*p = toChar;

}

void String::print() const

{

cout << *this << endl;

}

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::compare(const Char16* s1, const Char16* s2)

Line 345

Line 489

return 0;

}

std::ostream& operator<<(std::ostream& os, const String& x)

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;

}

int String::compareNoCase(const char* s1, const char* s2)

{

for (Uint32 i = 0, n = x.getLength(); i < n; i++)

while (*s1 && *s2)

os << x[i];

{

int r = tolower(*s1++) - tolower(*s2++);

if (r)

return r;

}

if (*s2)

return -1;

else if (*s1)

return 1;

return 0;

}

int String::compareNoCase(const String& s1, const String& s2)

{

const Char16* _s1 = s1.getData();

const Char16* _s2 = s2.getData();

while (*_s1 && *_s2)

{

int r;

#ifdef PEGASUS_HAS_EBCDIC

if (*_s1 <= 255 && *_s2 <= 255)

#else

if (*_s1 <= 127 && *_s2 <= 127)

#endif

{

r = tolower(*_s1++) - tolower(*_s2++);

}

else

{

r = *_s1++ - *_s2++;

}

if (r)

return r;

}

if (*_s2)

return -1;

else if (*_s1)

return 1;

return 0;

}

Boolean String::equal(const String& str1, const String& str2)

{

if (str1.size() != str2.size())

return false;

return String::compare(str1.getData(), str2.getData(), str1.size()) == 0;

}

Boolean String::equal(const String& str1, const Char16* str2)

{

if (str1.size() != _StrLen(str2))

return false;

return String::compare(str1.getData(), str2, str1.size()) == 0;

}

Boolean String::equal(const Char16* str1, const String& str2)

{

return equal(str2, str1);

}

Boolean String::equal(const String& str1, const char* str2)

{

return equal(str1, String(str2));

}

Boolean String::equal(const char* str1, const String& str2)

{

return equal(String(str1), str2);

}

Boolean String::equalNoCase(const String& str1, const String& str2)

{

if (str1.size() != str2.size())

return false;

const Char16* p = str1.getData();

const Char16* q = str2.getData();

Uint32 n = str1.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;

}

//#define NEWMATCHFUNCTION

#if defined NEWMATCHFUNCTION

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

// The following code was provided by Bob Blair.

/* _StringMatch Match input MatchString against a GLOB style pattern

Note that MatchChar is the char type so that this source

in portable to different string types. This is an internal function

Results: The return value is 1 if string matches pattern, and

0 otherwise. The matching operation permits the following

special characters in the pattern: *?\[] (see the manual

entry for details on what these mean).

Side effects: None.

/* MatchChar defined as a separate entity because this function source used

elsewhere was an unsigned char *. Here we use Uint16 to maintain 16 bit

size.

typedef Uint16 MatchChar;

inline Uint16 _ToLower(Uint16 ch)

{

#ifdef PEGASUS_HAS_EBCDIC

return ch <= 255 ? tolower(char(ch)) : ch;

#else

return ch <= 127 ? tolower(char(ch)) : ch;

#endif

}

inline Boolean _Equal(MatchChar ch1, MatchChar ch2, int nocase)

{

if (nocase)

return _ToLower(ch1) == _ToLower(ch2);

else

return ch1 == ch2;

}

static const MatchChar *

_matchrange(const MatchChar *range, MatchChar c, int nocase)

{

const MatchChar *p = range;

const MatchChar *rstart = range + 1;

const MatchChar *rend = 0;

MatchChar compchar;

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

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

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

if (_Equal(*rstart, c, nocase))

return ++rend;

if (*rstart == '-') {

rstart++;

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

return ++rend;

}

return (const MatchChar *)0;

}

static int

_StringMatch(

const MatchChar *testString,

const MatchChar *pattern,

int nocase ) /* Ignore case if this is true */

{

const MatchChar *pat = pattern;

const MatchChar *str = testString;

unsigned int done = 0;

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

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 (_StringMatch(str, pat, nocase)) { // 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, nocase); // 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 (!_Equal(*pat++, *str++, nocase)) // 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;

}

#else

////////////////////////////////////////////////////////////////////////////////

// String matching routines borrowed from Tcl 8.0:

////////////////////////////////////////////////////////////////////////////////

// This software is copyrighted by the Regents of the University of

// California, Sun Microsystems, Inc., and other parties. The following

// terms apply to all files associated with the software unless explicitly

// disclaimed in individual files.

// The authors hereby grant permission to use, copy, modify, distribute,

// and license this software and its documentation for any purpose, provided

// that existing copyright notices are retained in all copies and that this

// notice is included verbatim in any distributions. No written agreement,

// license, or royalty fee is required for any of the authorized uses.

// Modifications to this software may be copyrighted by their authors

// and need not follow the licensing terms described here, provided that

// the new terms are clearly indicated on the first page of each file where

// they apply.

// IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY

// FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES

// ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY

// DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE

// POSSIBILITY OF SUCH DAMAGE.

// THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,

// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,

// FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. THIS SOFTWARE

// IS PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE

// NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR

// MODIFICATIONS.

// GOVERNMENT USE: If you are acquiring this software on behalf of the

// U.S. government, the Government shall have only "Restricted Rights"

// in the software and related documentation as defined in the Federal

// Acquisition Regulations (FARs) in Clause 52.227.19 (c) (2). If you

// are acquiring the software on behalf of the Department of Defense, the

// software shall be classified as "Commercial Computer Software" and the

// Government shall have only "Restricted Rights" as defined in Clause

// 252.227-7013 (c) (1) of DFARs. Notwithstanding the foregoing, the

// authors grant the U.S. Government and others acting in its behalf

// permission to use and distribute the software in accordance with the

// terms specified in this license.

////////////////////////////////////////////////////////////////////////////////

*----------------------------------------------------------------------

* Tcl_StringMatch --

* See if a particular string matches a particular pattern.

* Results:

* The return value is 1 if string matches pattern, and

* 0 otherwise. The matching operation permits the following

* special characters in the pattern: *?\[] (see the manual

* entry for details on what these mean).

* Side effects:

* None.

*----------------------------------------------------------------------

typedef Uint16 MatchChar;

inline Uint16 _ToLower(Uint16 ch)

{

#ifdef PEGASUS_HAS_EBCDIC

return ch <= 255 ? tolower(char(ch)) : ch;

#else

return ch <= 127 ? tolower(char(ch)) : ch;

#endif

}

inline Boolean _Equal(Uint16 ch1, Uint16 ch2, int nocase)

{

if (nocase)

return _ToLower(ch1) == _ToLower(ch2);

else

return ch1 == ch2;

}

int _StringMatch(

MatchChar *string, /* String. */

MatchChar *pattern, /* Pattern, which may contain special

* characters. */

int nocase) /* Ignore case if this is true */

{

MatchChar c2;

while (1) {

/* See if we're at the end of both the pattern and the string.

* If so, we succeeded. If we're at the end of the pattern

* but not at the end of the string, we failed.

if (*pattern == 0) {

if (*string == 0) {

return 1;

} else {

return 0;

}

if ((*string == 0) && (*pattern != '*')) {

return 0;

}

/* Check for a "*" as the next pattern character. It matches

* any substring. We handle this by calling ourselves

* recursively for each postfix of string, until either we

* match or we reach the end of the string.

if (*pattern == '*') {

pattern += 1;

if (*pattern == 0) {

return 1;

}

while (1) {

if (_StringMatch(string, pattern, nocase)) {

return 1;

}

if (*string == 0) {

return 0;

}

string += 1;

}

/* Check for a "?" as the next pattern character. It matches

* any single character.

if (*pattern == '?') {

goto thisCharOK;

}

/* Check for a "[" as the next pattern character. It is followed

* by a list of characters that are acceptable, or by a range

* (two characters separated by "-").

if (*pattern == '[') {

pattern += 1;

while (1) {

if ((*pattern == ']') || (*pattern == 0)) {

return 0;

}

if (_Equal(*pattern, *string, nocase)) {

break;

}

if (pattern[1] == '-') {

c2 = pattern[2];

if (c2 == 0) {

return 0;

}

if ((*pattern <= *string) && (c2 >= *string)) {

break;

}

if ((*pattern >= *string) && (c2 <= *string)) {

break;

}

pattern += 2;

}

pattern += 1;

}

while (*pattern != ']') {

if (*pattern == 0) {

pattern--;

break;

}

pattern += 1;

}

goto thisCharOK;

}

/* If the next pattern character is '/', just strip off the '/'

* so we do exact matching on the character that follows.

if (*pattern == '\\') {

pattern += 1;

if (*pattern == 0) {

return 0;

}

/* There's no special character. Just make sure that the next

* characters of each string match.

if (!_Equal(*pattern, *string, nocase)) {

return 0;

}

thisCharOK: pattern += 1;

string += 1;

}

#endif

Boolean String::match(const String& str, const String& pattern)

{

return _StringMatch(

(Uint16*)str.getData(), (Uint16*)pattern.getData(), 0) != 0;

}

Boolean String::matchNoCase(const String& str, const String& pattern)

{

return _StringMatch(

(Uint16*)str.getData(), (Uint16*)pattern.getData(), 1) != 0;

}

///////////////////////////////////////////////////////////////////////////////

// String-related functions

///////////////////////////////////////////////////////////////////////////////

Boolean operator==(const String& str1, const String& str2)

{

return String::equal(str1, str2);

}

Boolean operator==(const String& str1, const char* str2)

{

return String::equal(str1, str2);

}

Boolean operator==(const char* str1, const String& str2)

{

return String::equal(str1, str2);

}

Boolean operator!=(const String& str1, const String& str2)

{

return !String::equal(str1, str2);

}

PEGASUS_STD(ostream)& operator<<(PEGASUS_STD(ostream)& os, const String& str1)

{

for (Uint32 i = 0, n = str1.size(); i < n; i++)

os << str1[i];

return os;

}

void String::toLower(char* str)

String operator+(const String& str1, const String& str2)

{

while (*str)

return String(str1).append(str2);

tolower(*str++);

}

String ToLower(const String& str)

Boolean operator<(const String& str1, const String& str2)

{

String tmp(str);

return String::compare(str1.getData(), str2.getData()) < 0;

}

Boolean operator<=(const String& str1, const String& str2)

{

return String::compare(str1.getData(), str2.getData()) <= 0;

}

for (Uint32 i = 0, n = tmp.getLength(); i < n; i++)

Boolean operator>(const String& str1, const String& str2)

{

Char16 c = tmp[i];

return String::compare(str1.getData(), str2.getData()) > 0;

}

if (c <= 127)

Boolean operator>=(const String& str1, const String& str2)

tmp[i] = tolower(c);

{

return String::compare(str1.getData(), str2.getData()) >= 0;

}

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;

}

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

{

return CompareNoCase(s1, s2) == 0;

}

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.4
changed lines
	Added in v.1.40

No CVS admin address has been configured