StringBase Class Reference

#include <basestr.h>

Inheritance diagram for StringBase:

List of all members.

Public Member Functions
	StringBase ()
	Default constructor for a StringBase. Sets the character buffer to 0 and the string length to zero. The user must call Alloc() before trying to use the StringBase. Scope: Public.
virtual	~StringBase ()
	Destroys & cleans up a string.
virtual BOOL	Alloc (INT32 size)
	Allocates space on the heap for a 0-terminated string of the passed size. This function should only be called for the StringBase base class, NOT for any of its fixed-length derivatives.
BOOL	Load (UINT32 resID, UINT32 inst=0)
	Extracts a string from the application's .EXE file, by default, or another module (eg. a dedicated DLL), overwriting the old contents of this StringBase object.
INT32	Length () const
	Calculates the length of the string.
INT32	MaxLength () const
	Calculates the longest allowed string that can be stored in this.
BOOL	IsEmpty () const
	Tests for the 0 string.
INT32	NextIndex (INT32 index) const
	Find the next character index Notes: If string exceptions are enabled, an exception will be thrown if the index goes out of range.
INT32	PrevIndex (INT32 index) const
	Find the previous character index Notes: If string exceptions are enabled, an exception will be thrown if the index goes out of range.
BOOL	IsLegal (INT32 index) const
	Check index for its legality.
BOOL	IsIllegal (INT32 index) const
	Check index for its legality.
StringBase &	Empty ()
	Sets a string to the 0 string (zero-terminated but no characters, NOT A 0 POINTER!).
StringBase &	toUpper ()
	Converts all lower-case letters in the string to upper-case.
StringBase &	toLower ()
	Converts all upper-case letters to lower-case.
StringBase &	toTitle ()
	Converts all the first letters of words to uppercase and the rest to lower case.
INT32 __cdecl	MakeMsg (UINT32 resID...)
	Internationally portable version of sprintf(...), eg. StringBase s; INT32 x, y, z; s.MakeMsg(_R(IDS_COORDFORMAT), x, y, z); TextOut(hdc, 20, 20, s, s.Length());.
INT32 __cdecl	_MakeMsg (const TCHAR *fmt...)
	Internationally portable version of sprintf(...), eg. UINT32 x; s._MakeMsg("#1%lu", x); TextOut(hdc, 20, 20, s, s.Length());.
	operator TCHAR * ()
	Cast a string into a C-style pointer to array of characters. If you intend to use the subscript operator [] with the results of the cast remember that no range checking is performed.
	operator const TCHAR * () const
	Cast a string into a C-style pointer to array of constant characters.
	operator wxString ()
	Cast a string into a wxString.
	operator const wxString () const
	Cast a string into a wxString.
StringBase &	operator+= (const StringBase &rhs)
	Append string y onto the end of string x, eg. x = TEXT("hello"); cout << (x += TEXT(" world!")) << endl;.
StringBase &	operator+= (const TCHAR *s)
	Append string y onto the end of string x, eg. x = TEXT("hello"); cout << (x += TEXT(" world!")) << endl;.
StringBase &	operator+= (const TCHAR ch)
	Appends this character to the end of this string.
StringBase &	operator= (const StringBase &other)
	Assignment (set equal to) operator, eg. StringBase x("rhubarb"); x = "custard";.
StringBase &	operator= (const TCHAR *s)
	Assignment (set equal to) operator, eg. StringBase x("rhubarb"); x = "custard";.
StringBase &	operator= (const TCHAR ch)
	Assigns the single character to this string.
const StringBase &	Left (StringBase *out, UINT32 count) const
	Similar to the BASIC Left$() string function.
const StringBase &	Mid (StringBase *out, UINT32 first, UINT32 count) const
	Similar to the BASIC Mid$() function.
const StringBase &	Right (StringBase *out, UINT32 count) const
	Similar to the BASIC Right$() function.
void	Split (StringBase *pstrStart, StringBase *pstrEnd, INT32 iSplit, BOOL fIncludeSplitChar)
	Splits a string into two separate strings at a given character.
INT32	Sub (const StringBase &mask, UINT32 from=0, TCHAR fuzz=0) const
	Similar to the (non-standard) BASIC Instr$() function. Scope: Public.
INT32	SubWithoutCase (const StringBase &strToFind) const
	Similar to the (non-standard) BASIC Instr$() function. Scope: Public.
void	Remove (INT32 Position, INT32 Number)
	Inserting a string into another one. Scope: Public.
void	Insert (const StringBase &InsertString, INT32 Position)
	Inserting a string into another one. Scope: Public.
void	SwapChar (const TCHAR schar, const TCHAR rchar)
	Exchange all schar characters in the string with rchar characters Scope: Public.
INT32	CountChar (const TCHAR tchar)
	Count all tchar characters in the string Scope: Public.
TCHAR	operator[] (const INT32 Index)
	Extract single characters from the string... 0 is the first char, String.Length() is the terminating zero...
const WCHAR	CharAt (const INT32 Index) const
	Extract single characters from the string... 0 is the first char, String.Length() is the terminating zero...
INT32	SkipComma (INT32 pos=0) const
	Find the next comma (starting from pos) and skip on to the next none space character beyond it. Notes: ** Throws an exception if string exceptions are enabled **.
INT32	SkipSpace (INT32 pos=0) const
	Find the next non-space character starting from pos. If pos is a none space character, the function will simply return with the same index. Notes: ** Throws an exception if string exceptions are enabled **.
INT32	FindNextChar (INT32 position=0) const
	Find the next none space character starting from pos. If pos is a none space character, the function will simply return with the same index. Notes: ** Throws an exception if string exceptions are enabled **.
INT32	FindNextChar (TCHAR c, INT32 position=0) const
	Find the next character to match c starting from position. Notes: ** Throws an exception if string exceptions are enabled **.
INT32	ConvertToInteger (INT32 &position) const
	Convert the sequence of characters starting from position into a numeric value. 32 bits of precision are returned and hence approx 10 digit numbers can be represented. If the numeric string is longer, the value 0x7FFFFFFF is returned (ie represting an overflow). If string exceptions are enabled, an exception will be thrown in this instance. All valid numeric digits will be read, no matter whether an overflow is immanent or not, hence you can safely continue to parse what is expected to be the next token along the string. The types of numbers allowed are +123686 -12394 124802398 but not 12439127397123.
INT32	ReverseFind (TCHAR cToFind) const
	As above.
virtual void	MakePercent (INT32 Value)
	Set the string equal to the given argument + a % character, or however the current locale wants it Example: String_32 Str; Str.MakePercent(23); For UK, Str now equals "23%".
virtual void	MakePercent (double Value)
virtual void	MakePercent (TCHAR *Value)
virtual void	FixFormat ()
bool	IsIdentical (const TCHAR *other) const
	Compare this StringBase object to another string.
bool	IsIdentical (const StringBase &other) const
	Compare this StringBase object to another string.
INT32	CompareTo (const TCHAR *other, BOOL CaseSensitive=TRUE) const
	Compare this StringBase object to another string. This is mainly intended for use internally by the comparison operators, but may also come in handy in other places.
INT32	CompareTo (const StringBase &other, BOOL CaseSensitive=TRUE) const
	Compare this StringBase object to another string. This is mainly intended for use internally by the comparison operators, but may also come in handy in other places.
Static Public Member Functions
static BOOL	IsAlpha (TCHAR c)
	Tests if the character is a-z, A-Z (or local equivalent).
static BOOL	IsAlphaNumeric (TCHAR c)
	Tests if the character is a-z, A-Z, 0-9, or local equivalent.
static BOOL	IsNumeric (TCHAR c)
	Tests if the character is 0-9, or local equivalent.
static BOOL	IsLower (TCHAR c)
	Tests if the character is a-z (or local equivalent).
static BOOL	IsUpper (TCHAR c)
	Tests if the character is A-Z, or local equivalent.
static BOOL	IsSpace (TCHAR c)
static TCHAR *	SafeCat (TCHAR *pstr1, const TCHAR *pcstr2, UINT32 nchMax)
	Appends string2 to the end of string1 and returns string1 as the result. The difference between this and camStrcat is the Max parameter which helps alleviate the buffer overwrite problems. Setting max to the length member of a stringbase will ERROR3IF that we don't go overwriting ends of buffers and suchlike... In such cases the result will be trucated.
static BOOL	EnableExceptionHandler (BOOL PushNewHandler=TRUE)
	This function adds a new exception handler to the string exception handler stack (if PushNewHandler is TRUE). Otherwise it will simply change the state of the most recently pushed handler. If there are no handlers and Push is FALSE, an ERROR3IF will be generated.
static BOOL	DisableExceptionHandler (BOOL PopHandler=TRUE)
	This function disables or completely removes the most previously enabled exception state. FALSE will be returned if the exception stack is empty. The default parameter allows you to temporarily disable the exception state without poping the handler.
static BOOL	WillThrowException ()
	This function interogates the exceptions state stack and determins whether exceptions will be thrown or not.
