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.54 and 1.109

version 1.54, 2002/08/29 00:27:52

version 1.109, 2005/05/18 20:34:36

Line 1

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

//%2005////////////////////////////////////////////////////////////////////////

// The Open Group, Tivoli Systems

// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.

// IBM Corp.; EMC Corporation, The Open Group.

// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.

// EMC Corporation; VERITAS Software Corporation; The Open Group.

// Permission is hereby granted, free of charge, to any person obtaining a copy

// of this software and associated documentation files (the "Software"), to

Line 24

Line 30

// Author: Mike Brasher (mbrasher@bmc.com)

// Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)

// Josephine Eskaline Joyce, IBM (jojustin@in.ibm.com) for Bug#3297

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

#include <cctype>

#include <cstring>

#include "String.h"

#include "Array.h"

#include "AutoPtr.h"

#include "InternalException.h"

#include <iostream>

#include <fstream>

#include <Pegasus/Common/CommonUTF.h>

#include "CommonUTF.h"

#ifdef PEGASUS_HAS_ICU

#include <unicode/ustring.h>

#include <unicode/uchar.h>

#endif

PEGASUS_USING_STD;

Line 51

Line 69

CString::CString(const CString& cstr)

{

_rep = new char[strlen(cstr._rep)+1];

_rep = 0;

_rep = strcpy(_rep, cstr._rep);

if (cstr._rep)

{

_rep = (void*)new char[strlen((char*)cstr._rep)+1];

strcpy((char*)_rep, (char*)cstr._rep);

}

CString::CString(char* cstr)

Line 63

Line 86

CString::~CString()

{

if (_rep)

delete [] _rep;

{

delete [] (char*)_rep;

}

CString& CString::operator=(const CString& cstr)

{

if (&cstr != this)

{

if (_rep)

{

delete [] (char*)_rep;

_rep = 0;

}

if (cstr._rep)

{

_rep = (char*)new char[strlen((char*)cstr._rep)+1];

strcpy((char*)_rep, (char*)cstr._rep);

}

return *this;

}

CString::operator const char*() const

{

return _rep;

return (char*)_rep;

}

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

Line 79

Line 122

const String String::EMPTY = String();

Uint32 _strnlen(const char* str, Uint32 n)

inline Uint32 _StrLen(const Char16* str)

{

if (!str)

throw NullPointer();

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

Uint32 n = 0;

{

if (!*str)

while (*str++)

{

n++;

return i;

}

return n;

}

Uint32 _strnlen(const Char16* str, Uint32 n)

// Converts a utf-8 char buffer to utf-16 and appends the utf-16 to the Array.

// n is the length of the input char *, if stopAtTerm is 0

// A terminator character is appended to the end.

// Note that each input char is converted individually, which gives

// the fastest performance.

void _convertAndAppend(const char* str, Array<Char16>& c16a, Uint32 n, Uint8 stopAtTerm)

{

if (!str)

Uint32 i = 0;

throw NullPointer();

while ((stopAtTerm && *str) || (!stopAtTerm && i < n))

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

{

if (!*str)

if (*(Uint8*)str <= 0x7f)

{

return i;

// Current byte sequence is in the us-ascii range.

}

c16a.append(Uint8(*str++));

}

else

return n;

}

inline Uint32 _StrLen(const char* str)

{

if (!str)

throw NullPointer();

// Current byte sequence is not in the us-ascii range.

return strlen(str);

// Check if the byte sequence is valid utf-8, and if so,

// call the converter to utf-16

Uint16 tgt[3];

tgt[1] = 0;

Uint8 c = UTF_8_COUNT_TRAIL_BYTES(*str);

if ( (!stopAtTerm && i + c >= n) ||

(!isValid_U8((const Uint8 *)str, c+1)) )

{

// Note about error conditions.

// It is possible that the last utf-8 char before the

// end of input string extends past the end of the input string.

// This is caught in both cases -

// If counting up to n, then the test above catches it.

// If converting until terminator found, then a terminator

// in the middle of a multi-byte utf-8 char is invalid.

MessageLoaderParms parms("Common.String.BAD_UTF8",

"The byte sequence starting at index $0 is not valid UTF-8 encoding.",

i);

throw Exception(parms);

}

else

inline Uint32 _StrLen(const Char16* str)

{

if (!str)

// str is incremented by this call to the start of the next char

throw NullPointer();

Uint16 * tgtBuf = tgt;

UTF8toUTF16((const Uint8 **)&str, (Uint8 *)&str[c+1], &tgtBuf, &tgtBuf[2]);

c16a.append(tgt[0]);

if (tgt[1])

{

// Its a utf-16 surrogate pair (uses 2 Char16's)

c16a.append(tgt[1]);

}

Uint32 n = 0;

// bump by the trailing byte count

i += c;

}

while (*str++)

i++;

n++;

} // end while

return n;

c16a.append('\0');

}

class StringRep

Line 155

Line 224

String::String(const String& str)

{

if (str._rep != NULL)

{

_rep = new StringRep(*str._rep);

}

else

{

_rep = new StringRep();

}

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

{

_rep = new StringRep;

assign(str.getData(), n);

assign(str.getChar16Data(), n);

}

String::String(const Char16* str)

{

if ( str == 0 )

{

throw NullPointer();

}

_rep = new StringRep(str);

}

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

{

if ( str == 0 )

{

throw NullPointer();

}

_rep = new StringRep;

assign(str, n);

}

String::String(const char* str)

{

if ( str == 0 )

{

throw NullPointer();

}

_rep = new StringRep;

assign(str);

AutoPtr<StringRep> tempRep(_rep);

// An exception can be thrown, so use a temp AutoPtr.

_convertAndAppend(str, _rep->c16a, 0, 1);

tempRep.release();

}

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

{

if ( str == 0 )

{

throw NullPointer();

}

_rep = new StringRep;

assign(str, n);

AutoPtr<StringRep> tempRep(_rep);

// An exception can be thrown, so use a temp AutoPtr.

_convertAndAppend(str, _rep->c16a, n, 0);

tempRep.release();

}

String::~String()

Line 194

Line 297

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

{

return assign(str);

if (&str != this)

{

assign(str);

}

return *this;

}

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

Line 205

Line 312

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

{

if ( str == 0 )

{

throw NullPointer();

}

_rep->c16a.clear();

_rep->c16a.append(str, _StrLen(str) + 1);

return *this;

Line 212

Line 324

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

{

if ( str == 0 )

{

throw NullPointer();

}

_rep->c16a.clear();

Uint32 m = _strnlen(str, n);

_rep->c16a.append(str, n);

_rep->c16a.append(str, m);

_rep->c16a.append('\0');

return *this;

}

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

{

_rep->c16a.clear();

if ( str == 0 )

{

Uint32 n = strlen(str) + 1;

throw NullPointer();

_rep->c16a.reserveCapacity(n);

}

while (n--)

_rep->c16a.append(*str++);

_rep->c16a.clear();

_convertAndAppend(str, _rep->c16a, 0, 1);

return *this;

}

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

{

_rep->c16a.clear();

if ( str == 0 )

{

Uint32 _n = _strnlen(str, n);

throw NullPointer();

_rep->c16a.reserveCapacity(_n + 1);

}

while (_n--)

_rep->c16a.append(*str++);

_rep->c16a.append('\0');

_rep->c16a.clear();

_convertAndAppend(str, _rep->c16a, n, 0);

return *this;

}

Line 260

Line 372

Uint32 String::size() const

{

//#if defined (PEGASUS_OS_VMS)

// This prevents returning a minus number.

// Seems as though the first time through

// the XML parser something doesn't get

// initialized and there is no check for

// a negative number in the parser!

// Uint32 foo;

// foo = _rep->c16a.size();

// if (foo == 0)

// {

// return 0;

// }

// else

// {

// return (foo -1);

// }

//#else

return _rep->c16a.size() - 1;

//#endif

}

const Char16* String::getData() const

const Char16* String::getChar16Data() const

{

return _rep->c16a.getData();

}

CString String::getCString() const

{

Uint32 n = size() + 1;

char* str = new char[n];

char* p = str;

const Char16* q = getData();

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

{

Uint16 c = *q++;

*p++ = char(c);

//if (c & 0xff00)

// truncatedCharacters = true;

}

return CString(str);

}

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

{

if (index > size())

Line 311

Line 425

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

{

Uint32 m = _strnlen(str, n);

if (str == 0)

_rep->c16a.reserveCapacity(_rep->c16a.size() + m);

{

throw NullPointer();

}

_rep->c16a.reserveCapacity(_rep->c16a.size() + n);

_rep->c16a.remove(_rep->c16a.size() - 1);

_rep->c16a.append(str, m);

_rep->c16a.append(str, n);

_rep->c16a.append('\0');

return *this;

}

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

{

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

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

}

void String::remove(Uint32 index, Uint32 size)

Line 340

Line 458

{

if (index < size())

{

if (length == PEG_NOT_FOUND)

if ((length == PEG_NOT_FOUND) || (length > size() - index))

length = size() - index;

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

return String(getChar16Data() + index, length);

}

else

return String();

}

Uint32 String::find(Char16 c) const

{

const Char16* first = getData();

const Char16* first = getChar16Data();

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

{

Line 364

Line 482

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

{

const Char16* data = getData();

const Char16* data = getChar16Data();

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

{

Line 377

Line 495

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

{

const Char16* pSubStr = s.getData();

const Char16* pSubStr = s.getChar16Data();

const Char16* pStr = getData();

const Char16* pStr = getChar16Data();

Uint32 subStrLen = s.size();

Uint32 strLen = size();

Line 400

Line 518

Uint32 i = 1;

for (; i < subStrLen; i++)

if (*pStr++ != *p++ )

{pStr--; break;} // break from loop

{pStr-=i; break;} // break from loop

if (i == subStrLen)

return loc;

}

Line 410

Line 528

Uint32 String::reverseFind(Char16 c) const

{

const Char16* first = getData();

const Char16* first = getChar16Data();

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

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

while (last != first)

{

Line 424

Line 542

void String::toLower()

{

#ifdef PEGASUS_HAS_ICU

if (InitializeICU::initICUSuccessful())

{

// This will do a locale-insensitive, but context-sensitive convert.

// Context-sensitive prevents any optimizations that try to

// convert just the ascii before calling ICU.

// The string may shrink or expand after the convert.

int32_t sz = size();

UChar* destbuf = new UChar[sz + 1];

const UChar* srcbuf = (const UChar *)getChar16Data();

UErrorCode err = U_ZERO_ERROR;

int32_t needed = u_strToLower(destbuf, sz + 1 , srcbuf, sz, NULL, &err);

if (err == U_BUFFER_OVERFLOW_ERROR)

{

delete [] destbuf;

destbuf = new UChar[needed + 1];

err = U_ZERO_ERROR;

u_strToLower(destbuf, needed + 1 , srcbuf, sz, NULL, &err);

}

if (U_FAILURE(err))

{

delete [] destbuf;

throw Exception(u_errorName(err));

}

if (needed == sz)

{

Char16* from = (Char16*)destbuf;

for (Char16* to = &_rep->c16a[0]; *to; to++, from++)

{

*to = *from;

}

else

{

assign((Char16 *)destbuf, needed);

}

delete [] destbuf;

}

else

#endif

{

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

{

if (*p <= PEGASUS_MAX_PRINTABLE_CHAR)

*p = tolower(*p);

}

void String::toUpper()

{

#ifdef PEGASUS_HAS_ICU

if (InitializeICU::initICUSuccessful())

{

// This will do a locale-insensitive, but context-sensitive convert.

// Context-sensitive prevents any optimizations that try to

// convert just the ascii before calling ICU.

// The string may shrink or expand after the convert.

int32_t sz = size();

UChar* destbuf = new UChar[sz + 1];

const UChar* srcbuf = (const UChar *)getChar16Data();

UErrorCode err = U_ZERO_ERROR;

int32_t needed = u_strToUpper(destbuf, sz + 1 , srcbuf, sz, NULL, &err);

if (err == U_BUFFER_OVERFLOW_ERROR)

{

delete [] destbuf;

destbuf = new UChar[needed + 1];

err = U_ZERO_ERROR;

u_strToUpper(destbuf, needed + 1 , srcbuf, sz, NULL, &err);

}

if (U_FAILURE(err))

{

delete [] destbuf;

throw Exception(u_errorName(err));

}

if (needed == sz)

{

Char16* from = (Char16*)destbuf;

for (Char16* to = &_rep->c16a[0]; *to; to++, from++)

{

*to = *from;

}

else

{

assign((Char16 *)destbuf, needed);

}

delete [] destbuf;

}

else

#endif

{

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

{

if (*p <= PEGASUS_MAX_PRINTABLE_CHAR)

*p = toupper(*p);

}

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

{

const Char16* s1c16 = s1.getData();

const Char16* s1c16 = s1.getChar16Data();

const Char16* s2c16 = s2.getData();

const Char16* s2c16 = s2.getChar16Data();

while (n--)

{

Line 449

Line 668

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

{

const Char16* s1c16 = s1.getData();

const Char16* s1c16 = s1.getChar16Data();

const Char16* s2c16 = s2.getData();

const Char16* s2c16 = s2.getChar16Data();

while (*s1c16 && *s2c16)

{

Line 470

Line 689

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

{

const Char16* _s1 = s1.getData();

#ifdef PEGASUS_HAS_ICU

const Char16* _s2 = s2.getData();

if (InitializeICU::initICUSuccessful())

{

return u_strcasecmp((const UChar*)s1.getChar16Data(),

(const UChar*)s2.getChar16Data(),

U_FOLD_CASE_DEFAULT);

}

#endif

const Char16* _s1 = s1.getChar16Data();

const Char16* _s2 = s2.getChar16Data();

while (*_s1 && *_s2)

{

Line 506

Line 733

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

{

#ifdef PEGASUS_HAS_ICU

return compareNoCase(str1, str2) == 0;

#else

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

return false;

const Char16* p = str1.getData();

const Char16* p = str1.getChar16Data();

const Char16* q = str2.getData();

const Char16* q = str2.getChar16Data();

Uint32 n = str1.size();

Line 527

Line 757

}

return true;

#endif

}

CString String::getCString() const

{

Uint32 n = 3*size() + 1;

char* str = new char[n];

const Char16* msg16 = getChar16Data();

const Uint16 *strsrc = (Uint16 *)msg16;

Uint16 *endsrc = (Uint16 *)&msg16[size()+1];

Uint8 *strtgt = (Uint8 *)str;

Uint8 *endtgt = (Uint8 *)&str[n];

UTF16toUTF8 (&strsrc,

endsrc,

&strtgt,

endtgt);

char* str1 = new char[strlen(str)+1];

strcpy(str1,str);

delete [] str;

return CString(str1);

}

#if 0

// ATTN-RK-P3-20020603: This code is not completely correct

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

// The following code was provided by Bob Blair.

Line 543

Line 800

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

entry for details on what these mean).

Side effects: None.

Line 554

Line 812

inline Uint16 _ToLower(Uint16 ch)

{

// ICU_TODO: If ICU is available we should do this the correct way.

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

}

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

{

// ICU_TODO: If ICU is available we should do this the correct way.

if (nocase)

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

else

return ch1 == ch2;

}

Line 652

Line 912

}

/** match matches a string against a GLOB style pattern.

Return trues if the String parameter matches the pattern. C-Shell style

glob matching is used.

@param str String to be matched against the pattern

@param pattern Pattern to use in the match

@return Boolean true if str matches pattern

The pattern definition is as follows:

<pre>

* Matches any number of any characters

? Match exactly one character

[chars] Match any character in chars

[chara-charb] Match any character in the range between chara and charb

</pre>

The literal characters *, ?, [, ] can be included in a string by

escaping them with backslash "\". Ranges of characters can be concatenated.

<pre>

examples:

Boolean result = String::match("This is a test", "*is*");

Boolean works = String::match("abcdef123", "*[0-9]");

</pre>

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

{

return _StringMatch(

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

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

}

/** matchNoCase Matches a String against a GLOB style pattern independent

of case.

Returns true if the str parameter matches the pattern. C-Shell style

glob matching is used. Ignore case in all comparisons. Case is

ignored in the match.

@parm str String containing the string to be matched\

@parm pattern GLOB style patterh to use in the match.

@return Boolean true if str matches patterh

@see match

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

{

return _StringMatch(

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

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

}

#endif

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

Line 693

Line 985

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

{

#if defined(PEGASUS_OS_OS400)

CString cstr = str.getCString();

const char* utf8str = cstr;

os << utf8str;

#elif defined(PEGASUS_HAS_ICU)

if (InitializeICU::initICUSuccessful())

{

char *buf = NULL;

const int size = str.size() * 6;

UnicodeString UniStr((const UChar *)str.getChar16Data(), (int32_t)str.size());

Uint32 bufsize = UniStr.extract(0,size,buf);

buf = new char[bufsize+1];

UniStr.extract(0,bufsize,buf);

os << buf;

os.flush();

delete [] buf;

}

else

#endif // End of PEGASUS_HAS_ICU #else leg.

{

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

{

Uint16 code = str[i];

Line 709

Line 1025

os << buffer;

}

return os;

}

Line 738

Line 1055

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

}

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.54
changed lines
	Added in v.1.109

No CVS admin address has been configured