-Here is a very, very, very ugly macro, but it makes things more
-transparent in cases, where a library function requires a
-(const wxString\& ) argument. This is especially the case in wxWindows,
-where all char-arguments are (const wxString\& ) and not (const char* ).
-This macro should only be used in such cases and NOT to
-modify the internal data.
-The conventional way would be 'function((char*)string.Chars())'.
-With the wxCHARARG macro, this can be achieved by 'function(wxCHARARG(string))'.
-This makes it clearer that the usage should be confined
-to arguments.
-
-\membersection{CommonPrefix}\label{wxstringCommonPrefix}
-
-\func{friend wxString}{CommonPrefix}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y},\\
- \param{int}{ startpos = 0}}\\
-
-\membersection{CommonSuffix}\label{wxstringCommonSuffix}
-
-\func{friend wxString}{CommonSuffix}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y},\\
- \param{int}{ startpos = -1}}
-
-\membersection{Compare}\label{wxstringCompare}
-
-\func{int}{Compare}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}\\
-\func{int}{Compare}{\param{const wxString\&}{ x}, \param{const wxSubString\&}{ y}}\\
-\func{int}{Compare}{\param{const wxString\&}{ x}, \param{const char*}{ y}}\\
-\func{int}{Compare}{\param{const wxSubString\&}{ x}, \param{const wxString\&}{ y}}\\
-\func{int}{Compare}{\param{const wxSubString\&}{ x}, \param{const wxSubString\&}{ y}}\\
-\func{int}{Compare}{\param{const wxSubString\&}{ x}, \param{const char*}{ y}}
-
-Case dependent comparison. Returns 0 if the match succeeded.
-
-\membersection{FCompare}\label{wxstringFCompare}
-
-\func{int}{FCompare}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}
-
-Case independent comparison. Returns 0 if the match succeeded.
-
-\membersection{Comparison operators}\label{wxstringComparison}
-
-\func{int}{operator $==$}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}\\
-\func{int}{operator $!=$}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}\\
-\func{int}{operator $>$}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}\\
-\func{int}{operator $>=$}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}\\
-\func{int}{operator $<$}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}\\
-\func{int}{operator $<=$}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}\\
-\func{int}{operator $==$}{\param{const wxString\&}{ x}, \param{const wxSubString\&}{ y}}\\
-\func{int}{operator $!=$}{\param{const wxString\&}{ x}, \param{const wxSubString\&}{ y}}\\
-\func{int}{operator $>$}{\param{const wxString\&}{ x}, \param{const wxSubString\&}{ y}}\\
-\func{int}{operator $>=$}{\param{const wxString\&}{ x}, \param{const wxSubString\&}{ y}}\\
-\func{int}{operator $<$}{\param{const wxString\&}{ x}, \param{const wxSubString\&}{ y}}\\
-\func{int}{operator $<=$}{\param{const wxString\&}{ x}, \param{const wxSubString\&}{ y}}\\
-\func{int}{operator $==$}{\param{const wxString\&}{ x}, \param{const char*}{ t}}\\
-\func{int}{operator $!=$}{\param{const wxString\&}{ x}, \param{const char*}{ t}}\\
-\func{int}{operator $>$}{\param{const wxString\&}{ x}, \param{const char*}{ t}}\\
-\func{int}{operator $>=$}{\param{const wxString\&}{ x}, \param{const char*}{ t}}\\
-\func{int}{operator $<$}{\param{const wxString\&}{ x}, \param{const char*}{ t}}\\
-\func{int}{operator $<=$}{\param{const wxString\&}{ x}, \param{const char*}{ t}}\\
-\func{int}{operator $==$}{\param{const wxSubString\&}{ x}, \param{const wxString\&}{ y}}\\
-\func{int}{operator $!=$}{\param{const wxSubString\&}{ x}, \param{const wxString\&}{ y}}\\
-\func{int}{operator $>$}{\param{const wxSubString\&}{ x}, \param{const wxString\&}{ y}}\\
-\func{int}{operator $>=$}{\param{const wxSubString\&}{ x}, \param{const wxString\&}{ y}}\\
-\func{int}{operator $<$}{\param{const wxSubString\&}{ x}, \param{const wxString\&}{ y}}\\
-\func{int}{operator $<=$}{\param{const wxSubString\&}{ x}, \param{const wxString\&}{ y}}\\
-\func{int}{operator $==$}{\param{const wxSubString\&}{ x}, \param{const wxSubString\&}{ y}}\\
-\func{int}{operator $!=$}{\param{const wxSubString\&}{ x}, \param{const wxSubString\&}{ y}}\\
-\func{int}{operator $>$}{\param{const wxSubString\&}{ x}, \param{const wxSubString\&}{ y}}\\
-\func{int}{operator $>=$}{\param{const wxSubString\&}{ x}, \param{const wxSubString\&}{ y}}\\
-\func{int}{operator $<$}{\param{const wxSubString\&}{ x}, \param{const wxSubString\&}{ y}}\\
-\func{int}{operator $<=$}{\param{const wxSubString\&}{ x}, \param{const wxSubString\&}{ y}}\\
-\func{int}{operator $==$}{\param{const wxSubString\&}{ x}, \param{const char*}{ t}}\\
-\func{int}{operator $!=$}{\param{const wxSubString\&}{ x}, \param{const char*}{ t}}\\
-\func{int}{operator $>$}{\param{const wxSubString\&}{ x}, \param{const char*}{ t}}\\
-\func{int}{operator $>=$}{\param{const wxSubString\&}{ x}, \param{const char*}{ t}}\\
-\func{int}{operator $<$}{\param{const wxSubString\&}{ x}, \param{const char*}{ t}}\\
-\func{int}{operator $<=$}{\param{const wxSubString\&}{ x}, \param{const char*}{ t}}
-
-\membersection{operator $+$}\label{wxstringoperatorplus}
-
-\func{wxString}{operator $+$}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}\\
-\func{wxString}{operator $+$}{\param{const wxString\&}{ x}, \param{const wxSubString\&}{ y}}\\
-\func{wxString}{operator $+$}{\param{const wxString\&}{ x}, \param{const char*}{ y}}\\
-\func{wxString}{operator $+$}{\param{const wxString\&}{ x}, \param{char}{ y}}\\
-\func{wxString}{operator $+$}{\param{const wxSubString\&}{ x}, \param{const wxString\&}{ y}}\\
-\func{wxString}{operator $+$}{\param{const wxSubString\&}{ x}, \param{const wxSubString\&}{ y}}\\
-\func{wxString}{operator $+$}{\param{const wxSubString\&}{ x}, \param{const char*}{ y}}\\
-\func{wxString}{operator $+$}{\param{const wxSubString\&}{ x}, \param{char}{ y}}\\
-\func{wxString}{operator $+$}{\param{const char*}{ x}, \param{const wxString\&}{ y}}\\
-\func{wxString}{operator $+$}{\param{const char*}{ x}, \param{const wxSubString\&}{ y}}
-
-\membersection{Join}\label{wxstringJoin}
-
-\func{friend wxString}{Join}{\param{wxString}{ src[]}, \param{int}{ n}, \param{const wxString\&}{ sep}}
-
-\membersection{Split}\label{wxstringSplit}
-
-\func{friend int}{Split}{\param{const wxString\&}{ x}, \param{wxString}{ res[]}, \param{int}{ maxn},\\
- \param{const wxString\&}{ sep}}\\
-\func{friend int}{Split}{\param{const wxString\&}{ x}, \param{wxString}{ res[]}, \param{int}{ maxn},\\
- \param{const wxRegex\&}{ sep}}\\
-
-Split string into array res at separators; return number of elements
+{\bf NB:} This function will use a safe version of {\it vsprintf()} (usually called
+{\it vsnprintf()}) whenever available to always allocate the buffer of correct
+size. Unfortunately, this function is not available on all platforms and the
+dangerous {\it vsprintf()} will be used then which may lead to buffer overflows.
+
+
+\membersection{wxString::PrintfV}\label{wxstringprintfv}
+
+\func{int}{PrintfV}{\param{const wxChar* }{pszFormat}, \param{va\_list}{ argPtr}}
+
+Similar to vprintf. Returns the number of characters written, or an integer less than zero
+on error.
+
+
+\membersection{wxString::Remove}\label{wxstringremove}
+
+\func{wxString\&}{Remove}{\param{size\_t}{ pos}}
+
+Same as Truncate. Removes the portion from {\it pos} to the end of the string.
+
+\func{wxString\&}{Remove}{\param{size\_t}{ pos}, \param{size\_t}{ len}}
+
+Removes {\it len} characters from the string, starting at {\it pos}.
+
+This is a wxWidgets 1.xx compatibility function; you should not use it in new code.
+
+
+\membersection{wxString::RemoveLast}\label{wxstringremovelast}
+
+\func{wxString\&}{RemoveLast}{\void}
+
+Removes the last character.
+
+
+\membersection{wxString::Replace}\label{wxstringreplace}
+
+\func{size\_t}{Replace}{\param{const wxString\&}{ strOld}, \param{const wxString\&}{ strNew}, \param{bool}{ replaceAll = true}}
+
+Replace first (or all) occurrences of substring with another one.
+
+{\it replaceAll}: global replace (default), or only the first occurrence.
+
+Returns the number of replacements made.
+
+
+\membersection{wxString::Right}\label{wxstringright}
+
+\constfunc{wxString}{Right}{\param{size\_t}{ count}}
+
+Returns the last {\it count} characters.
+
+
+\membersection{wxString::SetChar}\label{wxstringsetchar}
+
+\func{void}{SetChar}{\param{size\_t}{ n}, \param{wxChar}{ch}}
+
+Sets the character at position {\it n}.
+
+
+\membersection{wxString::Shrink}\label{wxstringshrink}
+
+\func{void}{Shrink}{\void}
+
+Minimizes the string's memory. This can be useful after a call to
+\helpref{Alloc()}{wxstringalloc} if too much memory were preallocated.
+
+
+\membersection{wxString::StartsWith}\label{wxstringstartswith}
+
+\constfunc{bool}{StartsWith}{\param{const wxString\& }{prefix}, \param{wxString }{*rest = NULL}}
+
+This function can be used to test if the string starts with the specified
+{\it prefix}. If it does, the function will return \true and put the rest
+of the string (i.e. after the prefix) into {\it rest} string if it is not
+{\tt NULL}. Otherwise, the function returns \false and doesn't modify the
+{\it rest}.
+
+
+\membersection{wxString::EndsWith}\label{wxstringendswith}
+
+\constfunc{bool}{EndsWith}{\param{const wxString\& }{suffix}, \param{wxString }{*rest = NULL}}
+
+This function can be used to test if the string ends with the specified
+{\it suffix}. If it does, the function will return \true and put the
+beginning of the string before the suffix into {\it rest} string if it is not
+{\tt NULL}. Otherwise, the function returns \false and doesn't
+modify the {\it rest}.
+
+
+\membersection{wxString::Strip}\label{wxstringstrip}
+
+\begin{verbatim}
+enum wxString::stripType {leading = 0x1, trailing = 0x2, both = 0x3};
+\end{verbatim}
+
+\constfunc{wxString}{Strip}{\param{stripType}{ s = trailing}}
+
+Strip characters at the front and/or end. The same as Trim except that it
+doesn't change this string.
+
+This is a wxWidgets 1.xx compatibility function; you should not use it in new code.
+
+
+\membersection{wxString::SubString}\label{wxstringsubstring}
+
+\constfunc{wxString}{SubString}{\param{size\_t}{ from}, \param{size\_t}{ to}}
+
+Returns the part of the string between the indices {\it from} and {\it to}
+inclusive.
+
+This is a wxWidgets 1.xx compatibility function, use \helpref{Mid}{wxstringmid}
+instead (but note that parameters have different meaning).
+
+
+\membersection{wxString::To8BitData}\label{wxstringto8bitdata}
+
+\constfunc{const char*}{To8BitData}{\void}
+
+Converts the string to an 8-bit string (ANSI builds only).
+
+\constfunc{const wxCharBuffer}{To8BitData}{\void}
+
+Converts the string to an 8-bit string in ISO-8859-1 encoding in the form of
+a wxCharBuffer (Unicode builds only).
+
+This is a convenience method useful when storing binary data in wxString.
+
+\newsince{2.8.4}
+
+\wxheading{See also}
+
+\helpref{From8BitData}{wxstringfrom8bitdata}
+
+
+\membersection{wxString::ToAscii}\label{wxstringtoascii}
+
+\constfunc{const char*}{ToAscii}{\void}
+
+\constfunc{const wxCharBuffer}{ToAscii}{\void}
+
+Converts the string to an ASCII, 7-bit string in the form of
+a wxCharBuffer (Unicode builds only) or a C string (ANSI builds).
+
+Note that this conversion only works if the string contains only ASCII
+characters. The \helpref{mb\_str}{wxstringmbstr} method provides more
+powerful means of converting wxString to C string.
+
+
+\membersection{wxString::ToDouble}\label{wxstringtodouble}
+
+\constfunc{bool}{ToDouble}{\param{double}{ *val}}
+
+Attempts to convert the string to a floating point number. Returns \true on
+success (the number is stored in the location pointed to by {\it val}) or \false
+if the string does not represent such number.
+
+\wxheading{See also}
+
+\helpref{wxString::ToLong}{wxstringtolong},\\
+\helpref{wxString::ToULong}{wxstringtoulong}
+
+
+\membersection{wxString::ToLong}\label{wxstringtolong}
+
+\constfunc{bool}{ToLong}{\param{long}{ *val}, \param{int }{base = $10$}}
+
+Attempts to convert the string to a signed integer in base {\it base}. Returns
+\true on success in which case the number is stored in the location
+pointed to by {\it val} or \false if the string does not represent a
+valid number in the given base.
+
+The value of {\it base} must be comprised between $2$ and $36$, inclusive, or
+be a special value $0$ which means that the usual rules of {\tt C} numbers are
+applied: if the number starts with {\tt 0x} it is considered to be in base
+$16$, if it starts with {\tt 0} - in base $8$ and in base $10$ otherwise. Note
+that you may not want to specify the base $0$ if you are parsing the numbers
+which may have leading zeroes as they can yield unexpected (to the user not
+familiar with C) results.
+
+\wxheading{See also}
+
+\helpref{wxString::ToDouble}{wxstringtodouble},\\
+\helpref{wxString::ToULong}{wxstringtoulong}
+
+
+\membersection{wxString::ToLongLong}\label{wxstringtolonglong}
+
+\constfunc{bool}{ToLongLong}{\param{wxLongLong\_t}{ *val}, \param{int }{base = $10$}}
+
+This is exactly the same as \helpref{ToLong}{wxstringtolong} but works with 64
+bit integer numbers.
+
+Notice that currently it doesn't work (always returns \false) if parsing of 64
+bit numbers is not supported by the underlying C run-time library. Compilers
+with C99 support and Microsoft Visual C++ version 7 and higher do support this.
+
+\wxheading{See also}
+
+\helpref{wxString::ToLong}{wxstringtolong},\\
+\helpref{wxString::ToULongLong}{wxstringtoulonglong}
+
+
+\membersection{wxString::ToULong}\label{wxstringtoulong}
+
+\constfunc{bool}{ToULong}{\param{unsigned long}{ *val}, \param{int }{base = $10$}}
+
+Attempts to convert the string to an unsigned integer in base {\it base}.
+Returns \true on success in which case the number is stored in the
+location pointed to by {\it val} or \false if the string does not
+represent a valid number in the given base. Please notice that this function
+behaves in the same way as the standard \texttt{strtoul()} and so it simply
+converts negative numbers to unsigned representation instead of rejecting them
+(e.g. $-1$ is returned as \texttt{ULONG\_MAX}).
+
+See \helpref{wxString::ToLong}{wxstringtolong} for the more detailed
+description of the {\it base} parameter.
+
+\wxheading{See also}
+
+\helpref{wxString::ToDouble}{wxstringtodouble},\\
+\helpref{wxString::ToLong}{wxstringtolong}
+
+
+\membersection{wxString::ToULongLong}\label{wxstringtoulonglong}
+
+\constfunc{bool}{ToULongLong}{\param{wxULongLong\_t}{ *val}, \param{int }{base = $10$}}
+
+This is exactly the same as \helpref{ToULong}{wxstringtoulong} but works with 64
+bit integer numbers.
+
+Please see \helpref{ToLongLong}{wxstringtolonglong} for additional remarks.
+
+
+\membersection{wxString::ToUTF8}\label{wxstringtoutf8}
+
+\constfunc{const char*}{ToUTF8}{\void}
+
+\constfunc{const wxCharBuffer}{ToUF8}{\void}
+
+Same as \helpref{utf8\_str}{wxstringutf8str}.
+
+
+\membersection{wxString::Trim}\label{wxstringtrim}
+
+\func{wxString\&}{Trim}{\param{bool}{ fromRight = true}}
+
+Removes white-space (space, tabs, form feed, newline and carriage return) from
+the left or from the right end of the string (right is default).
+
+
+\membersection{wxString::Truncate}\label{wxstringtruncate}
+
+\func{wxString\&}{Truncate}{\param{size\_t}{ len}}
+
+Truncate the string to the given length.
+
+
+\membersection{wxString::UngetWriteBuf}\label{wxstringungetwritebuf}
+
+\func{void}{UngetWriteBuf}{\void}
+
+\func{void}{UngetWriteBuf}{\param{size\_t }{len}}
+
+Puts the string back into a reasonable state (in which it can be used
+normally), after
+\rtfsp\helpref{wxString::GetWriteBuf}{wxstringgetwritebuf} was called.
+
+The version of the function without the {\it len} parameter will calculate the
+new string length itself assuming that the string is terminated by the first
+{\tt NUL} character in it while the second one will use the specified length
+and thus is the only version which should be used with the strings with
+embedded {\tt NUL}s (it is also slightly more efficient as {\tt strlen()}
+doesn't have to be called).
+
+This method is deprecated, please use
+\helpref{wxStringBuffer}{wxstringbuffer} or
+\helpref{wxStringBufferLength}{wxstringbufferlength} instead.
+
+
+\membersection{wxString::Upper}\label{wxstringupper}
+
+\constfunc{wxString}{Upper}{\void}
+
+Returns this string converted to upper case.
+
+
+\membersection{wxString::UpperCase}\label{wxstringuppercase}
+
+\func{void}{UpperCase}{\void}
+
+The same as MakeUpper.
+
+This is a wxWidgets 1.xx compatibility function; you should not use it in new code.
+
+
+\membersection{wxString::utf8\_str}\label{wxstringutf8str}
+
+\constfunc{const char*}{utf8\_str}{\void}
+
+\constfunc{const wxCharBuffer}{utf8\_str}{\void}
+
+Converts the strings contents to UTF-8 and returns it either as a temporary
+wxCharBuffer object or as a pointer to the internal string contents in
+UTF-8 build.
+% FIXME-UTF8: link to a topic explaining UTF-8 build here
+
+
+\membersection{wxString::wc\_str}\label{wxstringwcstr}
+
+\constfunc{const wchar\_t*}{wc\_str}{\param{const wxMBConv\&}{ conv}}
+
+\constfunc{const wxWCharBuffer}{wc\_str}{\param{const wxMBConv\&}{ conv}}
+
+Returns wide character representation of the string.
+In ANSI build, converts using \arg{conv}'s \helpref{cMB2WC}{wxmbconvcmb2wc}
+method and returns wxWCharBuffer. In Unicode build, this function is same
+as \helpref{c\_str}{wxstringcstr}.
+The macro wxWX2WCbuf is defined as the correct return type (without const).
+
+\wxheading{See also}
+
+\helpref{wxMBConv}{wxmbconv},
+\helpref{c\_str}{wxstringcstr}, \helpref{mb\_str}{wxstringwcstr},
+\helpref{fn\_str}{wxstringfnstr}, \helpref{wchar\_str}{wxstringwcharstr}
+
+\membersection{wxString::wchar\_str}\label{wxstringwcharstr}
+
+\constfunc{wxWritableWCharBuffer}{wchar\_str}{\void}
+
+Returns an object with string data that is implicitly convertible to
+{\tt char*} pointer. Note that changes to the returned buffer may or may
+not be lost (depending on the build) and so this function is only usable for
+passing strings to legacy libraries that don't have const-correct API. Use
+\helpref{wxStringBuffer}{wxstringbuffer} if you want to modify the string.
+
+\wxheading{See also}
+
+\helpref{mb\_str}{wxstringmbstr}, \helpref{wc\_str}{wxstringwcstr},
+\helpref{fn\_str}{wxstringfnstr}, \helpref{c\_str}{wxstringcstr},
+\helpref{char\_str}{wxstringcharstr}
+
+
+\membersection{wxString::operator!}\label{wxstringoperatornot}
+
+\constfunc{bool}{operator!}{\void}
+
+Empty string is \false, so !string will only return \true if the string is empty.
+This allows the tests for NULLness of a {\it const wxChar *} pointer and emptiness
+of the string to look the same in the code and makes it easier to port old code
+to wxString.
+
+See also \helpref{IsEmpty()}{wxstringisempty}.
+
+
+\membersection{wxString::operator $=$}\label{wxstringoperatorassign}
+
+\func{wxString\&}{operator $=$}{\param{const wxString\&}{ str}}
+
+\func{wxString\&}{operator $=$}{\param{const wxChar*}{ psz}}
+
+\func{wxString\&}{operator $=$}{\param{wxChar}{ c}}
+
+Assignment: the effect of each operation is the same as for the corresponding
+constructor (see \helpref{wxString constructors}{wxstringconstruct}).
+
+
+\membersection{wxString::operator $+$}\label{wxstringoperatorplus}
+
+Concatenation: all these operators return a new string equal to the
+concatenation of the operands.
+
+\func{wxString}{operator $+$}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}
+
+\func{wxString}{operator $+$}{\param{const wxString\&}{ x}, \param{const wxChar*}{ y}}
+
+\func{wxString}{operator $+$}{\param{const wxString\&}{ x}, \param{wxChar}{ y}}
+
+\func{wxString}{operator $+$}{\param{const wxChar*}{ x}, \param{const wxString\&}{ y}}
+
+
+\membersection{wxString::operator $+=$}\label{wxstringplusequal}
+
+\func{void}{operator $+=$}{\param{const wxString\&}{ str}}
+
+\func{void}{operator $+=$}{\param{const wxChar*}{ psz}}
+
+\func{void}{operator $+=$}{\param{wxChar}{ c}}
+
+Concatenation in place: the argument is appended to the string.
+
+
+\membersection{wxString::operator []}\label{wxstringoperatorbracket}
+
+\func{wxChar\&}{operator []}{\param{size\_t}{ i}}
+
+\constfunc{wxChar}{operator []}{\param{size\_t}{ i}}
+
+\func{wxChar\&}{operator []}{\param{int}{ i}}
+
+\constfunc{wxChar}{operator []}{\param{int}{ i}}
+
+Element extraction.
+
+
+\membersection{wxString::operator ()}\label{wxstringoperatorparenth}
+
+\func{wxString}{operator ()}{\param{size\_t}{ start}, \param{size\_t}{ len}}
+
+Same as Mid (substring extraction).
+
+
+\membersection{wxString::operator \cinsert}\label{wxstringoperatorout}
+
+\func{wxString\&}{operator \cinsert}{\param{const wxString\&}{ str}}
+
+\func{wxString\&}{operator \cinsert}{\param{const wxChar*}{ psz}}
+
+\func{wxString\&}{operator \cinsert}{\param{wxChar }{ch}}
+
+Same as $+=$.
+
+\func{wxString\&}{operator \cinsert}{\param{int}{ i}}
+
+\func{wxString\&}{operator \cinsert}{\param{float}{ f}}
+
+\func{wxString\&}{operator \cinsert}{\param{double}{ d}}
+
+These functions work as C++ stream insertion operators: they insert the given
+value into the string. Precision or format cannot be set using them, you can use
+\helpref{Printf}{wxstringprintf} for this.
+
+
+\membersection{wxString::operator \cextract}\label{wxstringoperatorin}
+
+\func{friend istream\&}{operator \cextract}{\param{istream\&}{ is}, \param{wxString\&}{ str}}
+
+Extraction from a stream.
+
+
+\membersection{wxString::operator const wxChar*}\label{wxstringoperatorconstcharpt}
+
+\constfunc{}{operator const wxChar*}{\void}
+
+Implicit conversion to a C string.
+
+
+\membersection{Comparison operators}\label{wxstringcomparison}
+
+\func{bool}{operator $==$}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}
+
+\func{bool}{operator $==$}{\param{const wxString\&}{ x}, \param{const wxChar*}{ t}}
+
+\func{bool}{operator $!=$}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}
+
+\func{bool}{operator $!=$}{\param{const wxString\&}{ x}, \param{const wxChar*}{ t}}
+
+\func{bool}{operator $>$}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}
+
+\func{bool}{operator $>$}{\param{const wxString\&}{ x}, \param{const wxChar*}{ t}}
+
+\func{bool}{operator $>=$}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}
+
+\func{bool}{operator $>=$}{\param{const wxString\&}{ x}, \param{const wxChar*}{ t}}
+
+\func{bool}{operator $<$}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}
+
+\func{bool}{operator $<$}{\param{const wxString\&}{ x}, \param{const wxChar*}{ t}}
+
+\func{bool}{operator $<=$}{\param{const wxString\&}{ x}, \param{const wxString\&}{ y}}
+
+\func{bool}{operator $<=$}{\param{const wxString\&}{ x}, \param{const wxChar*}{ t}}
+
+\wxheading{Remarks}
+
+These comparisons are case-sensitive.
+
+
+\section{\class{wxStringBuffer}}\label{wxstringbuffer}
+
+This tiny class allows to conveniently access the \helpref{wxString}{wxstring}
+internal buffer as a writable pointer without any risk of forgetting to restore
+the string to the usable state later.
+
+For example, assuming you have a low-level OS function called
+{\tt GetMeaningOfLifeAsString(char *)} returning the value in the provided
+buffer (which must be writable, of course) you might call it like this:
+
+\begin{verbatim}
+ wxString theAnswer;
+ GetMeaningOfLifeAsString(wxStringBuffer(theAnswer, 1024));
+ if ( theAnswer != "42" )
+ {
+ wxLogError("Something is very wrong!");
+ }
+\end{verbatim}
+
+Note that the exact usage of this depends on whether on not wxUSE\_STL is enabled. If
+wxUSE\_STL is enabled, wxStringBuffer creates a separate empty character buffer, and
+if wxUSE\_STL is disabled, it uses GetWriteBuf() from wxString, keeping the same buffer
+wxString uses intact. In other words, relying on wxStringBuffer containing the old
+wxString data is probably not a good idea if you want to build your program in both
+with and without wxUSE\_STL.
+
+\wxheading{Derived from}
+
+None
+
+\wxheading{Include files}
+
+<wx/string.h>
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+
+\membersection{wxStringBuffer::wxStringBuffer}\label{wxstringbufferctor}
+
+\func{}{wxStringBuffer}{\param{const wxString\& }{str}, \param{size\_t }{len}}
+
+Constructs a writable string buffer object associated with the given string
+and containing enough space for at least {\it len} characters. Basically, this
+is equivalent to calling \helpref{GetWriteBuf}{wxstringgetwritebuf} and
+saving the result.
+
+
+\membersection{wxStringBuffer::\destruct{wxStringBuffer}}\label{wxstringbufferdtor}
+
+\func{}{\destruct{wxStringBuffer}}{\void}
+
+Restores the string passed to the constructor to the usable state by calling
+\helpref{UngetWriteBuf}{wxstringungetwritebuf} on it.
+
+
+\membersection{wxStringBuffer::operator wxChar *}\label{wxstringbufferwxchar}
+
+\func{wxChar *}{operator wxChar *}{\void}
+
+Returns the writable pointer to a buffer of the size at least equal to the
+length specified in the constructor.
+
+
+
+\section{\class{wxStringBufferLength}}\label{wxstringbufferlength}
+
+This tiny class allows to conveniently access the \helpref{wxString}{wxstring}
+internal buffer as a writable pointer without any risk of forgetting to restore
+the string to the usable state later, and allows the user to set the internal
+length of the string.
+
+For example, assuming you have a low-level OS function called
+{\tt int GetMeaningOfLifeAsString(char *)} copying the value in the provided
+buffer (which must be writable, of course), and returning the actual length
+of the string, you might call it like this:
+
+\begin{verbatim}
+ wxString theAnswer;
+ wxStringBuffer theAnswerBuffer(theAnswer, 1024);
+ int nLength = GetMeaningOfLifeAsString(theAnswerBuffer);
+ theAnswerBuffer.SetLength(nLength);
+ if ( theAnswer != "42" )
+ {
+ wxLogError("Something is very wrong!");
+ }
+\end{verbatim}
+
+Note that the exact usage of this depends on whether on not wxUSE\_STL is enabled. If
+wxUSE\_STL is enabled, wxStringBuffer creates a separate empty character buffer, and
+if wxUSE\_STL is disabled, it uses GetWriteBuf() from wxString, keeping the same buffer
+wxString uses intact. In other words, relying on wxStringBuffer containing the old
+wxString data is probably not a good idea if you want to build your program in both
+with and without wxUSE\_STL.
+
+Note that SetLength {\tt must} be called before wxStringBufferLength destructs.
+
+\wxheading{Derived from}
+
+None
+
+\wxheading{Include files}
+
+<wx/string.h>
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+
+\membersection{wxStringBufferLength::wxStringBufferLength}\label{wxstringbufferlengthctor}
+
+\func{}{wxStringBufferLength}{\param{const wxString\& }{str}, \param{size\_t }{len}}
+
+Constructs a writable string buffer object associated with the given string
+and containing enough space for at least {\it len} characters. Basically, this
+is equivalent to calling \helpref{GetWriteBuf}{wxstringgetwritebuf} and
+saving the result.
+
+
+\membersection{wxStringBufferLength::\destruct{wxStringBufferLength}}\label{wxstringbufferlengthdtor}
+
+\func{}{\destruct{wxStringBufferLength}}{\void}
+
+Restores the string passed to the constructor to the usable state by calling
+\helpref{UngetWriteBuf}{wxstringungetwritebuf} on it.
+
+
+\membersection{wxStringBufferLength::SetLength}\label{wxstringbufferlengthsetlength}
+
+\func{void}{SetLength}{\param{size\_t }{nLength}}
+
+Sets the internal length of the string referred to by wxStringBufferLength to
+{\it nLength} characters.
+
+Must be called before wxStringBufferLength destructs.
+
+
+\membersection{wxStringBufferLength::operator wxChar *}\label{wxstringbufferlengthwxchar}
+
+\func{wxChar *}{operator wxChar *}{\void}
projects / wxWidgets.git / blobdiff