RWClassicCString
Module: Essential Tools Module Group: String Processing Classes
Does not inherit
- Local Index
- Synopsis
- Description
- RWCString and Mutexes
- Persistence
- Example
- Enumerations
- Public Constructors
- Type Conversion
- Assignment Operators
- Indexing Operators
- Public Member Functions
- Static Public Member Functions
- Related Global Operators
- Related Global Functions
- Global Logical Operators
Local Index
Members
Non-Members
|
operator!=() operator>>() operator>() |
operator>=() operator<<() operator<() |
operator<=() operator+() operator==() |
strXForm() toLower() toUpper() |
Synopsis
#include <rw/tools/nostl/cstring.h> RWClassicCString a;
Description
RWClassicCString is an alternate implementation of RWCString, but does not depend on the C++ Standard Library. RWCString is a typedef for RWClassicCString if you define a non-Standard Library build.
NOTE -- Rogue Wave does not support non-standard library builds.
RWClassicCString is designed for use with multibyte character sequences. To manipulate wide character strings, use RWClassicWString.
NOTE -- Member function overloads with std::string or RWCConstSubString appear only when building on top of the C++ Standard Library
RWCString and Mutexes
This section only applies to the Essential Tools Module builds that do NOT use the standard library.
Class RWCString uses a single mutex to protect string reference counts. When run in a multithreaded, multiprocessor environment contention for RWCString's single mutex can cause performance issues.
To address RWCString-related performance issues that may occur in a multithreaded, multiprocessor environment, we have provided a macro, RW_CSTRING_MUTEX_COUNT. This macro lets you adjust RWCString to use any number of mutexes. You use the macro by creating a custom configuration in Rogue Wave Component Builder that defines the macro and sets it equal to the desired number of mutexes (-DRW_CSTRING_MUTEX_COUNT=X). You then build your Essential Tools Module library with the new configuration.
This feature should only be used in a multithreaded, multiprocessor environment when your code is RWCString intensive. In other circumstances, changing the number of mutexes available will negatively affect performance.
To help you determine the optimal number of mutexes, we provide a second macro, RW_CSTRING_MUTEX_COUNT_INFO, that makes available the function printStringMutexCount(). The new function prints a usage histogram for the pool of mutexes. By reviewing the histogram you can determine the best number of mutexes for your environment. To use the printStringMutexCount() function, update your custom configuration to include the macro definition -DRW_CSTRING_MUTEX_COUNT_INFO. You can remove the second macro definition from your library after determining the best number of mutexes.
Persistence
Simple
Example
#include <iostream>
#include <rw/re.h>
#include <rw/cstring.h>
int main()
{
RWCString a("There is no joy in Beantown.");
std::cout << "\"" << a << "\"" << " becomes ";
// Any capitalized "town"
RWCRExpr re("[A-Z][a-z]*town");
a.replace(re, "Redmond");
std::cout << "\"" << a << "\"" << std::endl;
return 0;
}
Program output:
"There is no joy in Beantown." becomes "There is no joy in Redmond."
Enumerations
enum RWClassicCString::stripType
{leading = 0x1, trailing = 0x2, both = 0x3};
Used to specify whether characters are stripped from the beginning of the string, the end, or both.
enum RWClassicCString::caseCompare
{exact, ignoreCase, ignoreCaseStrict};
Used to specify whether comparisons, searches, and hashing functions should use case sensitive (exact) or case-insensitive (ignoreCase) semantics.
enum RWClassicCString::scopeType {one, all};
Used to specify whether regular expression replace replaces the first one substring matched by the regular expression or replaces all substrings matched by the regular expression.
Public Constructors
RWCString();
Creates a string of length zero (the null string).
RWClassicCString(const char* a);
Conversion from the null-terminated character string a. The created string will copy the data pointed to by a, up to the first terminating null. This function is incompatible with a strings with embedded nulls. This function may be incompatible with a MBCS strings.
RWClassicCString(const char* a, size_t N);
Constructs a string from the character string a. The created string will copy the data pointed to by a. Exactly N bytes are copied, including any embedded nulls. Hence, the buffer pointed to by a must be at least N bytes long.
RWClassicCString(RWSize_T ic)
Creates a string of length zero (the null string). The string's capacity (that is, the size it can grow to without resizing) is given by the parameter ic. We recommend creating an RWSize_T value from a numerical constant to pass into this constructor. While RWSize_T knows how to convert size_ts to itself, conforming compilers will choose the conversion to char instead.
RWClassicCString(const RWClassicCString& str);
Copy constructor. The created string will copy str's data.
RWClassicCString(const RWClassicCSubString& ss);
Conversion from sub-string. The created string will copy the substring represented by ss.
RWClassicCString(char c);
Constructs a string containing the single character c.
RWClassicCString(char c, size_t N);
Constructs a string containing the character c repeated N times.
Type Conversion
operator const char*() const;
Access to the RWClassicCString's data as a null terminated string. This data is owned by the RWClassicCString and may not be deleted or changed. If the RWClassicCString object itself changes or goes out of scope, the pointer value previously returned may (will!) become invalid. While the string is null-terminated, note that its length is still given by the member function length(). That is, it may contain embedded nulls.
Assignment Operators
RWClassicCString& operator=(const char* cs);
Assignment operator. Copies the null-terminated character string pointed to by cs into self. Returns a reference to self. This function is incompatible with cs strings with embedded nulls. This function may be incompatible with cs MBCS strings.
RWClassicCString& operator=(const RWClassicCString& str);
Assignment operator. The string will copy str's data. Returns a reference to self.
RWClassicCString& operator+=(const char* cs);
Appends the null-terminated character string pointed to by cs to self. Returns a reference to self. This function is incompatible with cs strings with embedded nulls. This function may be incompatible with cs MBCS strings.
RWClassicCString& operator+=(const RWClassicCString& str);
Appends the string str to self. Returns a reference to self.
Indexing Operators
char& operator[](size_t i); char operator[](size_t i) const;
Return the ith byte. The first variant can be used as an lvalue. The index i must be between 0 and the length of the string, minus one. Bounds checking is performed; if the index is out of range then an exceptionof type RWBoundsErr will occur.
char& operator()(size_t i); char operator()(size_t i) const;
Return the ith byte. The first variant can be used as an lvalue. The index i must be between 0 and the length of the string, minus one. Bounds checking is performed if the pre-processor macro RWBOUNDS_CHECK has been defined before including <rw/tools/nostlcstring.h>. In this case, if the index is out of range, then an exception of type RWBoundsErr will occur.
RWClassicCSubString operator()(size_t start, size_t len); const RWClassicCSubString operator()(size_t start, size_t len) const;
Substring operator. Returns an RWClassicCSubString of self with length len, starting at index start. The first variant can be used as an lvalue. The sum of start plus len must be less than or equal to the string length. If the library was built using the RW_DEBUG flag, and start and len are out of range, then an exception of type RWBoundsErr will occur.
RWClassicCSubString operator()(const RWCRExpr& re, size_t start=0); const RWClassicCSubString operator()(const RWCRExpr& re, size_t start=0) const; RWClassicCSubString operator()(const RWCRegexp& re, size_t start=0); const RWClassicCSubString operator()(const RWCRegexp& re, size_t start=0) const;
Returns the first substring starting after index start that matches the regular expression re. If there is no such substring, then the null substring is returned. The first variant can be used as an lvalue.
Note that if you wish to use operator()(const RWCRExpr&...) you must instead use match(const RWCRExpr&...) described below. The reason for this is that operator(const RWCRExpr&...) and operator(const RWCRegexp) are ambiguous in the case of RWClassicCString::operator("string"). In addition, operator(const char *) and operator(size_t) are ambiguous in the case of RWClassicCString::operator(0).
This function maybe incompatible with strings with embedded nulls. This function is incompatible with MBCS strings.
Public Member Functions
RWClassicCString& append(const char* cs);
Appends a copy of the null-terminated character string pointed to by cs to self. Returns a reference to self. This function is incompatible with cs strings with embedded nulls. This function may be incompatible with cs MBCS strings.
RWClassicCString& append(const char* cs, size_t N);
Appends a copy of the character string cs to self. Exactly N bytes are copied, including any embedded nulls. Hence, the buffer pointed to by cs must be at least N bytes long. Returns a reference to self.
RWClassicCString& append(char c, size_t rep=1);
Appends rep copies of the character c to self. Returns a reference to self. Defaults to 1.
RWClassicCString& append(const RWClassicCString& cstr);
Appends a copy of the string cstr to self. Returns a reference to self.
RWClassicCString& append(const RWClassicCString& cstr, size_t N);
Appends the first N bytes or the length of cstr (whichever is less) of cstr to self. Returns a reference to self.
size_t binaryStoreSize() const;
Returns the number of bytes necessary to store the object using the global function:
RWFile& operator<<(RWFile&, const RWClassicCString&);
size_t capacity() const;
Returns the current capacity of self. This is the number of bytes the string can hold without resizing.
size_t capacity(size_t N);
Hint to the implementation to change the capacity of self to N. Returns the actual capacity.
int collate(const char* str) const; int collate(const RWClassicCString& str) const;
Returns an int less then, greater than, or equal to zero, according to the result of calling the standard C library function ::strcoll() on self and the argument str. This supports locale-dependent collation. Provided only on platforms that provide ::strcoll(). This function is incompatible with strings with embedded nulls.
int compareTo(const char* str,
caseCompare = RWClassicCString::exact) const; int compareTo(const RWClassicCString& str, caseCompare = RWClassicCString::exact) const;
Returns an int less than, greater than, or equal to zero, according to the result of calling the standard C library function memcmp() on self and the argument str. Case sensitivity is according to the caseCompare argument, and may be RWClassicCString::exact or RWClassicCString::ignoreCase. If caseCompare is RWClassicCString::exact, then this function works for all string types. Otherwise, this function is incompatible with MBCS strings. This function is incompatible with const char* strings with embedded nulls. This function may be incompatible with const char* MBCS strings.
bool contains(const char* str,
caseCompare = RWClassicCString::exact) const; bool contains(const RWClassicCString& cs, caseCompare = RWClassicCString::exact) const;
Pattern matching. Returns true if str occurs in self. Case sensitivity is according to the caseCompare argument, and may be RWClassicCString::exact or RWClassicCString::ignoreCase. If caseCompare is RWClassicCString::exact, then this function works for all string types. Otherwise, this function is incompatible with MBCS strings. This function is incompatible with const char* strings with embedded nulls. This function may be incompatible with const char* MBCS strings.
const char* data() const;
Access to the RWClassicCString's data as a null terminated string. This datum is owned by the RWClassicCString and may not be deleted or changed. If the RWClassicCString object itself changes or goes out of scope, the pointer value previously returned will become invalid. While the string is null terminated, note that its length is still given by the member function length(). That is, it may contain embedded nulls.
size_t first(char c) const;
Returns the index of the first occurence of the character c in self. Returns RW_NPOS if there is no such character or if there is an embedded null prior to finding c. This function is incompatible with strings with embedded nulls. This function is incompatible with MBCS strings.
size_t first(char c, size_t) const;
Returns the index of the first occurence of the character c in self. Continues to search past embedded nulls. Returns RW_NPOS if there is no such character. This function is incompatible with MBCS strings.
size_t first(const char* str) const;
Returns the index of the first occurence in self of any character in str. Returns RW_NPOS if there is no match or if there is an embedded null prior to finding any character from str. This function is incompatible with strings with embedded nulls. This function may be incompatible with MBCS strings.
size_t first(const char* str, size_t N) const;
Returns the index of the first occurence in self of any character in str. Exactly N bytes in str are checked including any embedded nulls so str must point to a buffer containing at least N bytes. Returns RW_NPOS if there is no match.
unsigned hash(caseCompare = RWClassicCString::exact) const; static unsigned hash(const RWClassicCString&);
Returns a suitable hash value. If caseCompare is RWClassicCString::ignoreCase then this function will be incompatible with MBCS strings.
size_t
index(const char* pat,size_t i=0,
caseCompare = RWClassicCString::exact) const;
size_t
index(const RWClassicCString& pat,size_t i=0,
caseCompare = RWClassicCString::exact) const;
Pattern matching. Starting with index i, searches for the first occurrence of pat in self and returns the index of the start of the match. Returns RW_NPOS if there is no such pattern. Case sensitivity is according to the caseCompare argument; it defaults to RWClassicCString::exact. If caseCompare is RWClassicCString::exact, then this function works for all string types. Otherwise, this function is incompatible with MBCS strings.
size_t
index(const char* pat, size_t patlen,size_t i,
caseCompare cmp) const;
size_t
index(const RWClassicCString& pat, size_t patlen,size_t i,
caseCompare cmp) const;
Pattern matching. Starting with index i, searches for the first occurrence of the first patlen bytes from pat in self and returns the index of the start of the match. Returns RW_NPOS if there is no such pattern. Case sensitivity is according to the caseCompare argument. If caseCompare is RWClassicCString::exact, then this function works for all string types. Otherwise, this function is incompatible with MBCS strings.
size_t index(const RWCRExpr& re, size_t i=0) const; size_t index(const RWCRegexp& re, size_t i=0) const;
Regular expression matching. Returns the index greater than or equal to i of the start of the first pattern that matches the regular expression re. Returns RW_NPOS if there is no such pattern. This function is incompatible with MBCS strings.
size_t index(const RWCRExpr& re,size_t* ext,size_t i=0) const; size_t index(const RWCRegexp& re,size_t* ext,size_t i=0) const;
Regular expression matching. Returns the index greater than or equal to i of the start of the first pattern that matches the regular expression re. Returns RW_NPOS if there is no such pattern. The length of the matching pattern is returned in the variable pointed to by ext. This function is incompatible with strings with embedded nulls. This function may be incompatible with MBCS strings.
RWClassicCString& insert(size_t pos, const char* cs);
Inserts a copy of the null-terminated string cs into self at byte position pos, thus expanding the string. Returns a reference to self. This function is incompatible with cs strings with embedded nulls. This function may be incompatible with cs MBCS strings.
RWClassicCString& insert(size_t pos, const char* cs, size_t N);
Inserts a copy of the first N bytes of cs into self at byte position pos, thus expanding the string. Exactly N bytes are copied, including any embedded nulls. Hence, the buffer pointed to by cs must be at least N bytes long. Returns a reference to self.
RWClassicCString& insert(size_t pos, const RWClassicCString& str);
Inserts a copy of the string str into self at byte position pos. Returns a reference to self.
RWClassicCString& insert(size_t pos, const RWClassicCString& str, size_t N);
Inserts a copy of the first N bytes or the length of str (whichever is less) into self at byte position pos. Returns a reference to self.
bool isAscii() const;
Returns true if self contains no bytes with the high bit set.
bool isNull() const;
Returns true if this is a zero lengthed string (i.e., the null string).
size_t last(char c) const;
Returns the index of the last occurrence in the string of the character c. Returns RW_NPOS if there is no such character or if there is an embedded null to the right of c in self. This function is incompatible with strings with embedded nulls. This function may be incompatible with MBCS strings.
size_t last(char c, size_t N) const;
Returns the index of the last occurrence in the string of the character c. Continues to search past embedded nulls. Returns RW_NPOS if there is no such character. This function is incompatible with MBCS strings.
size_t length() const;
Returns the number of bytes in self. Note that if self contains multibyte characters, then this will not be the number of characters.
RWClassicCSubString match(const RWCRExpr& re); const RWClassicCSubString match(const RWCRExpr& re, size_t start=0) const;
Returns the first substring starting after index start that matches the regular expression re. If there is no such substring, then the null substring is returned. The first variant can be used as an lvalue. Note that this is used in place of operator()(const RWCRegexp&...) if you want to use extended regular expressions.
size_t mbLength() const;
Returns the number of multibyte characters in self, according to the Standard C function ::mblen(). Returns RW_NPOS if a bad character is encountered. Note that, in general, mbLength() = length(). Provided only on platforms that provide ::mblen().
RWClassicCString& prepend(const char* cs);
Prepends a copy of the null-terminated character string pointed to by cs to self. Returns a reference to self. This function is incompatible with cs strings with embedded nulls. This function may be incompatible with cs MBCS strings.
RWClassicCString& prepend(const char* cs, size_t N);
Prepends a copy of the character string cs to self. Exactly N bytes are copied, including any embedded nulls. Hence, the buffer pointed to by cs must be at least N bytes long. Returns a reference to self.
RWClassicCString& prepend(char c, size_t rep=1);
Prepends rep copies of character c to self. Returns a reference to self.
RWClassicCString& prepend(const RWClassicCString& str);
Prepends a copy of the string str to self. Returns a reference to self.
RWClassicCString& prepend(const RWClassicCString& cstr, size_t N);
Prepends the first N bytes or the length of cstr (whichever is less) to self. Returns a reference to self.
istream& readFile(istream& s);
Reads characters from the input stream s, replacing the previous contents of self, until EOF is reached. Null characters are treated the same as other characters.
istream& readLine(istream& s, bool skipWhite = true);
Reads characters from the input stream s, replacing the previous contents of self, until a newline (or an EOF) is encountered. The newline is removed from the input stream but is not stored. Null characters are treated the same as other characters. If the skipWhite argument is true, then whitespace is skipped (using the iostream library manipulator ws) before saving characters.
istream& readString(istream& s);
Reads characters from the input stream s, replacing the previous contents of self, until an EOF or null terminator is encountered. If the number of bytes remaining in the stream is large, you should resize the RWClassicCString to approximately the number of bytes to be read prior to using this method. This function is incompatible with strings with embedded nulls. This function may be incompatible with MBCS strings.
istream& readToDelim(istream& s, char delim='\n');
Reads characters from the input stream s, replacing the previous contents of self, until an EOF or the delimiting character delim is encountered. The delimiter is removed from the input stream but is not stored. Null characters are treated the same as other characters. If delim is '\0' then this function is incompatible with strings with embedded nulls. and may be incompatible with MBCS strings.
istream& readToken(istream& s);
Whitespace is skipped before saving characters. Characters are then read from the input stream s, replacing previous contents of self, until trailing whitespace or an EOF is encountered. The whitespace is left on the input stream. Null characters are treated the same as other characters. Whitespace is identified by the standard C library function isspace(). This function is incompatible with MBCS strings.
RWClassicCString& remove(size_t pos);
Removes the bytes from the byte position pos, which must be no greater than length(), to the end of string. Returns a reference to self.
RWClassicCString& remove(size_t pos, size_t N);
Removes N bytes or to the end of string (whichever comes first) starting at the byte position pos, which must be no greater than length(). Returns a reference to self.
RWClassicCString& replace(size_t pos, size_t N, const char* cs);
Replaces N bytes or to the end of string (whichever comes first) starting at byte position pos, which must be no greater than length(), with a copy of the null-terminated string cs. Returns a reference to self. This function is incompatible with cs strings with embedded nulls. This function may be incompatible with cs MBCS strings.
RWClassicCString& replace(size_t pos, size_t N1,const char* cs, size_t N2);
Replaces N1 bytes or to the end of string (whichever comes first) starting at byte position pos, which must be no greater than length(), with a copy of the string cs. Exactly N2 bytes are copied, including any embedded nulls. Hence, the buffer pointed to by cs must be at least N2 bytes long. Returns a reference to self.
RWClassicCString& replace(size_t pos, size_t N, const RWClassicCString& str);
Replaces N bytes or to the end of string (whichever comes first) starting at byte position pos, which must be no greater than length(), with a copy of the string str. Returns a reference to self.
RWClassicCString& replace(size_t pos, size_t N1,const RWClassicCString& str,
size_t N2);
Replaces N1 bytes or to the end of string (whichever comes first) starting at position pos, which must be no greater than length(), with a copy of the first N2 bytes, or the length of str (whichever is less), from str. Returns a reference to self.
replace(const RWCRExpr& pattern, const char* replacement,
scopeType scope=one);
replace(const RWCRExpr& pattern,
const RWClassicCString& replacement,
scopeType scope=one);
Replaces substring matched by pattern with replacement string. pattern is the new extended regular expression. scope is one of {one, all} and controls whether all matches of pattern are replaced with replacement or just the first one match is replaced. replacement is the replacement pattern for the string. Here's an example:
RWClassicCString s("hahahohoheehee");
s.replace(RWCRExpr("(ho)+","HAR"); // s == "hahaHARheehee"
This function is incompatible with const char* replacement strings with embedded nulls. This function may be incompatible with const char* replacement MBCS strings.
void resize(size_t n);
Changes the length of self to n bytes, adding blanks or truncating as necessary.
RWClassicCSubString strip(stripType s = RWClassicCString::trailing, char c = ' ');
Returns a substring of self where the character c has been stripped off the beginning, end, or both ends of the string. The first variant can be used as an lvalue. The enum stripType can take values:
RWClassicCSubString
subString(const char* cs, size_t start=0,
caseCompare = RWClassicCString::exact);
RWClassicCSubString
subString(const char* size_t=0,
caseCompare = RWClassicCString::exact) const;
Returns a substring representing the first occurence of the null-terminated string pointed to by "cs". The first variant can be used as an lvalue. Case sensitivity is according to the caseCompare argument; it defaults to RWClassicCString::exact. If caseCompare is RWClassicCString::ignoreCase then this function is incompatible with MBCS strings. This function is incompatible with cs strings with embedded nulls. This function may be incompatible with cs MBCS strings.
void toLower();
Changes all upper-case letters in self to lower-case, using the standard C library facilities declared in <ctype.h>. This function is incompatible with MBCS strings.
void toUpper();
Changes all lower-case letters in self to upper-case, using the standard C library facilities declared in <ctype.h>. This function is incompatible with MBCS strings.
Static Public Member Functions
static unsigned hash(const RWClassicCString& str);
Returns the hash value of str as returned by str.hash(RWClassicCString::exact).
static size_t initialCapacity(size_t ic = 15);
Sets the minimum initial capacity of an RWClassicCString, and returns the old value. The initial setting is 15 bytes. Larger values will use more memory, but result in fewer resizes when concatenating or reading strings. Smaller values will waste less memory, but result in more resizes.
static size_t maxWaste(size_t mw = 15);
Sets the maximum amount of unused space allowed in a string should it shrink, and returns the old value. The initial setting is 15 bytes. If more than mw bytes are wasted, then excess space will be reclaimed.
static size_t resizeIncrement(size_t ri = 16);
Sets the resize increment when more memory is needed to grow a string. Returns the old value. The initial setting is 16 bytes.
Related Global Operators
bool operator==(const RWClassicCString&, const char* ); bool operator==(const char*, const RWClassicCString&); bool operator==(const RWClassicCString&, const RWClassicCString&); bool operator!=(const RWClassicCString&, const char* ); bool operator!=(const char*, const RWClassicCString&); bool operator!=(const RWClassicCString&, const RWClassicCString&);
Logical equality and inequality. Case sensitivity is exact. This function is incompatible with const char* strings with embedded nulls. This function may be incompatible with const char* MBCS strings.
bool operator< (const RWClassicCString&, const char* ); bool operator< (const char*, const RWClassicCString&); bool operator< (const RWClassicCString&, const RWClassicCString&); bool operator> (const RWClassicCString&, const char* ); bool operator> (const char*, const RWClassicCString&); bool operator> (const RWClassicCString&, const RWClassicCString&); bool operator<=(const RWClassicCString&, const char* ); bool operator<=(const char*, const RWClassicCString&); bool operator<=(const RWClassicCString&, const RWClassicCString&); bool operator>=(const RWClassicCString&, const char* ); bool operator>=(const char*, const RWClassicCString&); bool operator>=(const RWClassicCString&, const RWClassicCString&);
Comparisons are done lexicographically, byte by byte. Case sensitivity is exact. Use member collate() or strxfrm() for locale sensitivity. This function is incompatible with const char* strings with embedded nulls. This function may be incompatible with const char* MBCS strings.
RWClassicCString operator+(const RWClassicCString&, const RWClassicCString&); RWClassicCString operator+(const char*, const RWClassicCString&); RWClassicCString operator+(const RWClassicCString&, const char* );
Concatenation operators. This function is incompatible with const char* strings with embedded nulls. This function may be incompatible with const char* MBCS strings.
ostream& operator<<(ostream& s, const RWClassicCString&);
Output an RWClassicCString on ostream s.
istream& operator>>(istream& s, RWClassicCString& str);
Calls str.readToken(s). That is, a token is read from the input stream s. This function is incompatible with MBCS strings.
RWvostream& operator<<(RWvostream&, const RWClassicCString& str); RWFile& operator<<(RWFile&, const RWClassicCString& str);
Saves string str to a virtual stream or RWFile, respectively.
RWvistream& operator>>(RWvistream&, RWClassicCString& str); RWFile& operator>>(RWFile&, RWClassicCString& str);
Restores a string into str from a virtual stream or RWFile, respectively, replacing the previous contents of str.
Related Global Functions
RWClassicCString strXForm(const RWClassicCString&);
Returns the result of applying ::strxfrm() to the argument string, to allow quicker collation than RWClassicCString::collate(). Provided only on platforms that provide ::strxfrm(). This function is incompatible with strings with embedded nulls.
RWClassicCString toLower(const RWClassicCString& str);
Returns a version of str where all upper-case characters have been replaced with lower-case characters. Uses the standard C library function tolower(). This function is incompatible with MBCS strings.
RWClassicCString toUpper(const RWClassicCString& str);
Returns a version of str where all lower-case characters have been replaced with upper-case characters. Uses the standard C library function toupper(). This function is incompatible with MBCS strings.
Global Logical Operators
bool
operator==(const RWClassicCString&,
const RWClassicCSubString&);
bool
operator==(const RWClassicCSubString&,
const RWClassicCString& );
Returns true if the substring is lexicographically equal to the character string or RWClassicCString argument. Case sensitivity is exact.
bool
operator!=(const RWClassicCString&,
const RWClassicCString& );
bool
operator!=(const RWClassicCString&,
const RWClassicCSubString&);
bool
operator!=(const RWClassicCSubString&,
const RWClassicCString& );
bool
operator!=(const char*,
const RWClassicCString& );
bool
operator!=(const RWClassicCString&,
const char* );
Returns the negation of the respective operator==().
© Copyright Rogue Wave Software, Inc. All Rights Reserved.
Rogue Wave and SourcePro are registered trademarks of Rogue Wave Software, Inc. in the United States and other countries. All other trademarks are the property of their respective owners.
Contact Rogue Wave about documentation or support issues.