// 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, ...);
#if wxUSE_UNICODE_UTF8
// see the comment near wxString::iterator for why we need this
-struct WXDLLIMPEXP_BASE wxStringIteratorNode
+class WXDLLIMPEXP_BASE wxStringIteratorNode
{
+public:
wxStringIteratorNode()
: m_str(NULL), m_citer(NULL), m_iter(NULL), m_prev(NULL), m_next(NULL) {}
wxStringIteratorNode(const wxString *str,
wxString(const wxString& stringSrc) : m_impl(stringSrc.m_impl) { }
// string containing nRepeat copies of ch
- wxString(wxUniChar ch, size_t nRepeat = 1)
+ wxString(wxUniChar ch, size_t nRepeat = 1 )
{ assign(nRepeat, ch); }
wxString(size_t nRepeat, wxUniChar ch)
{ assign(nRepeat, ch); }
void resize(size_t nSize, wxUniChar ch = wxT('\0'))
{
+ const size_t len = length();
+ if ( nSize == len)
+ return;
+
#if wxUSE_UNICODE_UTF8
- if ( !ch.IsAscii() )
+ if ( nSize < len )
{
- size_t len = length();
- if ( nSize == len)
- return;
- else if ( nSize < len )
- erase(nSize);
- else
- append(nSize - len, ch);
+ // we can't use wxStringImpl::resize() for truncating the string as it
+ // counts in bytes, not characters
+ erase(nSize);
+ return;
}
+
+ // we also can't use (presumably more efficient) resize() if we have to
+ // append characters taking more than one byte
+ if ( !ch.IsAscii() )
+ append(nSize - len, ch);
else
-#endif
+#endif // wxUSE_UNICODE_UTF8
m_impl.resize(nSize, (wxStringCharType)ch);
}
// 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)
#if wxUSE_WCHAR_T
const wxWCharBuffer wc_str(const wxMBConv& conv = wxConvLibc) 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
+ const wxCharBuffer fn_str() const { return wxConvFile.cWC2WX( wc_str( wxConvLibc ) ); }
#endif // Unicode/ANSI
// overloaded assignment
private:
wxStringImpl m_impl;
-#ifdef __VISUALC__
- // "struct 'ConvertedBuffer<T>' needs to have dll-interface to be used by
- // clients of class 'wxString'" - this is private, we don't care
- #pragma warning (disable:4251)
-#endif
-
// buffers for compatibility conversion from (char*)c_str() and
// (wchar_t*)c_str():
// FIXME-UTF8: bechmark various approaches to keeping compatibility buffers
ConvertedBuffer<wchar_t> m_convertedToWChar;
#endif
-#ifdef __VISUALC__
- #pragma warning (default:4251)
-#endif
-
#if wxUSE_UNICODE_UTF8
// FIXME-UTF8: (try to) move this elsewhere (TLS) or solve differently
// assigning to character pointer to by wxString::interator may
#endif // wxUSE_UNICODE_UTF8
friend class WXDLLIMPEXP_FWD_BASE wxCStrData;
- friend class wxImplStringBuffer;
- friend class wxImplStringBufferLength;
+ 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
template<typename T>
-class wxStringTypeBufferBase
+class WXDLLIMPEXP_BASE wxStringTypeBufferBase
{
public:
typedef T CharType;
};
template<typename T>
-class wxStringTypeBufferLengthBase
+class WXDLLIMPEXP_BASE wxStringTypeBufferLengthBase
{
public:
typedef T CharType;
: 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>
+
+WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( 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>
+WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE(
+ 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
+typedef wxStringInternalBuffer wxUTF8StringBuffer;
+typedef wxStringInternalBufferLength wxUTF8StringBufferLength;
+#elif wxUSE_UNICODE_WCHAR
+
+WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxStringTypeBufferBase<char> )
+
+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)
+};
+
+WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxStringTypeBufferLengthBase<char> )
+
+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_UNICODE_WCHAR
+
+
// ---------------------------------------------------------------------------
// wxString comparison functions: operator versions are always case sensitive
// ---------------------------------------------------------------------------
WXDLLIMPEXP_BASE wxSTD ostream& operator<<(wxSTD ostream&, const wxWCharBuffer&);
#endif
-#endif // wxSTD_STRING_COMPATIBILITY
+#if wxUSE_UNICODE && defined(HAVE_WOSTREAM)
+
+WXDLLIMPEXP_BASE wxSTD wostream& operator<<(wxSTD wostream&, const wxString&);
+WXDLLIMPEXP_BASE wxSTD wostream& operator<<(wxSTD wostream&, const wxCStrData&);
+WXDLLIMPEXP_BASE wxSTD wostream& operator<<(wxSTD wostream&, const wxWCharBuffer&);
+
+#endif // wxUSE_UNICODE && defined(HAVE_WOSTREAM)
+
+#endif // wxUSE_STD_IOSTREAM
// ---------------------------------------------------------------------------
// wxCStrData implementation
projects / wxWidgets.git / blobdiff