Protected Attributes
TCHAR *	text
UINT32	length
Private Member Functions
INT32	IllegalIndex () const
	Generate an illegal index Notes: ** Can potentially throw a user exception **.
INT32	BuildList (const TCHAR *)
	This private helper function scans the layout string, breaking it up into literal text and parameters, which are placed on an private list in the order they are encountered, together with their type and which argument passed to Format that they refer to. The formatting must be done in two passes as the order of the parameters is not known until the whole format string has been scanned. Scope: Private.
INT32	CCvsprintf (const TCHAR *, va_list)
	This private helper function takes the list generated by StringBase::BuildList and scans through it, formatting stack-frame parameters according to their list entry. This produces another list, this time of formatted parameters, which is then concatenated to produce the final output. Scope: Private.
	StringBase (const StringBase &other)
	Copy constructor - this is made private (and unimplemented) as it will not work for base class strings, which must call Alloc() before they are used. Scope: Private.
Static Private Member Functions
static INT32	TCharToNum (TCHAR c)
	Convert a TCHAR into a numeric value. The routine does not check for valid numeric characters, it just performs the conversion. Hence it is possibly for you to pass in the character 's' for instance and receive a >9 value back.
static void	ThrowStringException ()
	Throws a 'User' exception if the string exception stack says 'Yes'.
Static Private Attributes
static BOOL	ThrowExceptionStack [str_MAXEXCEPTIONS]
static INT32	CurrEx = -1
Friends
class	Error
bool	operator== (const StringBase &x, const TCHAR *y)
	Comparison (logical) operators, eg. x = "alpha"; y = "beta"; cout << "First is " << (x < y ? x : y) << endl; These functions will work according to local custom.
bool	operator== (const StringBase &x, const StringBase &y)
bool	operator< (const StringBase &x, const TCHAR *y)
bool	operator< (const StringBase &x, const StringBase &y)
	Comparison (logical) operators, eg. x = "alpha"; y = "beta"; cout << "First is " << (x < y ? x : y) << endl; These functions will work according to local custom.
bool	operator> (const StringBase &x, const TCHAR *y)
bool	operator> (const StringBase &x, const StringBase &y)
	Comparison (logical) operators, eg. x = "alpha"; y = "beta"; cout << "First is " << (x < y ? x : y) << endl; These functions will work according to local custom.
bool	operator!= (const StringBase &x, const TCHAR *y)
bool	operator!= (const StringBase &x, const StringBase &y)
	Comparison (logical) operators, eg. x = "alpha"; y = "beta"; cout << "First is " << (x < y ? x : y) << endl; These functions will work according to local custom.
bool	operator<= (const StringBase &x, const TCHAR *y)
bool	operator<= (const StringBase &x, const StringBase &y)
	Comparison (logical) operators, eg. x = "alpha"; y = "beta"; cout << "First is " << (x < y ? x : y) << endl; These functions will work according to local custom.
bool	operator>= (const StringBase &x, const TCHAR *y)
	Comparison (logical) operators, eg. x = "alpha"; y = "beta"; cout << "First is " << (x < y ? x : y) << endl; These functions will work according to local custom.
bool	operator>= (const StringBase &x, const StringBase &y)
std::istream &	operator>> (std::istream &is, StringBase &s)
	Read a string from a (non-persistent) stream. The input is terminated by a newline character (NOT whitespace, cf. reading C-style character arrays). If the string is longer than MAX_STRING_RES_LENGTH get() will read as many characters as possible and put a newline at the end.
std::ostream &	operator<< (std::ostream &os, const StringBase &s)
	Write a string to a (non-persistent) stream. If the string is 0 then "[0]" is printed.

---

Detailed Description

Definition at line 161 of file basestr.h.

---

Constructor & Destructor Documentation

StringBase::StringBase (   )  [inline]

