X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/655719367ac5e131d9642e5783f3ecf64d1a3385..2a32f1733dd39882d58627d5cb22dbdeb54eb693:/include/wx/string.h diff --git a/include/wx/string.h b/include/wx/string.h index 6667f8fae8..f55ac3032b 100644 --- a/include/wx/string.h +++ b/include/wx/string.h @@ -18,10 +18,6 @@ #ifndef _WX_WXSTRINGH__ #define _WX_WXSTRINGH__ -#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) - #pragma interface "string.h" -#endif - // ---------------------------------------------------------------------------- // headers // ---------------------------------------------------------------------------- @@ -51,10 +47,16 @@ #include // for strcasecmp() #endif // HAVE_STRCASECMP_IN_STRINGS_H +#ifdef __WXPALMOS__ + #include +#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 // --------------------------------------------------------------------------- @@ -74,16 +76,8 @@ // 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 @@ -134,7 +128,8 @@ inline int Stricmp(const char *psz1, const char *psz2) 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); @@ -164,11 +159,12 @@ inline int Stricmp(const char *psz1, const char *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 @@ -176,22 +172,32 @@ inline const wxString& wxGetEmptyString() { return *(wxString *)&wxEmptyString; #if wxUSE_UNICODE #ifdef HAVE_STD_WSTRING - typedef std::wstring wxStringBase; + typedef std::wstring wxStdString; #else - typedef std::basic_string wxStringBase; + typedef std::basic_string 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 + +#if wxUSE_STL + + // we don't need an extra ctor from std::string when copy ctor already does + // the work + #undef wxUSE_STD_STRING + #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 @@ -376,12 +382,9 @@ public: // 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] @@ -429,9 +432,9 @@ public: const_iterator end() const { return m_pchData + length(); } // first valid index position - iterator begin() { CopyBeforeWrite(); return m_pchData; } + iterator begin(); // position one after the last valid one - iterator end() { CopyBeforeWrite(); return m_pchData + length(); } + iterator end(); // insert another string wxStringBase& insert(size_t nPos, const wxStringBase& str) @@ -510,11 +513,8 @@ public: // 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; @@ -524,7 +524,6 @@ public: // 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; @@ -574,17 +573,15 @@ public: // 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; @@ -604,27 +601,9 @@ public: #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 @@ -673,10 +652,19 @@ public: wxString(const wxChar *psz, wxMBConv& WXUNUSED(conv), size_t nLength = npos) : wxStringBase(psz, nLength == npos ? wxStrlen(psz) : nLength) { } + // even we're not build 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); // from wxWCharBuffer (i.e. return from wxGetString) wxString(const wxWCharBuffer& psz) : wxStringBase(psz.data()) { } @@ -692,7 +680,7 @@ public: // from wxCharBuffer wxString(const wxCharBuffer& psz) - : wxStringBase(psz, npos) { } + : wxStringBase(psz) { } #endif // Unicode/ANSI // generic attributes & operations @@ -700,7 +688,7 @@ public: size_t Len() const { return length(); } // string contains any characters? bool IsEmpty() const { return empty(); } - // empty string is "FALSE", so !str will return TRUE + // empty string is "false", so !str will return true bool operator!() const { return IsEmpty(); } // truncate the string to given length wxString& Truncate(size_t uiLen); @@ -709,7 +697,7 @@ public: { 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() @@ -729,66 +717,58 @@ public: // 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 @@ -825,8 +805,7 @@ public: // 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(wxMBConv& conv = wxConvLibc) const; const wxWX2MBbuf mbc_str() const { return mb_str(*wxConvCurrent); } @@ -849,11 +828,13 @@ public: 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(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 @@ -863,9 +844,16 @@ public: // 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) @@ -922,8 +910,8 @@ public: // 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); @@ -975,15 +963,17 @@ public: // 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 signle 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)); @@ -1000,7 +990,7 @@ public: // 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 + // false bool StartsWith(const wxChar *prefix, wxString *rest = NULL) const; // get first nCount characters @@ -1037,25 +1027,25 @@ public: // 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 @@ -1138,11 +1128,11 @@ public: 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 @@ -1195,7 +1185,7 @@ public: { 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; @@ -1289,6 +1279,17 @@ public: #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 // ---------------------------------------------------------------------------- @@ -1371,7 +1372,10 @@ class WXDLLIMPEXP_BASE wxStringBufferLength 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() { @@ -1397,46 +1401,10 @@ private: // 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); } @@ -1475,14 +1443,6 @@ inline bool operator>=(const wxString& s1, const wxChar * s2) 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); } @@ -1503,16 +1463,12 @@ inline bool operator!=(const wxCharBuffer& s1, const wxString& s2) { 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; } @@ -1525,6 +1481,15 @@ inline wxString operator+(const wxCharBuffer& buf, const wxString& string) { 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 // ---------------------------------------------------------------------------