#ifndef _WX_WXSTRINGH__
#define _WX_WXSTRINGH__
-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
- #pragma interface "string.h"
-#endif
-
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#include <strings.h> // for strcasecmp()
#endif // HAVE_STRCASECMP_IN_STRINGS_H
+#ifdef __WXPALMOS__
+ #include <StringMgr.h>
+#endif
+
#include "wx/wxchar.h" // for wxChar
#include "wx/buffer.h" // for wxCharBuffer
#include "wx/strconv.h" // for wxConvertXXX() macros and wxMBConv classes
+class WXDLLIMPEXP_BASE wxString;
+
// ---------------------------------------------------------------------------
// macros
// ---------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------
-#if defined(__VISAGECPP__) && __IBMCPP__ >= 400
-// must define this static for VA or else you get multiply defined symbols everywhere
-extern const unsigned int wxSTRING_MAXLEN;
-
-#else
// maximum possible length for a string means "take all string" everywhere
-// (as sizeof(StringData) is unknown here, we substract 100)
-const unsigned int wxSTRING_MAXLEN = UINT_MAX - 100;
-
-#endif
+#define wxSTRING_MAXLEN wxStringBase::npos
// ----------------------------------------------------------------------------
// global data
return stricmp(psz1, psz2);
#elif defined(__WXPM__)
return stricmp(psz1, psz2);
-#elif defined(HAVE_STRCASECMP_IN_STRING_H) || \
+#elif defined(__WXPALMOS__) || \
+ defined(HAVE_STRCASECMP_IN_STRING_H) || \
defined(HAVE_STRCASECMP_IN_STRINGS_H) || \
defined(__GNUWIN32__)
return strcasecmp(psz1, psz2);
#endif // OS/compiler
}
-// return an empty wxString
-class WXDLLIMPEXP_BASE wxString; // not yet defined
-inline const wxString& wxGetEmptyString() { return *(wxString *)&wxEmptyString; }
+// ----------------------------------------------------------------------------
+// deal with STL/non-STL/non-STL-but-wxUSE_STD_STRING
+// ----------------------------------------------------------------------------
-#if wxUSE_STL
+// in both cases we need to define wxStdString
+#if wxUSE_STL || wxUSE_STD_STRING
#include "wx/beforestd.h"
#include <string>
#if wxUSE_UNICODE
#ifdef HAVE_STD_WSTRING
- typedef std::wstring wxStringBase;
+ typedef std::wstring wxStdString;
#else
- typedef std::basic_string<wxChar> wxStringBase;
+ typedef std::basic_string<wxChar> wxStdString;
#endif
#else
- typedef std::string wxStringBase;
+ typedef std::string wxStdString;
#endif
-#if (defined(__GNUG__) && (__GNUG__ < 3)) || \
- (defined(_MSC_VER) && (_MSC_VER <= 1200))
- #define wxSTRING_BASE_HASNT_CLEAR
-#endif
+#endif // need <string>
+#if wxUSE_STL
+
+ // we don't need an extra ctor from std::string when copy ctor already does
+ // the work
+ #undef wxUSE_STD_STRING
+ #define wxUSE_STD_STRING 0
+
+ #if (defined(__GNUG__) && (__GNUG__ < 3)) || \
+ (defined(_MSC_VER) && (_MSC_VER <= 1200))
+ #define wxSTRING_BASE_HASNT_CLEAR
+ #endif
+
+ typedef wxStdString wxStringBase;
#else // if !wxUSE_STL
-#ifndef HAVE_STD_STRING_COMPARE
+#if !defined(HAVE_STD_STRING_COMPARE) && \
+ (!defined(__WX_SETUP_H__) || wxUSE_STL == 0)
#define HAVE_STD_STRING_COMPARE
#endif
// initializes the string to the empty value (must be called only from
// ctors, use Reinit() otherwise)
void Init() { m_pchData = (wxChar *)wxEmptyString; }
- // initializaes the string with (a part of) C-string
+ // initializes the string with (a part of) C-string
void InitWith(const wxChar *psz, size_t nPos = 0, size_t nLen = npos);
// as Init, but also frees old data
void Reinit() { GetStringData()->Unlock(); Init(); }
typedef value_type *iterator;
typedef const value_type *const_iterator;
+#define wxSTRING_REVERSE_ITERATOR(name, const_or_not) \
+ class name \
+ { \
+ public: \
+ typedef wxChar value_type; \
+ typedef const_or_not value_type& reference; \
+ typedef const_or_not value_type *pointer; \
+ typedef const_or_not value_type *iterator_type; \
+ \
+ name(iterator_type i) : m_cur(i) { } \
+ name(const name& ri) : m_cur(ri.m_cur) { } \
+ \
+ iterator_type base() const { return m_cur; } \
+ \
+ reference operator*() const { return *(m_cur - 1); } \
+ \
+ name& operator++() { --m_cur; return *this; } \
+ name operator++(int) { name tmp = *this; --m_cur; return tmp; } \
+ name& operator--() { ++m_cur; return *this; } \
+ name operator--(int) { name tmp = *this; ++m_cur; return tmp; } \
+ \
+ bool operator==(name ri) const { return m_cur == ri.m_cur; } \
+ bool operator!=(name ri) const { return !(*this == ri); } \
+ \
+ private: \
+ iterator_type m_cur; \
+ }
+
+ wxSTRING_REVERSE_ITERATOR(const_reverse_iterator, const);
+
+ #define wxSTRING_CONST
+ wxSTRING_REVERSE_ITERATOR(reverse_iterator, wxSTRING_CONST);
+ #undef wxSTRING_CONST
+
+ #undef wxSTRING_REVERSE_ITERATOR
+
+
// constructors and destructor
// ctor for an empty string
wxStringBase() { Init(); }
{ InitWith(psz, 0, npos); }
wxStringBase(const wxChar *psz, size_t nLength)
{ InitWith(psz, 0, nLength); }
- wxStringBase(const wxChar *psz, wxMBConv& WXUNUSED(conv), size_t nLength = npos)
+ wxStringBase(const wxChar *psz,
+ const wxMBConv& WXUNUSED(conv),
+ size_t nLength = npos)
{ InitWith(psz, 0, nLength); }
// take nLen chars starting at nPos
wxStringBase(const wxStringBase& str, size_t nPos, size_t nLen)
wxStringBase& operator=(const wxChar *psz);
// return the length of the string
- size_type size() const { return GetStringData()->nDataLength; }
+ size_type length() const { return GetStringData()->nDataLength; }
// return the length of the string
- size_type length() const { return size(); }
+ size_type size() const { return length(); }
// return the maximum size of the string
size_type max_size() const { return wxSTRING_MAXLEN; }
// resize the string, filling the space with c if c != 0
// delete the contents of the string
void clear() { erase(0, npos); }
// returns true if the string is empty
- bool empty() const { return size() == 0; }
+ bool empty() const { return length() == 0; }
// inform string about planned change in size
void reserve(size_t sz) { Alloc(sz); }
size_type capacity() const { return GetStringData()->nAllocLength; }
// return the character at position n
value_type at(size_type n) const
{ wxASSERT_VALID_INDEX( n ); return m_pchData[n]; }
- value_type operator[](size_type n) const { return at(n); }
// returns the writable character at position n
reference at(size_type n)
{ wxASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; }
- reference operator[](size_type n)
- { wxASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; }
// lib.string.modifiers
// append elements str[pos], ..., str[pos+n]
// first valid index position
const_iterator begin() const { return m_pchData; }
+ iterator begin();
// position one after the last valid one
const_iterator end() const { return m_pchData + length(); }
+ iterator end();
- // first valid index position
- iterator begin() { CopyBeforeWrite(); return m_pchData; }
- // position one after the last valid one
- iterator end() { CopyBeforeWrite(); return m_pchData + length(); }
+ // first element of the reversed string
+ const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
+ reverse_iterator rbegin() { return reverse_iterator(end()); }
+ // one beyond the end of the reversed string
+ const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
+ reverse_iterator rend() { return reverse_iterator(begin()); }
// insert another string
wxStringBase& insert(size_t nPos, const wxStringBase& str)
// find a substring
size_t find(const wxStringBase& str, size_t nStart = 0) const;
- // VC++ 1.5 can't cope with this syntax.
-#if !defined(__VISUALC__) || defined(__WIN32__)
// find first n characters of sz
size_t find(const wxChar* sz, size_t nStart = 0, size_t n = npos) const;
-#endif // VC++ 1.5
// find the first occurence of character ch after nStart
size_t find(wxChar ch, size_t nStart = 0) const;
// as find, but from the end
size_t rfind(const wxStringBase& str, size_t nStart = npos) const;
- // VC++ 1.5 can't cope with this syntax.
// as find, but from the end
size_t rfind(const wxChar* sz, size_t nStart = npos,
size_t n = npos) const;
// All compare functions return -1, 0 or 1 if the [sub]string is less,
// equal or greater than the compare() argument.
- // just like strcmp()
- int compare(const wxStringBase& str) const
- { return wxStrcmp(c_str(), str.c_str()); }
+ // comparison with another string
+ int compare(const wxStringBase& str) const;
// comparison with a substring
int compare(size_t nStart, size_t nLen, const wxStringBase& str) const;
// comparison of 2 substrings
int compare(size_t nStart, size_t nLen,
const wxStringBase& str, size_t nStart2, size_t nLen2) const;
- // just like strcmp()
- int compare(const wxChar* sz) const
- { return wxStrcmp(c_str(), sz); }
+ // comparison with a c string
+ int compare(const wxChar* sz) const;
// substring comparison with first nCount characters of sz
int compare(size_t nStart, size_t nLen,
const wxChar* sz, size_t nCount = npos) const;
#endif // !wxUSE_STL
-// ---------------------------------------------------------------------------
-// This is (yet another one) String class for C++ programmers. It doesn't use
-// any of "advanced" C++ features (i.e. templates, exceptions, namespaces...)
-// thus you should be able to compile it with practicaly any C++ compiler.
-// This class uses copy-on-write technique, i.e. identical strings share the
-// same memory as long as neither of them is changed.
-//
-// This class aims to be as compatible as possible with the new standard
-// std::string class, but adds some additional functions and should be at
-// least as efficient than the standard implementation.
-//
-// Performance note: it's more efficient to write functions which take "const
-// String&" arguments than "const char *" if you assign the argument to
-// another string.
-//
-// It was compiled and tested under Win32, Linux (libc 5 & 6), Solaris 5.5.
-//
-// To do:
-// - ressource support (string tables in ressources)
-// - more wide character (UNICODE) support
-// - regular expressions support
+// ----------------------------------------------------------------------------
+// wxString: string class trying to be compatible with std::string, MFC
+// CString and wxWindows 1.x wxString all at once
// ---------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxString : public wxStringBase
// NB: special care was taken in arranging the member functions in such order
// that all inline functions can be effectively inlined, verify that all
- // performace critical functions are still inlined if you change order!
+ // performance critical functions are still inlined if you change order!
private:
// if we hadn't made these operators private, it would be possible to
// compile "wxString s; s = 17;" without any warnings as 17 is implicitly
: wxStringBase(psz ? psz : wxT("")) { }
wxString(const wxChar *psz, size_t nLength)
: wxStringBase(psz, nLength) { }
- wxString(const wxChar *psz, wxMBConv& WXUNUSED(conv), size_t nLength = npos)
+ wxString(const wxChar *psz,
+ const wxMBConv& WXUNUSED(conv),
+ size_t nLength = npos)
: wxStringBase(psz, nLength == npos ? wxStrlen(psz) : nLength) { }
+ // even if we're not built with wxUSE_STL == 1 it is very convenient to allow
+ // implicit conversions from std::string to wxString as this allows to use
+ // the same strings in non-GUI and GUI code, however we don't want to
+ // unconditionally add this ctor as it would make wx lib dependent on
+ // libstdc++ on some Linux versions which is bad, so instead we ask the
+ // client code to define this wxUSE_STD_STRING symbol if they need it
+#if wxUSE_STD_STRING
+ wxString(const wxStdString& s)
+ : wxStringBase(s.c_str()) { }
+#endif // wxUSE_STD_STRING
+
#if wxUSE_UNICODE
// from multibyte string
- // (NB: nLength is right now number of Unicode characters, not
- // characters in psz! So try not to use it yet!)
- wxString(const char *psz, wxMBConv& conv, size_t nLength = npos);
+ wxString(const char *psz, const wxMBConv& conv, size_t nLength = npos);
// from wxWCharBuffer (i.e. return from wxGetString)
wxString(const wxWCharBuffer& psz) : wxStringBase(psz.data()) { }
#else // ANSI
// from C string (for compilers using unsigned char)
- wxString(const unsigned char* psz, size_t nLength = npos)
+ wxString(const unsigned char* psz)
+ : wxStringBase((const char*)psz) { }
+ // from part of C string (for compilers using unsigned char)
+ wxString(const unsigned char* psz, size_t nLength)
: wxStringBase((const char*)psz, nLength) { }
#if wxUSE_WCHAR_T
// from wide (Unicode) string
- wxString(const wchar_t *pwz, wxMBConv& conv = wxConvLibc, size_t nLength = npos);
+ wxString(const wchar_t *pwz,
+ const wxMBConv& conv = wxConvLibc,
+ size_t nLength = npos);
#endif // !wxUSE_WCHAR_T
// from wxCharBuffer
wxString(const wxCharBuffer& psz)
- : wxStringBase(psz, npos) { }
+ : wxStringBase(psz) { }
#endif // Unicode/ANSI
// generic attributes & operations
size_t Len() const { return length(); }
// string contains any characters?
bool IsEmpty() const { return empty(); }
- // empty string is "FALSE", so !str will return TRUE
- bool operator!() const { return IsEmpty(); }
+ // empty string is "false", so !str will return true
+ bool operator!() const { return empty(); }
// truncate the string to given length
wxString& Truncate(size_t uiLen);
// empty string contents
{
Truncate(0);
- wxASSERT_MSG( IsEmpty(), _T("string not empty after call to Empty()?") );
+ wxASSERT_MSG( empty(), _T("string not empty after call to Empty()?") );
}
// empty the string and free memory
void Clear()
// data access (all indexes are 0 based)
// read access
wxChar GetChar(size_t n) const
- { return operator[](n); }
+ { return at(n); }
// read/write access
wxChar& GetWritableChar(size_t n)
- { return operator[](n); }
+ { return at(n); }
// write access
void SetChar(size_t n, wxChar ch)
- { operator[](n) = ch; }
+ { at(n) = ch; }
// get last character
wxChar Last() const
{
- wxASSERT_MSG( !IsEmpty(), _T("wxString: index out of bounds") );
+ wxASSERT_MSG( !empty(), _T("wxString: index out of bounds") );
- return operator[](length() - 1);
+ return at(length() - 1);
}
// get writable last character
wxChar& Last()
{
- wxASSERT_MSG( !IsEmpty(), _T("wxString: index out of bounds") );
- return operator[](length() - 1);
+ wxASSERT_MSG( !empty(), _T("wxString: index out of bounds") );
+ return at(length() - 1);
}
/*
- So why do we have all these overloaded operator[]s? A bit of history:
- initially there was only one of them, taking size_t. Then people
- started complaining because they wanted to use ints as indices (I
- wonder why) and compilers were giving warnings about it, so we had to
- add the operator[](int). Then it became apparent that you couldn't
- write str[0] any longer because there was ambiguity between two
- overloads and so you now had to write str[0u] (or, of course, use the
- explicit casts to either int or size_t but nobody did this).
-
- Finally, someone decided to compile wxWin on an Alpha machine and got
- a surprize: str[0u] didn't compile there because it is of type
- unsigned int and size_t is unsigned _long_ on Alpha and so there was
- ambiguity between converting uint to int or ulong. To fix this one we
- now add operator[](uint) for the machines where size_t is not already
- the same as unsigned int - hopefully this fixes the problem (for some
- time)
-
- The only real fix is, of course, to remove all versions but the one
- taking size_t...
+ Note that we we must define all of the overloads below to avoid
+ ambiguity when using str[0]. Also note that for a conforming compiler we
+ don't need const version of operatorp[] at all as indexed access to
+ const string is provided by implicit conversion to "const wxChar *"
+ below and defining them would only result in ambiguities, but some other
+ compilers refuse to compile "str[0]" without them.
*/
- // operator version of GetChar
- wxChar operator[](int n) const
- { return wxStringBase::operator[](n); }
- wxChar& operator[](size_type n)
- { return wxStringBase::operator[](n); }
+#if defined(__BORLANDC__) || defined(__WATCOMC__) || defined(__MWERKS__)
+ wxChar operator[](int n) const
+ { return wxStringBase::at(n); }
wxChar operator[](size_type n) const
- { return wxStringBase::operator[](n); }
+ { return wxStringBase::at(n); }
#ifndef wxSIZE_T_IS_UINT
- // operator version of GetChar
wxChar operator[](unsigned int n) const
- { return wxStringBase::operator[](n); }
+ { return wxStringBase::at(n); }
+#endif // size_t != unsigned int
+#endif // broken compiler
+
- // operator version of GetWriteableChar
+ // operator versions of GetWriteableChar()
+ wxChar& operator[](int n)
+ { return wxStringBase::at(n); }
+ wxChar& operator[](size_type n)
+ { return wxStringBase::at(n); }
+#ifndef wxSIZE_T_IS_UINT
wxChar& operator[](unsigned int n)
- { return wxStringBase::operator[](n); }
+ { return wxStringBase::at(n); }
#endif // size_t != unsigned int
// implicit conversion to C string
// type differs because a function may either return pointer to the buffer
// directly or have to use intermediate buffer for translation.
#if wxUSE_UNICODE
- const wxCharBuffer mb_str(wxMBConv& conv = wxConvLibc) const
- { return conv.cWC2MB(c_str()); }
+ const wxCharBuffer mb_str(const wxMBConv& conv = wxConvLibc) const;
const wxWX2MBbuf mbc_str() const { return mb_str(*wxConvCurrent); }
const wxChar* wc_str() const { return c_str(); }
// for compatibility with !wxUSE_UNICODE version
- const wxChar* wc_str(wxMBConv& WXUNUSED(conv)) const { return c_str(); }
+ const wxChar* wc_str(const wxMBConv& WXUNUSED(conv)) const { return c_str(); }
#if wxMBFILES
const wxCharBuffer fn_str() const { return mb_str(wxConvFile); }
const wxChar* mb_str() const { return c_str(); }
// for compatibility with wxUSE_UNICODE version
- const wxChar* mb_str(wxMBConv& WXUNUSED(conv)) const { return c_str(); }
+ const wxChar* mb_str(const wxMBConv& WXUNUSED(conv)) const { return c_str(); }
const wxWX2MBbuf mbc_str() const { return mb_str(); }
#if wxUSE_WCHAR_T
- const wxWCharBuffer wc_str(wxMBConv& conv) const
- { return conv.cMB2WC(c_str()); }
+ const wxWCharBuffer wc_str(const wxMBConv& conv) const;
#endif // wxUSE_WCHAR_T
-
+#ifdef __WXOSX__
+ const wxCharBuffer fn_str() const { return wxConvFile.cWC2WX( wc_str( wxConvLocal ) ); }
+#else
const wxChar* fn_str() const { return c_str(); }
+#endif
#endif // Unicode/ANSI
// overloaded assignment
// from a character
wxString& operator=(wxChar ch)
{ return (wxString&)wxStringBase::operator=(ch); }
- // from a C string
+ // from a C string - STL probably will crash on NULL,
+ // so we need to compensate in that case
+#if wxUSE_STL
+ wxString& operator=(const wxChar *psz)
+ { if(psz) wxStringBase::operator=(psz); else Clear(); return *this; }
+#else
wxString& operator=(const wxChar *psz)
{ return (wxString&)wxStringBase::operator=(psz); }
+#endif
+
#if wxUSE_UNICODE
// from wxWCharBuffer
wxString& operator=(const wxWCharBuffer& psz)
// string += C string
wxString& Append(const wxString& s)
{
- // test for IsEmpty() to share the string if possible
- if ( IsEmpty() )
+ // test for empty() to share the string if possible
+ if ( empty() )
*this = s;
else
append(s);
{ *this = str + *this; return *this; }
// non-destructive concatenation
- //
- friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string1, const wxString& string2);
- //
+ // two strings
+ friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string1,
+ const wxString& string2);
+ // string with a single char
friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string, wxChar ch);
- //
+ // char with a string
friend wxString WXDLLIMPEXP_BASE operator+(wxChar ch, const wxString& string);
- //
- friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string, const wxChar *psz);
- //
- friend wxString WXDLLIMPEXP_BASE operator+(const wxChar *psz, const wxString& string);
+ // string with C string
+ friend wxString WXDLLIMPEXP_BASE operator+(const wxString& string,
+ const wxChar *psz);
+ // C string with string
+ friend wxString WXDLLIMPEXP_BASE operator+(const wxChar *psz,
+ const wxString& string);
// stream-like functions
// insert an int into string
// insert an unsigned long into string
wxString& operator<<(unsigned long ul)
{ return (*this) << Format(_T("%lu"), ul); }
+#if defined wxLongLong_t && !defined wxLongLongIsLong
+ // insert a long long if they exist and aren't longs
+ wxString& operator<<(wxLongLong_t ll)
+ {
+ const wxChar *fmt = _T("%") wxLongLongFmtSpec _T("d");
+ return (*this) << Format(fmt, ll);
+ }
+ // insert an unsigned long long
+ wxString& operator<<(wxULongLong_t ull)
+ {
+ const wxChar *fmt = _T("%") wxLongLongFmtSpec _T("u");
+ return (*this) << Format(fmt , ull);
+ }
+#endif
// insert a float into string
wxString& operator<<(float f)
{ return (*this) << Format(_T("%f"), f); }
// string comparison
// case-sensitive comparison (returns a value < 0, = 0 or > 0)
- int Cmp(const wxChar *psz) const { return wxStrcmp(c_str(), psz); }
+ int Cmp(const wxChar *psz) const;
+ int Cmp(const wxString& s) const;
// same as Cmp() but not case-sensitive
- int CmpNoCase(const wxChar *psz) const { return wxStricmp(c_str(), psz); }
+ int CmpNoCase(const wxChar *psz) const;
+ int CmpNoCase(const wxString& s) const;
// test for the string equality, either considering case or not
// (if compareWithCase then the case matters)
- bool IsSameAs(const wxChar *psz, bool compareWithCase = TRUE) const
+ bool IsSameAs(const wxChar *psz, bool compareWithCase = true) const
{ return (compareWithCase ? Cmp(psz) : CmpNoCase(psz)) == 0; }
- // comparison with a signle character: returns TRUE if equal
- bool IsSameAs(wxChar c, bool compareWithCase = TRUE) const
+ // comparison with a single character: returns true if equal
+ bool IsSameAs(wxChar c, bool compareWithCase = true) const
{
return (length() == 1) && (compareWithCase ? GetChar(0u) == c
: wxToupper(GetChar(0u)) == wxToupper(c));
wxString operator()(size_t start, size_t len) const
{ return Mid(start, len); }
- // check that the string starts with prefix and return the rest of the
- // string in the provided pointer if it is not NULL, otherwise return
- // FALSE
+ // check if the string starts with the given prefix and return the rest
+ // of the string in the provided pointer if it is not NULL; otherwise
+ // return false
bool StartsWith(const wxChar *prefix, wxString *rest = NULL) const;
+ // check if the string ends with the given suffix and return the
+ // beginning of the string before the suffix in the provided pointer if
+ // it is not NULL; otherwise return false
+ bool EndsWith(const wxChar *suffix, wxString *rest = NULL) const;
// get first nCount characters
wxString Left(size_t nCount) const;
// trimming/padding whitespace (either side) and truncating
// remove spaces from left or from right (default) side
- wxString& Trim(bool bFromRight = TRUE);
+ wxString& Trim(bool bFromRight = true);
// add nCount copies chPad in the beginning or at the end (default)
- wxString& Pad(size_t nCount, wxChar chPad = wxT(' '), bool bFromRight = TRUE);
+ wxString& Pad(size_t nCount, wxChar chPad = wxT(' '), bool bFromRight = true);
// searching and replacing
// searching (return starting index, or -1 if not found)
- int Find(wxChar ch, bool bFromEnd = FALSE) const; // like strchr/strrchr
+ int Find(wxChar ch, bool bFromEnd = false) const; // like strchr/strrchr
// searching (return starting index, or -1 if not found)
int Find(const wxChar *pszSub) const; // like strstr
// replace first (or all of bReplaceAll) occurences of substring with
// another string, returns the number of replacements made
size_t Replace(const wxChar *szOld,
const wxChar *szNew,
- bool bReplaceAll = TRUE);
+ bool bReplaceAll = true);
// check if the string contents matches a mask containing '*' and '?'
bool Matches(const wxChar *szMask) const;
- // conversion to numbers: all functions return TRUE only if the whole
+ // conversion to numbers: all functions return true only if the whole
// string is a number and put the value of this number into the pointer
// provided, the base is the numeric base in which the conversion should be
// done and must be comprised between 2 and 36 or be 0 in which case the
// convert to a double
bool ToDouble(double *val) const;
- // formated input/output
+ // formatted input/output
// as sprintf(), returns the number of characters written or < 0 on error
// (take 'this' into account in attribute parameter count)
int Printf(const wxChar *pszFormat, ...) ATTRIBUTE_PRINTF_2;
int First( const wxChar ch ) const { return Find(ch); }
int First( const wxChar* psz ) const { return Find(psz); }
int First( const wxString &str ) const { return Find(str); }
- int Last( const wxChar ch ) const { return Find(ch, TRUE); }
- bool Contains(const wxString& str) const { return Find(str) != -1; }
+ int Last( const wxChar ch ) const { return Find(ch, true); }
+ bool Contains(const wxString& str) const { return Find(str) != wxNOT_FOUND; }
- // use IsEmpty()
- bool IsNull() const { return IsEmpty(); }
+ // use empty()
+ bool IsNull() const { return empty(); }
// std::string compatibility functions
{ return (wxString&)wxStringBase::assign(first, last); }
// string comparison
-#ifndef HAVE_STD_STRING_COMPARE
+#if !defined(HAVE_STD_STRING_COMPARE)
int compare(const wxStringBase& str) const;
// comparison with a substring
int compare(size_t nStart, size_t nLen, const wxStringBase& str) const;
{ return (wxString&)wxStringBase::operator+=(ch); }
};
+// notice that even though for many compilers the friend declarations above are
+// enough, from the point of view of C++ standard we must have the declarations
+// here as friend ones are not injected in the enclosing namespace and without
+// them the code fails to compile with conforming compilers such as xlC or g++4
+wxString WXDLLIMPEXP_BASE operator+(const wxString& string1, const wxString& string2);
+wxString WXDLLIMPEXP_BASE operator+(const wxString& string, wxChar ch);
+wxString WXDLLIMPEXP_BASE operator+(wxChar ch, const wxString& string);
+wxString WXDLLIMPEXP_BASE operator+(const wxString& string, const wxChar *psz);
+wxString WXDLLIMPEXP_BASE operator+(const wxChar *psz, const wxString& string);
+
+
// define wxArrayString, for compatibility
#if WXWIN_COMPATIBILITY_2_4 && !wxUSE_STL
#include "wx/arrstr.h"
#endif
+#if wxUSE_STL
+ // return an empty wxString (not very useful with wxUSE_STL == 1)
+ inline const wxString wxGetEmptyString() { return wxString(); }
+#else // !wxUSE_STL
+ // return an empty wxString (more efficient than wxString() here)
+ inline const wxString& wxGetEmptyString()
+ {
+ return *(wxString *)&wxEmptyString;
+ }
+#endif // wxUSE_STL/!wxUSE_STL
+
// ----------------------------------------------------------------------------
// wxStringBuffer: a tiny class allowing to get a writable pointer into string
// ----------------------------------------------------------------------------
public:
wxStringBufferLength(wxString& str, size_t lenWanted = 1024)
: m_str(str), m_buf(NULL), m_len(0), m_lenSet(false)
- { m_buf = m_str.GetWriteBuf(lenWanted); }
+ {
+ m_buf = m_str.GetWriteBuf(lenWanted);
+ wxASSERT(m_buf != NULL);
+ }
~wxStringBufferLength()
{
// wxString comparison functions: operator versions are always case sensitive
// ---------------------------------------------------------------------------
-#if wxUSE_STL
-
-inline bool operator==(const wxString& s1, const wxString& s2)
- { return s1.compare(s2) == 0; }
-inline bool operator==(const wxString& s1, const wxChar * s2)
- { return s1.compare(s2) == 0; }
-inline bool operator==(const wxChar * s1, const wxString& s2)
- { return s2.compare(s1) == 0; }
-inline bool operator!=(const wxString& s1, const wxString& s2)
- { return s1.compare(s2) != 0; }
-inline bool operator!=(const wxString& s1, const wxChar * s2)
- { return s1.compare(s2) != 0; }
-inline bool operator!=(const wxChar * s1, const wxString& s2)
- { return s2.compare(s1) != 0; }
-inline bool operator< (const wxString& s1, const wxString& s2)
- { return s1.compare(s2) < 0; }
-inline bool operator< (const wxString& s1, const wxChar * s2)
- { return s1.compare(s2) < 0; }
-inline bool operator< (const wxChar * s1, const wxString& s2)
- { return s2.compare(s1) > 0; }
-inline bool operator> (const wxString& s1, const wxString& s2)
- { return s1.compare(s2) > 0; }
-inline bool operator> (const wxString& s1, const wxChar * s2)
- { return s1.compare(s2) > 0; }
-inline bool operator> (const wxChar * s1, const wxString& s2)
- { return s2.compare(s1) < 0; }
-inline bool operator<=(const wxString& s1, const wxString& s2)
- { return s1.compare(s2) <= 0; }
-inline bool operator<=(const wxString& s1, const wxChar * s2)
- { return s1.compare(s2) <= 0; }
-inline bool operator<=(const wxChar * s1, const wxString& s2)
- { return s2.compare(s1) >= 0; }
-inline bool operator>=(const wxString& s1, const wxString& s2)
- { return s1.compare(s2) >= 0; }
-inline bool operator>=(const wxString& s1, const wxChar * s2)
- { return s1.compare(s2) >= 0; }
-inline bool operator>=(const wxChar * s1, const wxString& s2)
- { return s2.compare(s1) <= 0; }
-
-#else // if !wxUSE_STL
+// note that when wxUSE_STL == 1 the comparison operators taking std::string
+// are used and defining them also for wxString would only result in
+// compilation ambiguities when comparing std::string and wxString
+#if !wxUSE_STL
inline bool operator==(const wxString& s1, const wxString& s2)
{ return (s1.Len() == s2.Len()) && (s1.Cmp(s2) == 0); }
inline bool operator>=(const wxChar * s1, const wxString& s2)
{ return s2.Cmp(s1) <= 0; }
-#endif // !wxUSE_STL
-
-// comparison with char
-inline bool operator==(wxChar c, const wxString& s) { return s.IsSameAs(c); }
-inline bool operator==(const wxString& s, wxChar c) { return s.IsSameAs(c); }
-inline bool operator!=(wxChar c, const wxString& s) { return !s.IsSameAs(c); }
-inline bool operator!=(const wxString& s, wxChar c) { return !s.IsSameAs(c); }
-
#if wxUSE_UNICODE
inline bool operator==(const wxString& s1, const wxWCharBuffer& s2)
{ return (s1.Cmp((const wchar_t *)s2) == 0); }
{ return (s2.Cmp((const char *)s1) != 0); }
#endif // wxUSE_UNICODE/!wxUSE_UNICODE
-#if !wxUSE_STL
-
-wxString WXDLLIMPEXP_BASE operator+(const wxString& string1, const wxString& string2);
-wxString WXDLLIMPEXP_BASE operator+(const wxString& string, wxChar ch);
-wxString WXDLLIMPEXP_BASE operator+(wxChar ch, const wxString& string);
-wxString WXDLLIMPEXP_BASE operator+(const wxString& string, const wxChar *psz);
-wxString WXDLLIMPEXP_BASE operator+(const wxChar *psz, const wxString& string);
-
-#endif // !wxUSE_STL
-
#if wxUSE_UNICODE
inline wxString operator+(const wxString& string, const wxWCharBuffer& buf)
{ return string + (const wchar_t *)buf; }
{ return (const char *)buf + string; }
#endif // wxUSE_UNICODE/!wxUSE_UNICODE
+#endif // !wxUSE_STL
+
+// comparison with char (those are not defined by std::[w]string and so should
+// be always available)
+inline bool operator==(wxChar c, const wxString& s) { return s.IsSameAs(c); }
+inline bool operator==(const wxString& s, wxChar c) { return s.IsSameAs(c); }
+inline bool operator!=(wxChar c, const wxString& s) { return !s.IsSameAs(c); }
+inline bool operator!=(const wxString& s, wxChar c) { return !s.IsSameAs(c); }
+
// ---------------------------------------------------------------------------
// Implementation only from here until the end of file
// ---------------------------------------------------------------------------
#include "wx/iosfwrap.h"
-WXDLLIMPEXP_BASE wxSTD istream& operator>>(wxSTD istream&, wxString&);
WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxString&);
#endif // wxSTD_STRING_COMPATIBILITY
projects / wxWidgets.git / blobdiff