#include <StringMgr.h>
#endif
-#include "wx/wxcrt.h" // for wxChar, wxStrlen() etc.
+#include "wx/wxcrtbase.h" // for wxChar, wxStrlen() etc.
#include "wx/strvararg.h"
#include "wx/buffer.h" // for wxCharBuffer
#include "wx/strconv.h" // for wxConvertXXX() macros and wxMBConv classes
wxStringImpl::const_iterator *m_citer;
wxStringImpl::iterator *m_iter;
wxStringIteratorNode *m_prev, *m_next;
+
+ // the node belongs to a particular iterator instance, it's not copied
+ // when a copy of the iterator is made
+ DECLARE_NO_COPY_CLASS(wxStringIteratorNode)
};
#endif // wxUSE_UNICODE_UTF8
private: \
underlying_iterator m_cur
- class const_iterator;
+ class WXDLLIMPEXP_BASE const_iterator;
#if wxUSE_UNICODE_UTF8
// NB: In UTF-8 build, (non-const) iterator needs to keep reference
// string and traversing it in wxUniCharRef::operator=(). Head of the
// list is stored in wxString. (FIXME-UTF8)
- class iterator
+ class WXDLLIMPEXP_BASE iterator
{
WX_STR_ITERATOR_IMPL(iterator, wxChar*, wxUniCharRef);
public:
iterator(const iterator& i)
: m_cur(i.m_cur), m_node(i.str(), &m_cur) {}
+ iterator& operator=(const iterator& i)
+ { m_cur = i.m_cur; return *this; }
reference operator*()
{ return wxUniCharRef::CreateForString(m_node, m_cur); }
private:
iterator(wxString *str, underlying_iterator ptr)
: m_cur(ptr), m_node(str, &m_cur) {}
- iterator(wxString& str, underlying_iterator ptr)
- : m_cur(ptr), m_node(&str, &m_cur) {}
wxString* str() const { return wx_const_cast(wxString*, m_node.m_str); }
friend class const_iterator;
};
- class const_iterator
+ class WXDLLIMPEXP_BASE const_iterator
{
// NB: reference_type is intentionally value, not reference, the character
// may be encoded differently in wxString data:
const_iterator(const iterator& i)
: m_cur(i.m_cur), m_node(i.str(), &m_cur) {}
+ const_iterator& operator=(const const_iterator& i)
+ { m_cur = i.m_cur; return *this; }
+ const_iterator& operator=(const iterator& i)
+ { m_cur = i.m_cur; return *this; }
+
reference operator*() const
{ return wxStringOperations::DecodeChar(m_cur); }
// for internal wxString use only:
const_iterator(const wxString *str, underlying_iterator ptr)
: m_cur(ptr), m_node(str, &m_cur) {}
- const_iterator(const wxString& str, underlying_iterator ptr)
- : m_cur(ptr), m_node(&str, &m_cur) {}
const wxString* str() const { return m_node.m_str; }
#else // !wxUSE_UNICODE_UTF8
- class iterator
+ class WXDLLIMPEXP_BASE iterator
{
WX_STR_ITERATOR_IMPL(iterator, wxChar*, wxUniCharRef);
friend class const_iterator;
};
- class const_iterator
+ class WXDLLIMPEXP_BASE const_iterator
{
// NB: reference_type is intentionally value, not reference, the character
// may be encoded differently in wxString data:
wxString(const std::string& str)
{ assign(str.c_str(), str.length()); }
#endif
+#endif // wxUSE_STD_STRING
+ // Unlike ctor from std::string, we provide conversion to std::string only
+ // if wxUSE_STL and not merely wxUSE_STD_STRING (which is on by default),
+ // because it conflicts with operator const char/wchar_t*:
+#if wxUSE_STL
#if wxUSE_UNICODE_WCHAR && wxUSE_STL_BASED_WXSTRING
// wxStringImpl is std::string in the encoding we want
operator const wxStdWideString&() const { return m_impl; }
// 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:
+#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
#if wxUSE_UNICODE_UTF8
static wxString FromUTF8(const char *utf8)
{
+ if ( !utf8 )
+ return wxEmptyString;
+
wxASSERT( wxStringOperations::IsValidUtf8String(utf8) );
return FromImpl(wxStringImpl(utf8));
}
static wxString FromUTF8(const char *utf8, size_t len)
{
+ if ( !utf8 )
+ return wxEmptyString;
+ if ( len == npos )
+ return FromUTF8(utf8);
+
wxASSERT( wxStringOperations::IsValidUtf8String(utf8, len) );
return FromImpl(wxStringImpl(utf8, len));
}
bool IsSameAs(const wxWCharBuffer& str, bool compareWithCase = true) const
{ return IsSameAs(str.data(), compareWithCase); }
// comparison with a single character: returns true if equal
- bool IsSameAs(wxUniChar c, bool compareWithCase = true) const
- {
- return (length() == 1) && (compareWithCase ? GetChar(0u) == c
- : wxToupper(GetChar(0u)) == wxToupper(c));
- }
+ bool IsSameAs(wxUniChar c, bool compareWithCase = true) const;
// FIXME-UTF8: remove these overloads
bool IsSameAs(wxUniCharRef c, bool compareWithCase = true) const
{ return IsSameAs(wxUniChar(c), compareWithCase); }
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
{
wxStringIteratorNodeHead() : ptr(NULL) {}
wxStringIteratorNode *ptr;
+
+ // copying is disallowed as it would result in more than one pointer into
+ // the same linked list
+ DECLARE_NO_COPY_CLASS(wxStringIteratorNodeHead)
};
wxStringIteratorNodeHead m_iterators;
inline bool operator>=(const wxString& s1, const wxString& s2)
{ return s1.Cmp(s2) >= 0; }
-#if wxUSE_UNICODE
+inline bool operator==(const wxString& s1, const wxCStrData& s2)
+ { return s1 == s2.AsString(); }
+inline bool operator==(const wxCStrData& s1, const wxString& s2)
+ { return s1.AsString() == s2; }
+inline bool operator!=(const wxString& s1, const wxCStrData& s2)
+ { return s1 != s2.AsString(); }
+inline bool operator!=(const wxCStrData& s1, const wxString& s2)
+ { return s1.AsString() != s2; }
+
inline bool operator==(const wxString& s1, const wxWCharBuffer& s2)
{ return (s1.Cmp((const wchar_t *)s2) == 0); }
inline bool operator==(const wxWCharBuffer& s1, const wxString& s2)
{ return (s1.Cmp((const wchar_t *)s2) != 0); }
inline bool operator!=(const wxWCharBuffer& s1, const wxString& s2)
{ return (s2.Cmp((const wchar_t *)s1) != 0); }
-#else // !wxUSE_UNICODE
+
inline bool operator==(const wxString& s1, const wxCharBuffer& s2)
{ return (s1.Cmp((const char *)s2) == 0); }
inline bool operator==(const wxCharBuffer& s1, const wxString& s2)
{ return (s1.Cmp((const char *)s2) != 0); }
inline bool operator!=(const wxCharBuffer& s1, const wxString& s2)
{ return (s2.Cmp((const char *)s1) != 0); }
-#endif // wxUSE_UNICODE/!wxUSE_UNICODE
-#if wxUSE_UNICODE
inline wxString operator+(const wxString& string, const wxWCharBuffer& buf)
{ return string + (const wchar_t *)buf; }
inline wxString operator+(const wxWCharBuffer& buf, const wxString& string)
{ return (const wchar_t *)buf + string; }
-#else // !wxUSE_UNICODE
+
inline wxString operator+(const wxString& string, const wxCharBuffer& buf)
{ return string + (const char *)buf; }
inline wxString operator+(const wxCharBuffer& buf, const wxString& string)
{ return (const char *)buf + string; }
-#endif // wxUSE_UNICODE/!wxUSE_UNICODE
// comparison with char
inline bool operator==(const wxUniChar& c, const wxString& s) { return s.IsSameAs(c); }
#endif // wxUSE_UNICODE_UTF8
#if WXWIN_COMPATIBILITY_2_8
- // lot of code out there doesn't explicitly include wx/wxchar.h, but uses
+ // lot of code out there doesn't explicitly include wx/crt.h, but uses
// CRT wrappers that are now declared in wx/wxcrt.h and wx/wxcrtvararg.h,
// so let's include this header now that wxString is defined and it's safe
// to do it:
- #include "wx/wxchar.h"
+ #include "wx/crt.h"
#endif
#endif // _WX_WXSTRING_H_