#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 __PALMOS__
+#ifdef __WXPALMOS__
#include <StringMgr.h>
#endif
// 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 subtract 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
}
-#if wxUSE_STL
+// ----------------------------------------------------------------------------
+// deal with STL/non-STL/non-STL-but-wxUSE_STD_STRING
+// ----------------------------------------------------------------------------
+
+// in both cases we need to define wxStdString
+#if wxUSE_STL || defined(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
+
+ #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
// 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]
#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
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
+#ifdef wxUSE_STD_STRING
+ wxString(const wxStdString& s)
+ : wxStringBase(s.c_str()) { }
+#endif // wxUSE_STD_STRING
+
#if wxUSE_UNICODE
// from multibyte string
wxString(const char *psz, wxMBConv& conv, size_t nLength = npos);
// 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") );
- 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);
+ 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
#if wxUSE_WCHAR_T
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
// the same as above, but takes a va_list
static wxString FormatV(const wxChar *pszFormat, va_list argptr);
- // returns the highest possible memory allocation for encoding
- static size_t WorstEncodingCase(size_t len, wxMBConv& conv);
-
// raw access to string memory
// ensure that string has space for at least nLen characters
// only works if the data of this string is not shared
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);
}
// 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
// ---------------------------------------------------------------------------
projects / wxWidgets.git / blobdiff