#include "wx/stringops.h"
#include "wx/unichar.h"
-class WXDLLIMPEXP_BASE wxString;
+class WXDLLIMPEXP_FWD_BASE wxString;
// unless this symbol is predefined to disable the compatibility functions, do
// use them
size_t m_offset;
bool m_owned;
- friend class WXDLLIMPEXP_BASE wxString;
+ friend class WXDLLIMPEXP_FWD_BASE wxString;
};
// ----------------------------------------------------------------------------
// We have to implement the version without template arguments manually
// because of the StringReturnType<> hack, although WX_DEFINE_VARARG_FUNC
// normally does it itself. It has to be a template so that we can use
- // the hack, even though there's no real template parameter:
- struct FormatDummyArg {} ;
-
+ // the hack, even though there's no real template parameter. We can't move
+ // it to wxStrig, because it would shadow these versions of Format() then.
template<typename T>
inline static typename StringReturnType<T>::type
- Format(const wxFormatString& fmt, FormatDummyArg dummy = FormatDummyArg())
+ Format(const T& fmt)
{
- return DoFormatWchar(fmt);
+ // NB: this doesn't compile if T is not (some form of) a string;
+ // this makes Format's prototype equivalent to
+ // Format(const wxFormatString& fmt)
+ return DoFormatWchar(wxFormatString(fmt));
}
// int Printf(const wxString& format, ...);
/* for internal wxString use only: */ \
underlying_iterator impl() const { return m_cur; } \
\
- friend class WXDLLIMPEXP_BASE wxString; \
- friend class WXDLLIMPEXP_BASE wxCStrData; \
+ friend class wxString; \
+ friend class wxCStrData; \
\
private: \
underlying_iterator m_cur
- class WXDLLIMPEXP_BASE const_iterator;
+ class WXDLLIMPEXP_FWD_BASE const_iterator;
#if wxUSE_UNICODE_UTF8
// NB: In UTF-8 build, (non-const) iterator needs to keep reference
// implicit conversion to C string
operator wxCStrData() const { return c_str(); }
- // these operators conflict with operators for conversion to std::string,
- // so they must be disabled in STL build:
+ // the first two operators conflict with operators for conversion to
+ // std::string and they must be disabled in STL build; the next one only
+ // makes sense if conversions to char* are also defined and not defining it
+ // in STL build also helps us to get more clear error messages for the code
+ // which relies on implicit conversion to char* in STL build
#if !wxUSE_STL
operator const char*() const { return c_str(); }
operator const wchar_t*() const { return c_str(); }
-#endif
// implicit conversion to untyped pointer for compatibility with previous
// wxWidgets versions: this is the same as conversion to const char * so it
// may fail!
operator const void*() const { return c_str(); }
+#endif // wxUSE_STL
// identical to c_str(), for MFC compatibility
const wxCStrData GetData() const { return c_str(); }
// the behaviour of these functions with the strings containing anything
// else than 7 bit ASCII characters is undefined, use at your own risk.
#if wxUSE_UNICODE
- static wxString FromAscii(const char *ascii, size_t len); // string
- static wxString FromAscii(const char *ascii); // string
- static wxString FromAscii(const char ascii); // char
+ static wxString FromAscii(const char *ascii, size_t len);
+ static wxString FromAscii(const char *ascii);
+ static wxString FromAscii(char ascii);
const wxCharBuffer ToAscii() const;
#else // ANSI
static wxString FromAscii(const char *ascii) { return wxString( ascii ); }
static wxString FromAscii(const char *ascii, size_t len)
{ return wxString( ascii, len ); }
- static wxString FromAscii(const char ascii) { return wxString( ascii ); }
+ static wxString FromAscii(char ascii) { return wxString( ascii ); }
const char *ToAscii() const { return c_str(); }
#endif // Unicode/!Unicode
+ // also provide unsigned char overloads as signed/unsigned doesn't matter
+ // for 7 bit ASCII characters
+ static wxString FromAscii(const unsigned char *ascii)
+ { return FromAscii((const char *)ascii); }
+ static wxString FromAscii(const unsigned char *ascii, size_t len)
+ { return FromAscii((const char *)ascii, len); }
+
// conversion to/from UTF-8:
#if wxUSE_UNICODE_UTF8
static wxString FromUTF8(const char *utf8)
wxStringIteratorNodeHead m_iterators;
- friend class WXDLLIMPEXP_BASE wxStringIteratorNode;
- friend class WXDLLIMPEXP_BASE wxUniCharRef;
+ friend class WXDLLIMPEXP_FWD_BASE wxStringIteratorNode;
+ friend class WXDLLIMPEXP_FWD_BASE wxUniCharRef;
#endif // wxUSE_UNICODE_UTF8
- friend class WXDLLIMPEXP_BASE wxCStrData;
- friend class wxImplStringBuffer;
- friend class wxImplStringBufferLength;
+ friend class WXDLLIMPEXP_FWD_BASE wxCStrData;
+ friend class wxStringInternalBuffer;
+ friend class wxStringInternalBufferLength;
};
#ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
{ return wxUniChar(ch) + string; }
-#if wxUSE_STL_BASED_WXSTRING
- // return an empty wxString (not very useful with wxUSE_STL == 1)
- inline const wxString wxGetEmptyString() { return wxString(); }
-#else // !wxUSE_STL_BASED_WXSTRING
- // return an empty wxString (more efficient than wxString() here)
- inline const wxString& wxGetEmptyString()
- {
- return *(wxString *)&wxEmptyString;
- }
-#endif // wxUSE_STL_BASED_WXSTRING/!wxUSE_STL_BASED_WXSTRING
+#define wxGetEmptyString() wxString()
// ----------------------------------------------------------------------------
// wxStringBuffer: a tiny class allowing to get a writable pointer into string
#if !wxUSE_STL_BASED_WXSTRING
// string buffer for direct access to string data in their native
// representation:
-class wxImplStringBuffer
+class wxStringInternalBuffer
{
public:
typedef wxStringCharType CharType;
- wxImplStringBuffer(wxString& str, size_t lenWanted = 1024)
+ wxStringInternalBuffer(wxString& str, size_t lenWanted = 1024)
: m_str(str), m_buf(NULL)
{ m_buf = m_str.DoGetWriteBuf(lenWanted); }
- ~wxImplStringBuffer() { m_str.DoUngetWriteBuf(); }
+ ~wxStringInternalBuffer() { m_str.DoUngetWriteBuf(); }
operator wxStringCharType*() const { return m_buf; }
wxString& m_str;
wxStringCharType *m_buf;
- DECLARE_NO_COPY_CLASS(wxImplStringBuffer)
+ DECLARE_NO_COPY_CLASS(wxStringInternalBuffer)
};
-class wxImplStringBufferLength
+class wxStringInternalBufferLength
{
public:
typedef wxStringCharType CharType;
- wxImplStringBufferLength(wxString& str, size_t lenWanted = 1024)
+ wxStringInternalBufferLength(wxString& str, size_t lenWanted = 1024)
: m_str(str), m_buf(NULL), m_len(0), m_lenSet(false)
{
m_buf = m_str.DoGetWriteBuf(lenWanted);
wxASSERT(m_buf != NULL);
}
- ~wxImplStringBufferLength()
+ ~wxStringInternalBufferLength()
{
wxASSERT(m_lenSet);
m_str.DoUngetWriteBuf(m_len);
size_t m_len;
bool m_lenSet;
- DECLARE_NO_COPY_CLASS(wxImplStringBufferLength)
+ DECLARE_NO_COPY_CLASS(wxStringInternalBufferLength)
};
#endif // !wxUSE_STL_BASED_WXSTRING
: m_str(str), m_buf(lenWanted), m_len(0), m_lenSet(false)
{ }
- ~wxStringTypeBufferLengthBase()
- {
- wxASSERT(m_lenSet);
- m_str.assign(m_buf.data(), m_len);
- }
-
operator CharType*() { return m_buf.data(); }
void SetLength(size_t length) { m_len = length; m_lenSet = true; }
};
#if wxUSE_STL_BASED_WXSTRING
-class wxImplStringBuffer : public wxStringTypeBufferBase<wxStringCharType>
+class wxStringInternalBuffer : public wxStringTypeBufferBase<wxStringCharType>
{
public:
- wxImplStringBuffer(wxString& str, size_t lenWanted = 1024)
+ wxStringInternalBuffer(wxString& str, size_t lenWanted = 1024)
: wxStringTypeBufferBase<wxStringCharType>(str, lenWanted) {}
- ~wxImplStringBuffer()
+ ~wxStringInternalBuffer()
{ m_str.m_impl.assign(m_buf.data()); }
- DECLARE_NO_COPY_CLASS(wxImplStringBuffer)
+ DECLARE_NO_COPY_CLASS(wxStringInternalBuffer)
};
-class wxImplStringBufferLength : public wxStringTypeBufferLengthBase<wxStringCharType>
+class wxStringInternalBufferLength : public wxStringTypeBufferLengthBase<wxStringCharType>
{
public:
- wxImplStringBufferLength(wxString& str, size_t lenWanted = 1024)
+ wxStringInternalBufferLength(wxString& str, size_t lenWanted = 1024)
: wxStringTypeBufferLengthBase<wxStringCharType>(str, lenWanted) {}
- ~wxImplStringBufferLength()
+ ~wxStringInternalBufferLength()
{
wxASSERT(m_lenSet);
m_str.m_impl.assign(m_buf.data(), m_len);
}
- DECLARE_NO_COPY_CLASS(wxImplStringBufferLength)
+ DECLARE_NO_COPY_CLASS(wxStringInternalBufferLength)
};
#endif // wxUSE_STL_BASED_WXSTRING
typedef wxStringTypeBuffer<wxChar> wxStringBuffer;
typedef wxStringTypeBufferLength<wxChar> wxStringBufferLength;
#else // if !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
-typedef wxImplStringBuffer wxStringBuffer;
-typedef wxImplStringBufferLength wxStringBufferLength;
+typedef wxStringInternalBuffer wxStringBuffer;
+typedef wxStringInternalBufferLength wxStringBufferLength;
#endif // !wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
+#if wxUSE_UNICODE_UTF8 && !wxUSE_STL_BASED_WXSTRING
+typedef wxStringInternalBuffer wxUTF8StringBuffer;
+typedef wxStringInternalBufferLength wxUTF8StringBufferLength;
+#elif wxUSE_UNICODE // !wxUSE_UNICODE_UTF8 || wxUSE_STL_BASED_WXSTRING
+class WXDLLIMPEXP_BASE wxUTF8StringBuffer : public wxStringTypeBufferBase<char>
+{
+public:
+ wxUTF8StringBuffer(wxString& str, size_t lenWanted = 1024)
+ : wxStringTypeBufferBase<char>(str, lenWanted) {}
+ ~wxUTF8StringBuffer();
+
+ DECLARE_NO_COPY_CLASS(wxUTF8StringBuffer)
+};
+
+class WXDLLIMPEXP_BASE wxUTF8StringBufferLength
+ : public wxStringTypeBufferLengthBase<char>
+{
+public:
+ wxUTF8StringBufferLength(wxString& str, size_t lenWanted = 1024)
+ : wxStringTypeBufferLengthBase<char>(str, lenWanted) {}
+ ~wxUTF8StringBufferLength();
+
+ DECLARE_NO_COPY_CLASS(wxUTF8StringBufferLength)
+};
+#endif // wxUSE_UNICODE_UTF8 && !wxUSE_STL_BASED_WXSTRING or not
+
+
// ---------------------------------------------------------------------------
// wxString comparison functions: operator versions are always case sensitive
// ---------------------------------------------------------------------------
inline wxCStrData::~wxCStrData()
{
if ( m_owned )
- delete m_str;
+ delete wx_const_cast(wxString*, m_str); // cast to silence warnings
}
// simple cases for AsChar() and AsWChar(), the complicated ones are
wxStringImpl::const_iterator *citer,
wxStringImpl::iterator *iter)
{
- m_next = m_prev = NULL;
+ m_prev = NULL;
m_iter = iter;
m_citer = citer;
m_str = str;
if ( m_next )
m_next->m_prev = this;
}
+ else
+ {
+ m_next = NULL;
+ }
}
void wxStringIteratorNode::clear()
projects / wxWidgets.git / blobdiff