Default constructor for a StringBase. Sets the character buffer to 0 and the string length to zero. The user must call Alloc() before trying to use the StringBase. Scope: Public. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 22nd April 1993 Parameters: -  [INPUTS] Definition at line 340 of file basestr.h. : text(0), length(0) { // Empty. }

StringBase::~StringBase (   )  [inline, virtual]

Destroys & cleans up a string. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 22nd April 1993 Definition at line 375 of file basestr.h. { if (text) delete[] text; }

StringBase::StringBase (  const StringBase &  other  )  [inline, private]

Copy constructor - this is made private (and unimplemented) as it will not work for base class strings, which must call Alloc() before they are used. Scope: Private. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 22nd April 1993 Parameters: Another  StringBase object. [INPUTS] Definition at line 360 of file basestr.h. { // Empty. }

---

Member Function Documentation

INT32 __cdecl StringBase::_MakeMsg (  const TCHAR *  fmt...  )

Internationally portable version of sprintf(...), eg. UINT32 x; s._MakeMsg("#1%lu", x); TextOut(hdc, 20, 20, s, s.Length());. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 22nd April 1993 Parameters: A  constant character pointer, and a variable number of other parameters, [INPUTS] which must match the format specifiers embedded in the character pointer. Note that floating point parameters are NOT supported **** Changes  "this" to become the formatted string, with the passed parameters [OUTPUTS] substituted into the string resource in the correct order. Returns: The number of characters in the formatted string. Definition at line 186 of file makemsg.cpp. { /* if (IsUserName("JustinF")) TRACE( _T("_MakeMsg called with format string %s\n"), fmt); */ ENSURE(text, "Call to StringBase::_MakeMsg for an unallocated String"); ENSURE(fmt, "Call to StringBase::_MakeMsg with a null format parameter"); va_list ap; va_start(ap, fmt); INT32 n = CCvsprintf(fmt, ap); va_end(ap); return n; }

BOOL StringBase::Alloc (  INT32  size  )  [virtual]

Allocates space on the heap for a 0-terminated string of the passed size. This function should only be called for the StringBase base class, NOT for any of its fixed-length derivatives. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 22nd April 1993 Parameters: The  number of characters the string is to hold (EXCLUDING the [INPUTS] terminating 0). Returns: TRUE if the allocation was successful. Errors: _R(IDE_NOMORE_MEMORY) Scope: Public Reimplemented in String_128, String_256, String_16, String_32, String_64, and String_8. Definition at line 142 of file basestr.cpp. { ERROR3IF(size < 0, "Attempt to ALLOCate a String of negative length"); if (text) delete[] text; #ifdef _UNICODE text = new TCHAR[length = size + 1]; #else text = new TCHAR[length = (size + 1) * 2]; // MBCS #endif ERRORIF(text == 0, _R(IDE_NOMORE_MEMORY), FALSE); *text = 0; return TRUE; }

INT32 StringBase::BuildList (  const TCHAR *  format  )  [private]

This private helper function scans the layout string, breaking it up into literal text and parameters, which are placed on an private list in the order they are encountered, together with their type and which argument passed to Format that they refer to. The formatting must be done in two passes as the order of the parameters is not known until the whole format string has been scanned. Scope: Private. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 22nd April 1993 Parameters: A  pointer to the format string to be analysed. [INPUTS] Returns: The number of format specifiers in the string, which should be the same as the number of arguments to be formatted. Definition at line 284 of file makemsg.cpp. { /* if (IsUserName("JustinF")) TRACE( _T("\tBuildList called with format string %s\n"), format); */ ENSURE(format, "Null parameter passed to StringBase::BuildList"); const TCHAR* start = format; INT32 nArgs = 0; while (*start) { const TCHAR* next = start; // Look for a format specifier in the layout string if (*next == TEXT('#')) if (IsNumeric(*(++next))) { INT32 ArgPos = *next - TEXT('0'); // MS approved method - yuck!!! ENSURE(ArgPos >= 1 && ArgPos <= 9, "Illegal format string passed to MakeMsg!"); if (*(++next) == TEXT('%')) { // Seem to have found the beginning of a specifier, // so try parsing it, to extract the type information if (*(++next) == TEXT('-')) next++; if (*next == TEXT('#')) next++; if (*next == TEXT('0')) next++; while (IsNumeric(*next)) next++; if (*next == TEXT('.')) while (IsNumeric(*++next)); // Ok, we have skipped the width, precision etc. and // "next" should now be pointing at the type character(s) ArgType kind; if (*next == TEXT('l')) // an INT32 something or another? switch (*++next) { case TEXT('d'): case TEXT('i'): kind = SIGNED_INT32_ARG; break; case TEXT('u'): case TEXT('x'): case TEXT('X'): kind = UNSIGNED_INT32_ARG; break; default: // false alarm, can't be a specifier next = start + 1; goto not_format; } else switch (*next) // single type character { case TEXT('c'): kind = CHAR_ARG; break; case TEXT('d'): case TEXT('i'): kind = SIGNED_INT_ARG; break; case TEXT('p'): // a pointer kind = UINT_PTR_ARG; break; case TEXT('u'): case TEXT('x'): case TEXT('X'): kind = UNSIGNED_INT_ARG; break; case TEXT('s'): kind = CHAR_POINTER_ARG; break; case TEXT('S'): kind = STRING_POINTER_ARG; break; default: next = start + 1; goto not_format; // boo hiss hooray! } // Successfully parsed the format specifier, so add // it to the Item list. Skip the leading #n of the specifier, // so (next) now points to the character following the '%X' // format specifier. next++; // Extract the specifier. TCHAR temp[64]; INT32 len = next - start - 2; camStrncpy(temp, start + 2, len); temp[len] = 0; new Item(temp, ArgPos, kind); start = next; nArgs++; /* if (IsUserName("JustinF")) { TRACE( _T("\tItem: (%d) at #%d %s\n"), kind, ArgPos, temp); TRACE( _T("\t\tRemaining: %s\n"), start); } */ continue; } else // Put back the previous character next--; } not_format: // Scan a literal up to the next '#' or null, whichever is sooner while (*next && *next != TEXT('#')) next++; TCHAR temp[256]; INT32 len = next - start; camStrncpy(temp, start, len); temp[len] = 0; new Item(temp, 0, LITERAL); start = next; /* if (IsUserName("JustinF")) { TRACE( _T("\tLiteral: %s\n"), temp); } */ } return nArgs; }

INT32 StringBase::CCvsprintf (  const TCHAR *  layout, va_list  va )  [private]

This private helper function takes the list generated by StringBase::BuildList and scans through it, formatting stack-frame parameters according to their list entry. This produces another list, this time of formatted parameters, which is then concatenated to produce the final output. Scope: Private. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 22nd April 1993 Parameters: A  pointer to the format string, a variable-parameter pointer to the [INPUTS] arguments to be formatted. Returns: The length of the StringBase once the arguments have been substituted into it. Definition at line 425 of file makemsg.cpp. { /* if (IsUserName("JustinF")) TRACE( _T("CCvsprintf called with format string %s\n"), layout); */ INT32 n = BuildList(layout); for (INT32 i = 1; i <= n; i++) { for (Item* p = Item::head; p; p = p->next) if (p->pos != i) continue; else { // Found specifier i in the list, so grab from the stack // and call wsprintf() to convert to text. The converted // text is put in the temp[] buffer - note the enormous // size of this, in accordance with the C standard. TCHAR temp[512]; switch (p->type) { // type 'c' - single character case CHAR_ARG: #if defined(__WXMSW__) camSnprintf( temp, 512, p->str, va_arg(va, TCHAR) ); #else // TCHARs are promoted to INT32 when passed via ... under GCC camSnprintf( temp, 512, p->str, va_arg(va, INT32) ); #endif break; // type 'd' / 'i' - signed decimal integer case SIGNED_INT_ARG: camSnprintf(temp, 512, p->str, va_arg(va, INT32)); break; // type 'ld' / 'li' - signed decimal INT32 case SIGNED_INT32_ARG: camSnprintf(temp, 512, p->str, va_arg(va, INT32)); break; // type 'u' - unsigned decimal integer case UNSIGNED_INT_ARG: camSnprintf(temp, 512, p->str, va_arg(va, UINT32)); break; // type 'lu' / 'lx' / 'lX' - unsigned decimal INT32 case UNSIGNED_INT32_ARG: camSnprintf(temp, 512, p->str, va_arg(va, UINT32)); break; // type 's' - long pointer to array of (constant) char case CHAR_POINTER_ARG: camSnprintf(temp, 512, p->str, va_arg(va, LPCTSTR)); break; // type 'p' a pointer case UINT_PTR_ARG: camSnprintf(temp, 512, p->str, va_arg(va, UINT_PTR)); break; // type 'S' - a pointer to a StringBase. First change the // %S format specifier, which is our own, into a sprintf() // compatible %s. Note that the 'S' is always the last // character of the format specifier. case STRING_POINTER_ARG: (p->str)[camStrlen(p->str) - 1] = TEXT('s'); camSnprintf(temp, 512, p->str, LPCTSTR(va_arg(va, const StringBase*)->text)); break; default: break; } // Replace the format specifier with the formatted text delete[] p->str; camStrcpy(p->str = new TCHAR[camStrlen(temp) + 1], temp); break; } } // Concatenate every string in the list, tidy up, and return in "this" string *text = 0; UINT32 NextChar = 0; INT32 Index = 0; for (Item* p = Item::head; (p != NULL && NextChar < length) ; p = p->next) { /* if (camStrlen(text) + camStrlen(p->str) < length) camStrcat(text, p->str); else { ENSURE(FALSE, "Call to String::MakeMsg will overflow - text has been truncated"); } */ for (Index = 0; p->str[Index] != 0 && NextChar < length; Index++) text[NextChar++] = p->str[Index]; } if (NextChar > length) NextChar = length; text[NextChar] = TCHAR('\0'); delete Item::head; return camStrlen(text); }

const WCHAR StringBase::CharAt (  const INT32  Index  )  const [inline]

Extract single characters from the string... 0 is the first char, String.Length() is the terminating zero... Author: Richard_Millican (Xara Group Ltd) <camelotdev@xara.com> Date: 22nd November 1995 Returns The character at offset Index into the string... Or 0 if there were problems (or if the character was 0 of course). Definition at line 898 of file basestr.h. { #ifdef UNICODE ERROR3IF(!text, "Call to String::operator[] for an unALLOCated String"); TCHAR ch = (text && (Index <= (INT32)camStrlen(text))) ? text[Index] : 0; return (WCHAR)ch; #else PORTNOTETRACE("other", "WCHAR StringBase::CharAt does nothing in non-UNICODE builds!"); ERROR3("This function is unimplemented in non-UNICODE builds!"); return (WCHAR)0; #endif }

INT32 StringBase::CompareTo (  const StringBase &  other, BOOL  CaseSensitive = TRUE )  const

Compare this StringBase object to another string. This is mainly intended for use internally by the comparison operators, but may also come in handy in other places. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 24/5/94 Parameters: other  - A string against which this one will be compared [INPUTS] Returns: The same as the standard C strcmp, i.e: A negative value if this is considered 'less than' other Zero, if the strings are considered equal A positive value if this is considered 'greater than' other Notes: This function is VERY SLOW, but does proper comparisons for the locale to determine relative positioning of strings. Use StringBase::IsIdentical to see if 2 strings are exactly the same. Returns: Errors: If either of the strings is 0, an ENSURE failure is generated See also: StringBase::IsIdentical Definition at line 285 of file basestr.cpp. { ERROR3IF(text == 0 || other.text == 0, "StringBase::CompareTo: not ALLOCed"); PORTNOTE("other", "StringBase::CompareTo should be locale specific"); #if FALSE DWORD dw = NORM_IGNOREKANATYPE | NORM_IGNOREWIDTH; if (!CaseSensitive) dw |= NORM_IGNORECASE; return CompareString(LOCALE_USER_DEFAULT, dw, text, -1, other.text, -1) - 2; #endif if( CaseSensitive ) { return camStrcmp( text, other.text ); } else { return camStricmp( text, other.text ); } }

INT32 StringBase::CompareTo (  const TCHAR *  other, BOOL  CaseSensitive = TRUE )  const

Compare this StringBase object to another string. This is mainly intended for use internally by the comparison operators, but may also come in handy in other places. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 24/5/94 Parameters: other  - A string against which this one will be compared [INPUTS] Returns: The same as the standard C strcmp, i.e: A negative value if this is considered 'less than' other Zero, if the strings are considered equal A positive value if this is considered 'greater than' other Notes: This function is VERY SLOW, but does proper comparisons for the locale to determine relative positioning of strings. Use StringBase::IsIdentical to see if 2 strings are exactly the same. Returns: Errors: If either of the strings is 0, an ENSURE failure is generated See also: StringBase::IsIdentical Definition at line 336 of file basestr.cpp. { ERROR3IF(text == 0 || other == 0, "StringBase::CompareTo: null buffers"); PORTNOTE("other", "StringBase::CompareTo should be locale specific"); #if FALSE DWORD dw = NORM_IGNOREKANATYPE | NORM_IGNOREWIDTH; if (!CaseSensitive) dw |= NORM_IGNORECASE; return CompareString(LOCALE_USER_DEFAULT, dw, text, -1, other, -1) - 2; #endif if( CaseSensitive ) { return camStrcmp( text, other ); } else { return camStricmp( text, other ); } }

INT32 StringBase::ConvertToInteger (  INT32 &  position  )  const

Convert the sequence of characters starting from position into a numeric value. 32 bits of precision are returned and hence approx 10 digit numbers can be represented. If the numeric string is longer, the value 0x7FFFFFFF is returned (ie represting an overflow). If string exceptions are enabled, an exception will be thrown in this instance. All valid numeric digits will be read, no matter whether an overflow is immanent or not, hence you can safely continue to parse what is expected to be the next token along the string. The types of numbers allowed are +123686 -12394 124802398 but not 12439127397123. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 29/07/96 Parameters: position  = the character index [INPUTS] position  = the new character index [OUTPUTS] Returns: A signed numeric value for the sequence of characters starting at position in this string. Notes: ** Throws an exception if string exceptions are enabled ** Definition at line 1529 of file basestr.cpp. { ERROR3IF(!text, "Call to StringBase::ConvertToInteger for unALLOCated String"); const TCHAR pos = TEXT('+'); const TCHAR neg = TEXT('-'); INT32 value = 0; BOOL isneg = FALSE; INT32 maxdigs = 10; INT32 nchars = Length(); position = SkipSpace(position); if (position>-1 && position<nchars) { isneg = (text[position]==neg); if (isneg || text[position]==pos) position=NextIndex(position); while (position<nchars && IsNumeric(text[position])) { value = value*10 + (StringBase::TCharToNum(text[position])); position=NextIndex(position); maxdigs--; } if (maxdigs<0) { TRACEUSER("Mike", wxT("Overflow during ConvertToInteger") ); StringBase::ThrowStringException(); return ((isneg) ? 0x80000000 : 0x7FFFFFFF); } value = (isneg) ? (-value) : (value); } return value; }

INT32 StringBase::CountChar (  const TCHAR  tchar  )

Count all tchar characters in the string Scope: Public. Author: Richard_Millican (Xara Group Ltd) <camelotdev@xara.com> Date: 20/11/95 Parameters: tchar  - the search character [INPUTS] Returns: Number of times 'tchar' appears in the string Definition at line 975 of file basestr.cpp. { ERROR3IF(!text, "Call to String::CountChar for an unALLOCated String"); INT32 Count = 0; if (text) { TCHAR* pThis = text; while (*pThis != 0) { if (*pThis == tchar) Count ++; pThis = camStrinc(pThis); } } return Count; }

BOOL StringBase::DisableExceptionHandler (  BOOL  PopHandler = TRUE  )  [static]

This function disables or completely removes the most previously enabled exception state. FALSE will be returned if the exception stack is empty. The default parameter allows you to temporarily disable the exception state without poping the handler. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 29/07/96 Parameters: PopHandler  = a default parameter, determining whether the current [INPUTS] handler state is poped or not Returns: TRUE if all goes well FALSE if there are no exception states to pop! Errors: Definition at line 1333 of file basestr.cpp. { ERROR2IF(CurrEx < 0, FALSE, "StringBase::DisableExceptions; Nothing on the exception stack!"); ThrowExceptionStack[CurrEx]=FALSE; if (PopHandler) CurrEx--; return TRUE; }

StringBase & StringBase::Empty (   )  [inline]

Sets a string to the 0 string (zero-terminated but no characters, NOT A 0 POINTER!). Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 10th August 1993 Definition at line 719 of file basestr.h. { ERROR3IF(!text, "Attempt to EMPTY an unALLOCated String"); if (text) *text = 0; return *this; }

BOOL StringBase::EnableExceptionHandler (  BOOL  PushNewHandler = TRUE  )  [static]

This function adds a new exception handler to the string exception handler stack (if PushNewHandler is TRUE). Otherwise it will simply change the state of the most recently pushed handler. If there are no handlers and Push is FALSE, an ERROR3IF will be generated. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 29/07/96 Parameters: PushNewHandler  = a default parameter, determining whether a new [INPUTS] exception handler state is pushed on the handler stack or not. Returns: TRUE if throwing exceptions is enabled FALSE if a new exception state could not be pushed. Errors: if an attempt is made to push a new handler when the stack is full if an attempt is made to set the current exception handler to 'on' when there's no exception handlers on the stack Definition at line 1303 of file basestr.cpp. { if (PushNewHandler) CurrEx++; ERROR2IF(CurrEx >= str_MAXEXCEPTIONS, FALSE, "StringBase::EnableExceptions overflow!"); ERROR2IF(CurrEx < 0, FALSE, "StringBase::EnableExceptions - handler does not exist"); ThrowExceptionStack[CurrEx]=TRUE; return TRUE; }

INT32 StringBase::FindNextChar (  TCHAR  c, INT32  position = 0 )  const

Find the next character to match c starting from position. Notes: ** Throws an exception if string exceptions are enabled **. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 29/07/96 Parameters: c  = the character whose index we need [INPUTS] position = the character index from which to start Returns: the index of the next none space character, -1 if none, OR an exception is thrown Definition at line 1455 of file basestr.cpp. { ERROR3IF(!text, "Call to StringBase::FindNextChar for unALLOCated String"); INT32 nchars = Length(); if (!text || position<0 || position>=nchars) return IllegalIndex(); while ((text[position]!=c) && position<nchars) position=NextIndex(position); return ((position==nchars) ? (IllegalIndex()) : (position)); }

INT32 StringBase::FindNextChar (  INT32  position = 0  )  const

Find the next none space character starting from pos. If pos is a none space character, the function will simply return with the same index. Notes: ** Throws an exception if string exceptions are enabled **. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 29/07/96 Parameters: position  = the character index from which to start [INPUTS] Returns: the index of the next none space character -1 if none, OR an exception is thrown Definition at line 1423 of file basestr.cpp. { ERROR3IF(!text, "Call to StringBase::FindNextChar for unALLOCated String"); // get the length of this string in characters INT32 nchars = Length(); if (!text || position<0 || position>=nchars) return IllegalIndex(); TCHAR c = TEXT(' '); while ((text[position]==c) && position<nchars) position=NextIndex(position); return ((position==nchars) ? (IllegalIndex()) : (position)); }

void StringBase::FixFormat (   )  [virtual]

Definition at line 1042 of file basestr.cpp. { #if FALSE #if 0 != wxUSE_UNICODE INT32 i=0; while ((i+1)<Length()) // Don't look at the last character { if ( (text[i]==_T('%')) && ( (text[i+1]==_T('s')) || (text[i+1]==_T('c')) ) ) { String_8 l(_T("l")); Insert(l, i+1); i++; // Skip over the inserted char too } i++; } #endif #endif }

INT32 StringBase::IllegalIndex (   )  const [inline, private]

Generate an illegal index Notes: ** Can potentially throw a user exception **. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 29/07/96 Parameters: -  [INPUTS] Returns: An illegal index ie -1 if exceptions are disabled, otherwise an exception is thrown Definition at line 567 of file basestr.h. { StringBase::ThrowStringException(); return -1; }

void StringBase::Insert (  const StringBase &  InsertString, INT32  Position )

Inserting a string into another one. Scope: Public. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 26th August 1994 Parameters: InsertString  - the string to inserted. [INPUTS] Position - the number of the character before which InsertString is to be inserted. Counting starts at 0. Returns: - Definition at line 838 of file basestr.cpp. { ERROR3IF(Position < 0,"Negative position passed to StringBase::Insert"); ERROR3IF(!text || !InsertString.text, "Not ALLOCed in StringBase::Insert"); if (text && InsertString && InsertString.text) { INT32 LeftL = Position; INT32 RightL = Length()-Position; StringBase LeftS; StringBase RightS; if (LeftL<=0) { RightS.Alloc(this->Length()); RightS=*this; *this=*InsertString; *this+=RightS; } else { if (RightL<=0) { *this+=*InsertString; } else { LeftS.Alloc(LeftL); Left(&LeftS, LeftL); RightS.Alloc(RightL); Right(&RightS, RightL); *this=LeftS; *this+=*InsertString; *this+=RightS; } } } }

BOOL StringBase::IsAlpha (  TCHAR  c  )  [inline, static]

Tests if the character is a-z, A-Z (or local equivalent). Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 10th August 1993 Parameters: A  Unicode character. [INPUTS] Returns: TRUE if the passed character is an alphabet letter. Definition at line 625 of file basestr.h. { return camIsalpha(c); // IsCharAlpha(c); }

BOOL StringBase::IsAlphaNumeric (  TCHAR  c  )  [inline, static]

Tests if the character is a-z, A-Z, 0-9, or local equivalent. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 10th August 1993 Parameters: A  Unicode character [INPUTS] Returns: TRUE if the passed character is an alphabet letter or a digit. Definition at line 641 of file basestr.h. { return camIsalnum(c); //IsCharAlphaNumeric(c); }

BOOL StringBase::IsEmpty (   )  const [inline]

Tests for the 0 string. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 25th August 1993 Returns: TRUE if the string has no length. Definition at line 425 of file basestr.h. { return text == 0 || *text == 0; }

bool StringBase::IsIdentical (  const StringBase &  other  )  const [inline]

Compare this StringBase object to another string. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 23/4/96 Parameters: other  - A string against which this one will be compared [INPUTS] Returns: TRUE if the strings are identical FALSE if the strings are different in any way Errors: If either of the strings is 0, an ESNURE failure is generated Notes: We define different versions of the function for UNICODE builds, as camStrcmp is very slow compared to vanilla strcmp. Note also that this is a very fast comparison compared to CompareTo. It should be used in preference where relative ordering of strings does not need to be determined. See also: StringBase::CompareTo Definition at line 459 of file basestr.h. { ERROR3IF(text == 0 || other.text == 0, "StringBase::IsIdentical: not ALLOCed"); return wxStrcmp(text, other.text) == 0; }

bool StringBase::IsIdentical (  const TCHAR *  other  )  const [inline]

Compare this StringBase object to another string. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 23/4/96 Parameters: other  - A string against which this one will be compared [INPUTS] Returns: TRUE if the strings are identical FALSE if the strings are different in any way Errors: If either of the strings is 0, an ESNURE failure is generated Notes: We define different versions of the function for UNICODE builds, as camStrcmp is very slow compared to vanilla strcmp. Note also that this is a very fast comparison compared to CompareTo. It should be used in preference where relative ordering of strings does not need to be determined. See also: StringBase::CompareTo Definition at line 494 of file basestr.h. { ERROR3IF(text == 0 || other == 0, "StringBase::IsIdentical: null params"); return wxStrcmp( text, other ) == 0; }

BOOL StringBase::IsIllegal (  INT32  index  )  const [inline]

Check index for its legality. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 29/07/96 Parameters: index,a  character index in this string [INPUTS] Returns: TRUE if index is illegal FALSE if not Definition at line 588 of file basestr.h. { return ((index<0) || index>(Length())); }

BOOL StringBase::IsLegal (  INT32  index  )  const [inline]

Check index for its legality. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 29/07/96 Parameters: index,a  character index in this string [INPUTS] Returns: TRUE if index is llegal FALSE if its illegal Definition at line 608 of file basestr.h. { return !IsIllegal(index); }

BOOL StringBase::IsLower (  TCHAR  c  )  [inline, static]

Tests if the character is a-z (or local equivalent). Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 10th August 1993 Parameters: A  Unicode character [INPUTS] Returns: TRUE if the passed character is a lower-case letter. Definition at line 673 of file basestr.h. { return camIslower(c); // IsCharLower(c) }

BOOL StringBase::IsNumeric (  TCHAR  c  )  [inline, static]

Tests if the character is 0-9, or local equivalent. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 10th August 1993 Parameters: A  Unicode character [INPUTS] Returns: TRUE if the passed character is a digit. Definition at line 657 of file basestr.h. { return camIsalnum(c) && !camIsalpha(c); }

BOOL StringBase::IsSpace (  TCHAR  c  )  [inline, static]

Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 10th August 1993 Parameters: A  Unicode character [INPUTS] Returns: TRUE if the passed character is whitespace. Definition at line 704 of file basestr.h. { return camIsspace(c); }

BOOL StringBase::IsUpper (  TCHAR  c  )  [inline, static]

Tests if the character is A-Z, or local equivalent. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 10th August 1993 Parameters: A  Unicode character [INPUTS] Returns: TRUE if the passed character is an upper-case letter. Definition at line 689 of file basestr.h. { return camIsupper(c); // IsCharUpper(c) }

const StringBase & StringBase::Left (  StringBase *  out, UINT32  count )  const

Similar to the BASIC Left$() string function. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 22nd April 1993 Parameters: The  number of characters in the prefix. [INPUTS] The  leftmost [count] characters of the StringBase. If count is greater than [OUTPUTS] the StringBase's length, the the whole StringBase is returned. If count is equal to zero, the 0 StringBase is output. Returns: Errors: ERROR3IF failure if (count) is negative, or if the out StringBase is not large enough to hold the result. See also: StringBase::Right StringBase::Mid Definition at line 535 of file basestr.cpp. { ERROR3IF(out == 0, "0 output parameter in StringBase::Left"); ERROR3IF(!text || !out->text, "Call to String::Left for unALLOCated String"); ERROR3IF(count < 0, "Call to String::Left with a meaningless character count"); ERROR3IF(out->length <= count, "Call to String::Left will overflow"); if (text && out && out->text) { if (count == 0) *(out->text) = 0; else if (count >= camStrlen(text)) camStrcpy(out->text, text); else { camStrncpy(out->text, text, (INT32)count); out->text[count] = 0; } } return *this; }

INT32 StringBase::Length (   )  const [inline]

Calculates the length of the string. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 22nd April 1993 Returns: The number of characters in the string, excluding any terminating 0. Definition at line 390 of file basestr.h. { ERROR3IF(!text, "Attempt to find the LENGTH of an unALLOCated String"); return (text) ? camStrlen( text ) : 0; }

BOOL StringBase::Load (  UINT32  resID, UINT32  moduleID = 0 )

Extracts a string from the application's .EXE file, by default, or another module (eg. a dedicated DLL), overwriting the old contents of this StringBase object. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 22nd April 1993 Parameters: A  string resource identifier and an optional module handle. Specify [INPUTS] a module handle only if the resource is not located in the default place (CAMELOT.EXE). Most resources will be. If a moduleID is given, the string will try to be loaded from that module. If it fails, it will fall-back to the .exe file. The string will be truncated if required to fit the available buffer size. Returns: TRUE of the string is successfully loaded, FALSE otherwise. See also: SmartLoadString Definition at line 176 of file basestr.cpp. { ERROR3IF(text == 0, "Attempt to LOAD a String which hasn't been ALLOCated"); // Load the string resource. Get OIL layer to truncate to suit the destination. if (!text) return FALSE; return SmartLoadString(moduleID, resID, text, length*sizeof(TCHAR)); }

INT32 __cdecl StringBase::MakeMsg (  UINT32  resID...  )

Internationally portable version of sprintf(...), eg. StringBase s; INT32 x, y, z; s.MakeMsg(_R(IDS_COORDFORMAT), x, y, z); TextOut(hdc, 20, 20, s, s.Length());. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 22nd April 1993 Parameters: A  string resource identifier, and a variable number of other parameters, [INPUTS] which must match the format specifiers embedded in the string resource. Note that floating point parameters are NOT supported. Changes  "this" to become the formatted string, with the passed parameters [OUTPUTS] substituted into the string resource in the correct order. Returns: The number of characters in the formatted string. This will be zero if a problem occurs, such as not being able to load the format string resource. Errors: ENSURE failure if called for a String that hasn't been allocated. Definition at line 132 of file makemsg.cpp. { /* if (IsUserName("JustinF")) TRACE( _T("MakeMsg called with resource ID %u\n"), resID); */ ENSURE(text, "Call to StringBase::MakeMsg for unallocated String"); va_list ap; va_start(ap, resID); INT32 n = 0; StringBase s; if (s.Alloc(MAX_STRING_RES_LENGTH) && s.Load(resID)) { n = CCvsprintf(s.text, ap); } #ifdef _DEBUG /* else { if (IsUserName("JustinF")) TRACE( _T("Failed to allocate or load the format string in MakeMsg()\n")); } */ #endif va_end(ap); #if !defined(EXCLUDE_FROM_RALPH) && !defined(EXCLUDE_FROM_XARALX) // Remember the resource ID, in case the help system can't work out the message ID. SetNextMsgHelpContext(resID); #endif // Return the number of characters in the formatted string. return n; }

void StringBase::MakePercent (  TCHAR *  Value  )  [virtual]

Reimplemented in StringVar. Definition at line 1029 of file basestr.cpp. { if (text) { // Some callers seem to call this with Value=Text ... Grrr String_32 tmp(Value); String_32 Format(_R(IDS_PERCENT_STRING)); Format.FixFormat(); camSnprintf( text, 32, (TCHAR *)Format, tmp.text ); } }

void StringBase::MakePercent (  double  Value  )  [virtual]

Reimplemented in StringVar. Definition at line 1019 of file basestr.cpp. { if (text) { String_32 TmpStr; if(Convert::DoubleToString(Value, &TmpStr)) MakePercent((TCHAR *)TmpStr); } }

void StringBase::MakePercent (  INT32  Value  )  [virtual]

Set the string equal to the given argument + a % character, or however the current locale wants it Example: String_32 Str; Str.MakePercent(23); For UK, Str now equals "23%". Author: Richard_Millican (Xara Group Ltd) <camelotdev@xara.com> Date: 22nd November 1995 Parameters: Takes  a number / string [INPUTS] Reimplemented in StringVar. Definition at line 1009 of file basestr.cpp. { if (text) { String_32 Format(_R(IDS_PERCENT_LONG)); Format.FixFormat(); camSnprintf( text, 32, (TCHAR *)Format, Value ); } }

INT32 StringBase::MaxLength (   )  const [inline]

Calculates the longest allowed string that can be stored in this. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 25th August 1993 Returns: The maximum number of characters the string can contain. Definition at line 406 of file basestr.h. { #ifdef _UNICODE return length - 1; #else return (length / 2) - 1; // MBCS - two chars per character #endif }

const StringBase & StringBase::Mid (  StringBase *  out, UINT32  first, UINT32  count )  const

Similar to the BASIC Mid$() function. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 22nd April 1993 Parameters: The  position of the first character to extract and the total number of [INPUTS] characters to include in the sub-string. Note that the first character of a string is at position 0, like C, not 1, like BASIC. Places  the n characters starting at position m in [out], which must be [OUTPUTS] large enough. See also: StringBase::Left StringBase::Right Definition at line 575 of file basestr.cpp. { ERROR3IF(out == 0, "0 output parameter in StringBase::Mid"); ERROR3IF(!text || !out->text, "Call to String::Mid for unALLOCated String"); ERROR3IF(count < 0, "Call to String::Mid with a meaningless character count"); ERROR3IF(out->length <= count, "Call to String::Mid will overflow"); if (text && out && out->text) { UINT32 L = camStrlen(text); if ((first + count) > L) count = L - first; if (count <= 0) *(out->text) = 0; else { camStrncpy(out->text, text + first, (INT32)count); out->text[count] = 0; } } return *this; }

INT32 StringBase::NextIndex (  INT32  index  )  const [inline]

Find the next character index Notes: If string exceptions are enabled, an exception will be thrown if the index goes out of range. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 29/07/96 Parameters: index  = the current character index [INPUTS] Returns: the next characater index after 'index' -1 if there is no next index, OR an exception is thrown Definition at line 517 of file basestr.h. { INT32 i = index + 1; if (IsLegal(i)) return i; TRACEUSER( "Mike", wxT("String index overflow in StringBase::NextIndex()") ); return IllegalIndex(); }

StringBase::operator const TCHAR * (   )  const [inline]

Cast a string into a C-style pointer to array of constant characters. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 22nd April 1993 Returns: N/A See also: StringBase::operator TCHAR*() Definition at line 786 of file basestr.h. { return text; }

StringBase::operator const wxString (   )  const [inline]

Cast a string into a wxString. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 28th January 2006 Returns: N/A See also: StringBase::operator TCHAR*() Definition at line 819 of file basestr.h. { return wxString(text); }

StringBase::operator TCHAR * (   )  [inline]

Cast a string into a C-style pointer to array of characters. If you intend to use the subscript operator [] with the results of the cast remember that no range checking is performed. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 22nd April 1993 Returns: Not applicable! Definition at line 769 of file basestr.h. { return text; }

StringBase::operator wxString (   )  [inline]

Cast a string into a wxString. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 28th January 2006 Returns: Not applicable! Definition at line 802 of file basestr.h. { return wxString(text); }

StringBase & StringBase::operator+= (  const TCHAR  ch  )

Appends this character to the end of this string. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 11/12/95 Parameters: A  character to add to the end of this String. [INPUTS] Returns: A reference to the lhs, ie. this StringBase as an lvalue. Reimplemented in StringVar. Definition at line 445 of file basestr.cpp. { ERROR3IF(text == 0, "Call to String::operator+= for an unALLOCated String"); INT32 CurrentLength = camStrlen(text); ERROR3IF(CurrentLength == MaxLength() - 1, "StringBase::operator+= will overflow"); text[CurrentLength] = ch; text[CurrentLength + 1] = 0; return *this; }

StringBase & StringBase::operator+= (  const TCHAR *  s  )

Append string y onto the end of string x, eg. x = TEXT("hello"); cout << (x += TEXT(" world!")) << endl;. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 22nd April 1993 Parameters: The  C-style character "string" to add to the end of this String. [INPUTS] Returns: A reference to the lhs, ie. this StringBase as an lvalue. Reimplemented in StringVar. Definition at line 426 of file basestr.cpp. { ERROR3IF(!text || !s, "Call to String::operator+= for an unALLOCated String"); ERROR3IF(camStrlen(text) + camStrlen(s) >= length, "Call to String::operator+= will result in overflow"); if (text && s) SafeCat(text, s, length-1); return *this; }

StringBase & StringBase::operator+= (  const StringBase &  rhs  )  [inline]

Append string y onto the end of string x, eg. x = TEXT("hello"); cout << (x += TEXT(" world!")) << endl;. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 22nd April 1993 Parameters: The  string to add to the end of this string. [INPUTS] Returns: A reference to the lhs, ie. this StringBase as an lvalue. Reimplemented in StringVar. Definition at line 838 of file basestr.h. { ERROR3IF(!text || !rhs.text, "Call to String::operator+= for an unALLOCated String"); /* ERROR3IF(camStrlen(text) + camStrlen(rhs.text) >= length, "Call to String::operator+= will result in overflow");*/ if (text && rhs.text) SafeCat(text, rhs.text, length-1); return *this; }

StringBase & StringBase::operator= (  const TCHAR  ch  )  [inline]

Assigns the single character to this string. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 11/12/1995 Parameters: ch  - a single character [INPUTS] Returns: A reference to this. Reimplemented in StringVar. Definition at line 859 of file basestr.h. { ERROR3IF(text == 0, "Call to String::operator= for an unALLOCated String"); text[0] = ch; text[1] = 0; return *this; }

StringBase & StringBase::operator= (  const TCHAR *  s  )

Assignment (set equal to) operator, eg. StringBase x("rhubarb"); x = "custard";. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 22nd April 1993 Parameters: A  pointer to a constant C-style (possibly wide-character) string. [INPUTS] Returns: A reference to this. Reimplemented in StringVar. Definition at line 398 of file basestr.cpp. { ERROR3IF(!text || !s, "Call to String::operator= for an unALLOCated String or 0 char*"); // ERROR3IF(camStrlen(s) >= length, "Call to String::operator= will result in overflow"); if (text && s) { if(camStrlen(s) >= length) camStrncpy(text, s, (INT32)length-1); else camStrcpy(text, s); } return *this; }

StringBase & StringBase::operator= (  const StringBase &  other  )

Assignment (set equal to) operator, eg. StringBase x("rhubarb"); x = "custard";. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 22nd April 1993 Parameters: A  reference to a constant String. [INPUTS] Returns: A reference to this. Reimplemented in StringVar. Definition at line 370 of file basestr.cpp. { ERROR3IF(!text || !other.text, "Call to String::operator= for an unALLOCated String"); // ERROR3IF(camStrlen(other.text) >= length, "Call to String::operator= will result in overflow"); if (text && other.text) { if(camStrlen(other.text) >= length) camStrncpy(text, other.text, (INT32)length - 1); else camStrcpy(text, other.text); } return *this; }

TCHAR StringBase::operator[] (  const INT32  Index  )  [inline]

Extract single characters from the string... 0 is the first char, String.Length() is the terminating zero... Author: Richard_Millican (Xara Group Ltd) <camelotdev@xara.com> Date: 22nd November 1995 Returns The character at offset Index into the string... Or 0 if there were problems (or if the character was 0 of course). Definition at line 880 of file basestr.h. { ERROR3IF(!text, "Call to String::operator[] for an unALLOCated String"); return (text && (Index <= (INT32)camStrlen(text))) ? text[Index] : 0; }

INT32 StringBase::PrevIndex (  INT32  index  )  const [inline]

Find the previous character index Notes: If string exceptions are enabled, an exception will be thrown if the index goes out of range. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 29/07/96 Parameters: index  = the current character index [INPUTS] Returns: the previous characater index before 'index' -1 if there is no previous index, OR an exception is thrown Definition at line 542 of file basestr.h. { INT32 i = index-1; if (IsLegal(i)) return i; TRACEUSER( "Mike", wxT("String index underflow in StringBase::PrevIndex()") ); return IllegalIndex(); }

void StringBase::Remove (  INT32  nchStartPos, INT32  nchRemove )

Inserting a string into another one. Scope: Public. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 26th August 1994 Position - the position of the first character to be removed. Counting starts at 0. Number - the number of characters to be removed. Returns: - Definition at line 892 of file basestr.cpp. { ERROR3IF(nchStartPos < 0,"Bad start position passed to StringBase::Remove"); if (!text) { ERROR3("Not ALLOCed in StringBase::Remove"); return; } StringBase strLeftSeg; StringBase strRightSeg; INT32 nchRightSeg = Length() - nchStartPos - nchRemove; if (nchStartPos <= 0) { if (nchRightSeg <= 0) Empty(); else Right(this, nchRightSeg); } else { if (nchRightSeg <= 0) { Left(this, nchStartPos); } else { if (!strLeftSeg.Alloc(nchStartPos) || !strRightSeg.Alloc(nchRightSeg)) return; Left(&strLeftSeg, nchStartPos); Right(&strRightSeg, nchRightSeg); *this = strLeftSeg; *this += strRightSeg; } } }

INT32 StringBase::ReverseFind (  TCHAR  cToFind  )  const

As above. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com>, from Mike Date: 2/5/97 Parameters: c  = the character whose index we need [INPUTS] Returns: The index of the last occurrence of character cToFind in the string. Definition at line 1481 of file basestr.cpp. { ERROR2IF(text==0, IllegalIndex(), "Call to StringBase::ReverseFind for unALLOCated String"); INT32 iPosition=Length()-1; while ((text[iPosition]!=cToFind) && iPosition>=0) iPosition--; if (iPosition<0) return IllegalIndex(); else return iPosition; }

const StringBase & StringBase::Right (  StringBase *  out, UINT32  count )  const

Similar to the BASIC Right$() function. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 22nd April 1993 Parameters: The  number of characters in the postfix. [INPUTS] Returns: The rightmost n characters of the StringBase. If n is greater than the StringBase's length, the value of the whole StringBase is returned. If n is less than or equal to zero, the 0 StringBase is returned. See also: StringBase::Left StringBase::Mid Definition at line 614 of file basestr.cpp. { ERROR3IF(out == 0, "0 output parameter in StringBase::Right"); ERROR3IF(!text || !out->text, "Call to StringBase::Right for unALLOCated String"); ERROR3IF(count < 0, "Call to StringBase::Right with a meaningless character count"); ERROR3IF(out->length <= count, "Call to StringBase::Right will overflow"); if (text && out && out->text) { UINT32 L = camStrlen(text); if (count == 0) *(out->text) = 0; else if (count >= L) camStrcpy(out->text, text); else { camStrncpy(out->text, text + L - count, (INT32)count); out->text[count] = 0; } } return *this; }

TCHAR * StringBase::SafeCat (  TCHAR *  string1, const TCHAR *  string2, UINT32  Max )  [static]

Appends string2 to the end of string1 and returns string1 as the result. The difference between this and camStrcat is the Max parameter which helps alleviate the buffer overwrite problems. Setting max to the length member of a stringbase will ERROR3IF that we don't go overwriting ends of buffers and suchlike... In such cases the result will be trucated. Author: Richard_Millican (Xara Group Ltd) <camelotdev@xara.com> Date: 26th February 1996 Parameters: string1  0-terminated destination string [INPUTS] string2 0-terminated source string Max Maximum number of characters string1 is allowed to contain string1  Resulting string [OUTPUTS] Returns: string1 eg, TCHAR String1[256] = "Fish"; SafeCat(String1, "cake", 7); will result in "Fishcak" being placed in String1... Definition at line 484 of file basestr.cpp. { ERROR3IF(string1 == 0 || string2 == 0, "StringBase::SafeCat given 0 params"); UINT32 len1 = camStrlen(string1); ERROR3IF(len1 > Max, "First parameter to StringBase::SafeCat already larger than safe"); // No point trying if all space used up if (len1 <= Max) { // Are we going to overflow ? if ((len1 + camStrlen(string2)) > Max) { ERROR3("Call to StringBase::SafeCat will give truncated result"); // Yeah, so we need to chop some of the second string off before concatenation INT32 Required = Max - len1; if (Required > 0) { camStrncpy( &(string1[len1]), string2, Required); string1[Max] = 0; } } else { // No, just do a normal strcat camStrcat(string1, string2); } } return string1; }

INT32 StringBase::SkipComma (  INT32  pos = 0  )  const

Find the next comma (starting from pos) and skip on to the next none space character beyond it. Notes: ** Throws an exception if string exceptions are enabled **. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 29/07/96 Parameters: pos  = the character index from which to start [INPUTS] Returns: the index of the next none space character after the comma, -1 if none, OR an exception is thrown Throws an exception if string exceptions are enabled Definition at line 1400 of file basestr.cpp. { if ((pos = FindNextChar(TEXT(','), pos)) >= 0) pos = FindNextChar(pos + 1); return pos; }

INT32 StringBase::SkipSpace (  INT32  pos = 0  )  const [inline]

Find the next non-space character starting from pos. If pos is a none space character, the function will simply return with the same index. Notes: ** Throws an exception if string exceptions are enabled **. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 29/07/96 Parameters: pos  = the character index from which to start [INPUTS] Returns: the index of the next none space character -1 if none, OR an exception is thrown Definition at line 1382 of file basestr.h. { return FindNextChar(pos); }

void StringBase::Split (  StringBase *  pstrStart, StringBase *  pstrEnd, INT32  iSplit, BOOL  fIncludeSplitChar )

Splits a string into two separate strings at a given character. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 2/5/97 Parameters: iSplit  Index of the splitting character [INPUTS] fIncludeSplitChar TRUE Put the splitting character at the end of strStart FALSE Put the splitting character at the start of strEnd pstrStart  The string into which to put everything before [OUTPUTS] the splitting character pstrEnd The string into which to put everything before the splitting character Note that pstrStart or pstrEnd may either be 0 or may point at this string. Useful in parsing URLs. Returns: Errors: If any parameters are invalid See also: WebAddress::Parse Definition at line 665 of file basestr.cpp. { //First check our parameters if (iSplit<0) { ERROR2RAW("StringBase::Split - 0 parameter"); return; } //If iSplit is greater than the length of the string, then //put the entire string into pstrStart if (iSplit>=Length()) { if (pstrStart) *pstrStart=*this; if (pstrEnd) pstrEnd->Empty(); return; } //This variable is 1 if we're including the splitting character //and 0 otherwise INT32 iIncludeSplitChar=(fIncludeSplitChar? 1 : 0); //And get the length INT32 iLength=Length(); //Now, let's get the start string String_256 strStart; //This is the number of characters to include in the start string INT32 iStartChars=iSplit+iIncludeSplitChar; //And now actually create the start string Left(&strStart, iStartChars); //And the end string String_256 strEnd; Right(&strEnd, iLength-iStartChars); //Now, if we have been passed an output start string if (pstrStart) //Copy our start string into it *pstrStart=strStart; //And if we have been passed an output end string if (pstrEnd) //Copy our end string into it *pstrEnd=strEnd; }

INT32 StringBase::Sub (  const StringBase &  mask, UINT32  from = 0, TCHAR  fuzz = 0 )  const

Similar to the (non-standard) BASIC Instr$() function. Scope: Public. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 22nd April 1993 Parameters: A  reference to the substring (mask) to search for; optionally the first [INPUTS] character position to search from (default is first character in the string); optionally the character in the mask which is acting as a wildcard (if not specified, there is no wildcard in the mask). Returns: Returns the starting position of the substring, or -1 if the substring does not appear within "this". Definition at line 735 of file basestr.cpp. { ERROR3IF(!text || !mask.text, "Call to String::Sub for an unALLOCated String"); ERROR3IF(from < 0, "Call to String::Sub with a negative \"from\" character position"); if (text && mask.text) { if (from >= camStrlen(text) || camStrlen(mask.text) == 0) return -1; BOOL matched = FALSE; // 2 state DFA const TCHAR* pSub = mask.text; for (const TCHAR* pThis = text + from; *pThis; pThis++) if (*pSub != fuzz && *pThis != *pSub) // current pair match? { if (matched) // no, so if we had a match previously { pThis--; // then we must go back one character matched = FALSE; } pSub = mask.text; // and also match from beginning of mask } else { matched = TRUE; // yes, we have a match if (*++pSub == 0) // matched all of mask? return (pThis - text) - (pSub - mask.text) + 1; } } // return NOT FOUND return -1; }

INT32 StringBase::SubWithoutCase (  const StringBase &  strToFind  )  const

Similar to the (non-standard) BASIC Instr$() function. Scope: Public. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 26/6/97 Parameters: mask  The string to search for [INPUTS] from (optional) the character to search from Returns: Returns the starting position of the substring, or -1 if the substring does not appear within "this". The comparison is done without regard to case. For example, trying to find the string "fILe" in the following string: "The Rockford Files" would give a result of 13. Definition at line 788 of file basestr.cpp. { ERROR3IF(!text || !strToFind.text, "Call to String::Sub for an unALLOCated String"); if (IsEmpty() || strToFind.IsEmpty()) return -1; #if !defined(__WXMAC__) //First set up a pointer to search this string with TCHAR* pcThisChar=text; INT32 iThisChar=0; //Now, while pcThisChar is valid while (pcThisChar!=0 && *pcThisChar!='\0') { //Is strToSearch from pcThisChar onwards the same //as strToFind, doing a case insensitive comparision? if (camStrnicmp(pcThisChar, strToFind, camStrlen(strToFind))==0) { //Yes. So return the index of the character we found return iThisChar; } pcThisChar=camStrinc(pcThisChar); iThisChar++; } #else PORTNOTE("macport", "StringBase::SubWithoutCase not yet implemented"); ERROR3("StringBase::SubWithoutCase not yet implemented"); #endif //Otherwise return -1 return -1; }

void StringBase::SwapChar (  const TCHAR  schar, const TCHAR  rchar )

Exchange all schar characters in the string with rchar characters Scope: Public. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 19/04/95 Parameters: schar  - the search character [INPUTS] rchar - the replacement character Returns: - Definition at line 946 of file basestr.cpp. { ERROR3IF(!text ,"Call to String::SwapChar for an unALLOCated String"); if (text) { TCHAR* pThis = text; while( *pThis != wxT('\0') ) { if (*pThis == schar) *pThis = rchar; pThis = camStrinc(pThis); } } }

INT32 StringBase::TCharToNum (  TCHAR  c  )  [inline, static, private]

Convert a TCHAR into a numeric value. The routine does not check for valid numeric characters, it just performs the conversion. Hence it is possibly for you to pass in the character 's' for instance and receive a >9 value back. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 29/07/96 Parameters: c,a  character [INPUTS] Returns: If c turns out to be a numeric character, its numeric value 0..9 Definition at line 1097 of file basestr.h. { return c - TEXT('0'); }

void StringBase::ThrowStringException (   )  [static, private]

Throws a 'User' exception if the string exception stack says 'Yes'. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 29/07/96 Definition at line 1374 of file basestr.cpp. { PORTNOTETRACE("other","StringBase::ThrowStringException - do nothing"); #ifndef EXCLUDE_FROM_XARALX if (StringBase::WillThrowException()) AfxThrowUserException(); #endif }

StringBase & StringBase::toLower (   )  [inline]

Converts all upper-case letters to lower-case. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 22nd April 1993 Definition at line 749 of file basestr.h. { ERROR3IF(!text, "Call to TOLOWER for an unALLOCated String"); if (text) CharLower(text); return *this; }

StringBase & StringBase::toTitle (   )

Converts all the first letters of words to uppercase and the rest to lower case. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 30/10/97 Definition at line 196 of file basestr.cpp. { ERROR3IF(text == 0, "Call to TOLOWER for an unALLOCated String"); //First set up a pointer with which to go through the string TCHAR* pText=text; //And set up a buffer, which we will use to convert the case of single //characters //GTODO: Put this in a separate function? TCHAR bufToConvert[2]; bufToConvert[0]='\0'; bufToConvert[1]='\0'; //Now, until we reach the end of the string while (pText && *pText!='\0') { //Move pText through the string until it points //to a letter while (pText && !IsAlpha(*pText) && *pText!='\0') { pText++; } //And, if we are not at the end of the string if (pText && *pText!='\0') { //Convert that letter to upper case bufToConvert[0]=*pText; CharUpper(bufToConvert); *pText=bufToConvert[0]; //Now advance to the next character pText++; } //And convert any following letters to lower case, until //we reach the end of the string of letters. We also //count apostrophes as letters, since they may be part of //a word while (pText && (IsAlpha(*pText) || *pText=='\'')) { // Convert that letter to lower case bufToConvert[0]=*pText; CharLower(bufToConvert); *pText=bufToConvert[0]; // And advance to the next letter pText++; } } return *this; }

StringBase & StringBase::toUpper (   )  [inline]

Converts all lower-case letters in the string to upper-case. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 22nd April 1993 Definition at line 735 of file basestr.h. { ERROR3IF(!text, "Call to TOUPPER for an unALLOCated String"); if (text) CharUpper(text); // get Windows API to convert return *this; }

BOOL StringBase::WillThrowException (   )  [static]

This function interogates the exceptions state stack and determins whether exceptions will be thrown or not. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 29/07/96 Parameters: -  [INPUTS] Returns: TRUE if exceptions will currently be thrown FALSE if functions will return errors (ie out of range indexes) Definition at line 1357 of file basestr.cpp. { return (CurrEx < 0) ? FALSE : ThrowExceptionStack[CurrEx]; }

---

Friends And Related Function Documentation

friend class Error [friend]

Definition at line 164 of file basestr.h.

bool operator!= (  const StringBase &  x, const StringBase &  y )  [friend]

Comparison (logical) operators, eg. x = "alpha"; y = "beta"; cout << "First is " << (x < y ? x : y) << endl; These functions will work according to local custom. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> (Jason) Date: 22nd April 1993 (24/5/94) (23/4/96) Returns Return 0 (FALSE) or 1 (TRUE) according to the relative lexical order of two strings. Notes: Now uses IsIdentical to compare the strings, which is 12 times faster than the new internationalised CompareTo. Definition at line 961 of file basestr.h. { return !x.IsIdentical(y); }

bool operator!= (  const StringBase &  x, const TCHAR *  y )  [friend]

Definition at line 967 of file basestr.h. { return !x.IsIdentical(y); }

bool operator< (  const StringBase &  x, const StringBase &  y )  [friend]

Comparison (logical) operators, eg. x = "alpha"; y = "beta"; cout << "First is " << (x < y ? x : y) << endl; These functions will work according to local custom. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> (Jason) Date: 22nd April 1993 (24/5/94) Returns Return 0 (FALSE) or 1 (TRUE) according to the relative lexical order of two strings. Definition at line 987 of file basestr.h. { return x.CompareTo(y) < 0; }

bool operator< (  const StringBase &  x, const TCHAR *  y )  [friend]

Definition at line 993 of file basestr.h. { return x.CompareTo(y) < 0; }

std::ostream& operator<< (  std::ostream &  os, const StringBase &  s )  [friend]

Write a string to a (non-persistent) stream. If the string is 0 then "[0]" is printed. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 22nd April 1993 Parameters: A  reference to an output stream) and a reference to the constant string [INPUTS] to write to it. Returns: Reference to the output stream. See also: istream& operator>>(istream& is, StringBase& s) Definition at line 1274 of file basestr.cpp. { ERROR3IF(!s.text, "Call to ostream << for an unALLOCated String"); os << (s.Length() ? s.text : TEXT("[0]")); return os; }

bool operator<= (  const StringBase &  x, const StringBase &  y )  [friend]

Comparison (logical) operators, eg. x = "alpha"; y = "beta"; cout << "First is " << (x < y ? x : y) << endl; These functions will work according to local custom. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> (Jason) Date: 22nd April 1993 (24/5/94) Returns Return 0 (FALSE) or 1 (TRUE) according to the relative lexical order of two strings. Definition at line 1041 of file basestr.h. { return x.CompareTo(y) <= 0; }

bool operator<= (  const StringBase &  x, const TCHAR *  y )  [friend]

Definition at line 1047 of file basestr.h. { return x.CompareTo(y) <= 0; }

bool operator== (  const StringBase &  x, const StringBase &  y )  [friend]

Definition at line 938 of file basestr.h. { return x.IsIdentical(y); }

bool operator== (  const StringBase &  x, const TCHAR *  y )  [friend]

Comparison (logical) operators, eg. x = "alpha"; y = "beta"; cout << "First is " << (x < y ? x : y) << endl; These functions will work according to local custom. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> (Jason) Date: 22nd April 1993 (24/5/94) (23/4/96) Returns Return 0 (FALSE) or 1 (TRUE) according to the relative lexical order of two strings. Notes: Now uses IsIdentical to compare the strings, which is 12 times faster than the new internationalised CompareTo. Definition at line 932 of file basestr.h. { return x.IsIdentical(y); }

bool operator> (  const StringBase &  x, const StringBase &  y )  [friend]

Comparison (logical) operators, eg. x = "alpha"; y = "beta"; cout << "First is " << (x < y ? x : y) << endl; These functions will work according to local custom. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> (Jason) Date: 22nd April 1993 (24/5/94) Returns Return 0 (FALSE) or 1 (TRUE) according to the relative lexical order of two strings. Definition at line 1014 of file basestr.h. { return x.CompareTo(y) > 0; }

bool operator> (  const StringBase &  x, const TCHAR *  y )  [friend]

Definition at line 1020 of file basestr.h. { return x.CompareTo(y) > 0; }

bool operator>= (  const StringBase &  x, const StringBase &  y )  [friend]

Definition at line 1076 of file basestr.h. { return x.CompareTo(y) >= 0; }

bool operator>= (  const StringBase &  x, const TCHAR *  y )  [friend]

Comparison (logical) operators, eg. x = "alpha"; y = "beta"; cout << "First is " << (x < y ? x : y) << endl; These functions will work according to local custom. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> (Jason) Date: 22nd April 1993 (24/5/94) Returns Return 0 (FALSE) or 1 (TRUE) according to the relative lexical order of two strings. Definition at line 1069 of file basestr.h. { return x.CompareTo(y) >= 0; }

std::istream& operator>> (  std::istream &  is, StringBase &  s )  [friend]

Read a string from a (non-persistent) stream. The input is terminated by a newline character (NOT whitespace, cf. reading C-style character arrays). If the string is longer than MAX_STRING_RES_LENGTH get() will read as many characters as possible and put a newline at the end. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 22nd April 1993 Parameters: A  reference to an input stream and a reference to the string whose [INPUTS] value is to be read. Returns: A reference to the input stream, which enables the chaining of stream operations. See also: ostream& operator<<(ostream& os, const StringBase& s) Definition at line 1240 of file basestr.cpp. { ERROR3IF(!s.text, "Call to istream >> for an unALLOCated String"); char temp[MAX_STRING_RES_LENGTH]; is >> std::ws; // skip any leading whitespace is.get(temp, MAX_STRING_RES_LENGTH); // grab a chunk of input, up to a newline ERROR3IF( size_t(s.length) <= strlen(temp), "Call to istream >> will overflow String" ); #if wxUSE_UNICODE PORTNOTE("other","This is not very efficient needs revisiting") TCHAR ptsz[MAX_STRING_RES_LENGTH]; mbstowcs( ptsz, temp, MAX_STRING_RES_LENGTH ); #else s = temp; // NB. s.operator=(const TCHAR*) #endif return is; }

---

Member Data Documentation

INT32 StringBase::CurrEx = -1 [static, private]

Definition at line 298 of file basestr.h.

UINT32 StringBase::length [protected]

Definition at line 307 of file basestr.h.

TCHAR* StringBase::text [protected]

Definition at line 306 of file basestr.h.

BOOL StringBase::ThrowExceptionStack [static, private]

Definition at line 297 of file basestr.h.

---

The documentation for this class was generated from the following files:

• wxOil/basestr.h (r1785/r1283)
• wxOil/basestr.cpp (r1785/r1282)
• wxOil/makemsg.cpp (r1785/r1333)

---