#include "wx/buffer.h" // for wxCharBuffer
#include "wx/strconv.h" // for wxConvertXXX() macros and wxMBConv classes
#include "wx/stringimpl.h"
+#include "wx/stringops.h"
#include "wx/unichar.h"
class WXDLLIMPEXP_BASE wxString;
// buffer for holding temporary substring when using any of the methods
// that take (char*,size_t) or (wchar_t*,size_t) arguments:
- // FIXME-UTF8: This will need changes when UTF8 build is introduced
template<typename T>
struct SubstrBufFromType
{
{ return ConvertStr(str, n, wxConvLibc); }
#endif
- // moves the iterator to the next Unicode character
- static void IncIter(wxStringImpl::iterator& i) { ++i; }
- static void IncIter(wxStringImpl::const_iterator& i) { ++i; }
- // moves the iterator to the previous Unicode character
- static void DecIter(wxStringImpl::iterator& i) { --i; }
- static void DecIter(wxStringImpl::const_iterator& i) { --i; }
- // moves the iterator by n Unicode characters
- static wxStringImpl::iterator AddToIter(wxStringImpl::iterator i, int n)
- { return i + n; }
- static wxStringImpl::const_iterator AddToIter(wxStringImpl::const_iterator i, int n)
- { return i + n; }
- // returns distance of the two iterators in Unicode characters
- static int DiffIters(wxStringImpl::iterator i1, wxStringImpl::iterator i2)
- { return i1 - i2; }
- static int DiffIters(wxStringImpl::const_iterator i1, wxStringImpl::const_iterator i2)
- { return i1 - i2; }
-
- // encodes the character to a form used to represent it in internal
- // representation (returns a string in UTF8 version)
- static wxChar EncodeChar(wxUniChar ch) { return (wxChar)ch; }
- static wxUniChar DecodeChar(wxStringImpl::const_iterator i) { return *i; }
-
// translates position index in wxString to/from index in underlying
// wxStringImpl:
static size_t PosToImpl(size_t pos) { return pos; }
#else // wxUSE_UNICODE_UTF8
- // checks correctness of UTF-8 sequence
- static bool IsValidUtf8String(const char *c);
-#ifdef __WXDEBUG__
- static bool IsValidUtf8LeadByte(unsigned char c);
-#endif
-
- // table of offsets to skip forward when iterating
- static unsigned char ms_utf8IterTable[256];
-
- static void IncIter(wxStringImpl::iterator& i)
- {
- wxASSERT( IsValidUtf8LeadByte(*i) );
- i += ms_utf8IterTable[(unsigned char)*i];
- }
- static void IncIter(wxStringImpl::const_iterator& i)
- {
- wxASSERT( IsValidUtf8LeadByte(*i) );
- i += ms_utf8IterTable[(unsigned char)*i];
- }
-
- static void DecIter(wxStringImpl::iterator& i);
- static void DecIter(wxStringImpl::const_iterator& i);
- static wxStringImpl::iterator AddToIter(wxStringImpl::iterator i, int n);
- static wxStringImpl::const_iterator AddToIter(wxStringImpl::const_iterator i, int n);
- static int DiffIters(wxStringImpl::const_iterator i1, wxStringImpl::const_iterator i2);
- static int DiffIters(wxStringImpl::iterator i1, wxStringImpl::iterator i2);
-
- struct Utf8CharBuffer
- {
- char data[5];
- operator const char*() const { return data; }
- };
- static Utf8CharBuffer EncodeChar(wxUniChar ch);
- // returns n copies of ch encoded in UTF-8 string
- static wxCharBuffer EncodeNChars(size_t n, wxUniChar ch);
-
- // returns the length of UTF-8 encoding of the character with lead byte 'c'
- static size_t GetUtf8CharLength(char c)
- {
- wxASSERT( IsValidUtf8LeadByte(c) );
- return ms_utf8IterTable[(unsigned char)c];
- }
+ // FIXME-UTF8: return as-is without copying under UTF8 locale, return
+ // converted string under other locales - needs wxCharBuffer
+ // changes
+ static wxCharBuffer ImplStr(const char* str,
+ const wxMBConv& conv = wxConvLibc)
+ { return ConvertStr(str, npos, conv).data; }
+ static SubstrBufFromMB ImplStr(const char* str, size_t n,
+ const wxMBConv& conv = wxConvLibc)
+ { return ConvertStr(str, n, conv); }
- // decodes single UTF-8 character from UTF-8 string
- // FIXME-UTF8: move EncodeChar/DecodeChar and other operations to separate
- // class
- static wxUniChar DecodeChar(wxStringImpl::const_iterator i)
- { return wxUniCharRef::DecodeChar(i); }
- friend class WXDLLIMPEXP_BASE wxUniCharRef;
+ static wxCharBuffer ImplStr(const wchar_t* str)
+ { return ConvertStr(str, npos, wxConvUTF8).data; }
+ static SubstrBufFromWC ImplStr(const wchar_t* str, size_t n)
+ { return ConvertStr(str, n, wxConvUTF8); }
size_t PosToImpl(size_t pos) const
{
else
return const_iterator(m_impl.begin() + pos) - begin();
}
-
- // FIXME-UTF8: return as-is without copying under UTF8 locale, return
- // converted string under other locales - needs wxCharBuffer
- // changes
- static wxCharBuffer ImplStr(const char* str,
- const wxMBConv& conv = wxConvLibc)
- { return ConvertStr(str, npos, conv).data; }
- static SubstrBufFromMB ImplStr(const char* str, size_t n,
- const wxMBConv& conv = wxConvLibc)
- { return ConvertStr(str, n, conv); }
-
- static wxCharBuffer ImplStr(const wchar_t* str)
- { return ConvertStr(str, npos, wxConvUTF8).data; }
- static SubstrBufFromWC ImplStr(const wchar_t* str, size_t n)
- { return ConvertStr(str, n, wxConvUTF8); }
#endif // !wxUSE_UNICODE_UTF8/wxUSE_UNICODE_UTF8
public:
reference operator[](size_t n) const { return *(*this + n); } \
\
iterator_name& operator++() \
- { wxString::IncIter(m_cur); return *this; } \
+ { wxStringOperations::IncIter(m_cur); return *this; } \
iterator_name& operator--() \
- { wxString::DecIter(m_cur); return *this; } \
+ { wxStringOperations::DecIter(m_cur); return *this; } \
iterator_name operator++(int) \
{ \
iterator_name tmp = *this; \
- wxString::IncIter(m_cur); \
+ wxStringOperations::IncIter(m_cur); \
return tmp; \
} \
iterator_name operator--(int) \
{ \
iterator_name tmp = *this; \
- wxString::DecIter(m_cur); \
+ wxStringOperations::DecIter(m_cur); \
return tmp; \
} \
\
iterator_name& operator+=(int n) \
- { m_cur = wxString::AddToIter(m_cur, n); return *this; } \
+ { \
+ m_cur = wxStringOperations::AddToIter(m_cur, n); \
+ return *this; \
+ } \
iterator_name& operator+=(size_t n) \
- { m_cur = wxString::AddToIter(m_cur, (int)n); return *this; } \
+ { \
+ m_cur = wxStringOperations::AddToIter(m_cur, (int)n); \
+ return *this; \
+ } \
iterator_name& operator-=(int n) \
- { m_cur = wxString::AddToIter(m_cur, -n); return *this; } \
+ { \
+ m_cur = wxStringOperations::AddToIter(m_cur, -n); \
+ return *this; \
+ } \
iterator_name& operator-=(size_t n) \
- { m_cur = wxString::AddToIter(m_cur, -(int)n); return *this; } \
+ { \
+ m_cur = wxStringOperations::AddToIter(m_cur, -(int)n); \
+ return *this; \
+ } \
\
difference_type operator-(const iterator_name& i) const \
- { return wxString::DiffIters(m_cur, i.m_cur); } \
+ { return wxStringOperations::DiffIters(m_cur, i.m_cur); } \
\
bool operator==(const iterator_name& i) const \
{ return m_cur == i.m_cur; } \
iterator(const iterator& i) : m_cur(i.m_cur), m_str(i.m_str) {}
iterator operator+(int n) const
- { return iterator(m_str, wxString::AddToIter(m_cur, n)); }
+ { return iterator(m_str, wxStringOperations::AddToIter(m_cur, n)); }
iterator operator+(size_t n) const
- { return iterator(m_str, wxString::AddToIter(m_cur, (int)n)); }
+ { return iterator(m_str, wxStringOperations::AddToIter(m_cur, (int)n)); }
iterator operator-(int n) const
- { return iterator(m_str, wxString::AddToIter(m_cur, -n)); }
+ { return iterator(m_str, wxStringOperations::AddToIter(m_cur, -n)); }
iterator operator-(size_t n) const
- { return iterator(m_str, wxString::AddToIter(m_cur, -(int)n)); }
+ { return iterator(m_str, wxStringOperations::AddToIter(m_cur, -(int)n)); }
private:
iterator(wxString *str, underlying_iterator ptr)
iterator(const iterator& i) : m_cur(i.m_cur) {}
iterator operator+(int n) const
- { return iterator(wxString::AddToIter(m_cur, n)); }
+ { return iterator(wxStringOperations::AddToIter(m_cur, n)); }
iterator operator+(size_t n) const
- { return iterator(wxString::AddToIter(m_cur, (int)n)); }
+ { return iterator(wxStringOperations::AddToIter(m_cur, (int)n)); }
iterator operator-(int n) const
- { return iterator(wxString::AddToIter(m_cur, -n)); }
+ { return iterator(wxStringOperations::AddToIter(m_cur, -n)); }
iterator operator-(size_t n) const
- { return iterator(wxString::AddToIter(m_cur, -(int)n)); }
+ { return iterator(wxStringOperations::AddToIter(m_cur, -(int)n)); }
private:
// for internal wxString use only:
// NB: reference_type is intentionally value, not reference, the character
// may be encoded differently in wxString data:
WX_STR_ITERATOR_IMPL(const_iterator, const wxChar*, wxUniChar,
- wxString::DecodeChar(m_cur));
+ wxStringOperations::DecodeChar(m_cur));
public:
const_iterator(const const_iterator& i) : m_cur(i.m_cur) {}
const_iterator(const iterator& i) : m_cur(i.m_cur) {}
const_iterator operator+(int n) const
- { return const_iterator(wxString::AddToIter(m_cur, n)); }
+ { return const_iterator(wxStringOperations::AddToIter(m_cur, n)); }
const_iterator operator+(size_t n) const
- { return const_iterator(wxString::AddToIter(m_cur, (int)n)); }
+ { return const_iterator(wxStringOperations::AddToIter(m_cur, (int)n)); }
const_iterator operator-(int n) const
- { return const_iterator(wxString::AddToIter(m_cur, -n)); }
+ { return const_iterator(wxStringOperations::AddToIter(m_cur, -n)); }
const_iterator operator-(size_t n) const
- { return const_iterator(wxString::AddToIter(m_cur, -(int)n)); }
+ { return const_iterator(wxStringOperations::AddToIter(m_cur, -(int)n)); }
private:
// for internal wxString use only:
return const_iterator(data.m_str->begin() + data.m_offset);
}
+ // in UTF-8 STL build, creation from std::string requires conversion under
+ // non-UTF8 locales, so we can't have and use wxString(wxStringImpl) ctor;
+ // instead we define dummy type that lets us have wxString ctor for creation
+ // from wxStringImpl that couldn't be used by user code (in all other builds,
+ // "standard" ctors can be used):
+#if wxUSE_UNICODE_UTF8 && wxUSE_STL_BASED_WXSTRING
+ struct CtorFromStringImplTag {};
+
+ wxString(CtorFromStringImplTag* WXUNUSED(dummy), const wxStringImpl& src)
+ : m_impl(src) {}
+
+ static wxString FromImpl(const wxStringImpl& src)
+ { return wxString((CtorFromStringImplTag*)NULL, src); }
+#else
+ #if !wxUSE_STL_BASED_WXSTRING
+ wxString(const wxStringImpl& src) : m_impl(src) { }
+ // else: already defined as wxString(wxStdString) below
+ #endif
+ static wxString FromImpl(const wxStringImpl& src) { return wxString(src); }
+#endif
+
public:
// constructors and destructor
// ctor for an empty string
wxString() {}
// copy ctor
- // FIXME-UTF8: this one needs to do UTF-8 conversion in UTF-8 build!
- wxString(const wxStringImpl& stringSrc) : m_impl(stringSrc) { }
-
wxString(const wxString& stringSrc) : m_impl(stringSrc.m_impl) { }
// string containing nRepeat copies of ch
: m_impl(str.Mid(0, nLength).m_impl) {}
// even if we're not built 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
+ // implicit conversions from std::string to wxString and vice verse 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 && !wxUSE_STL_BASED_WXSTRING
- wxString(const wxStdString& s)
- // FIXME-UTF8: this one needs to do UTF-8 conversion in UTF-8 build!
- : m_impl(s.c_str()) { } // FIXME-UTF8: this is broken for embedded 0s
-#endif // wxUSE_STD_STRING && !wxUSE_STL_BASED_WXSTRING
+#if wxUSE_STD_STRING
+
+ #if wxUSE_UNICODE_WCHAR
+ wxString(const wxStdWideString& str) : m_impl(str) {}
+ #else // UTF-8 or ANSI
+ wxString(const wxStdWideString& str)
+ { assign(str.c_str(), str.length()); }
+ #endif
+
+ #if !wxUSE_UNICODE // ANSI build
+ // FIXME-UTF8: do this in UTF8 build #if wxUSE_UTF8_LOCALE_ONLY, too
+ wxString(const std::string& str) : m_impl(str) {}
+ #else // Unicode
+ wxString(const std::string& str)
+ { assign(str.c_str(), str.length()); }
+ #endif
+
+ #if wxUSE_UNICODE_WCHAR && wxUSE_STL_BASED_WXSTRING
+ // wxStringImpl is std::string in the encoding we want
+ operator const wxStdWideString&() const { return m_impl; }
+ #else
+ // wxStringImpl is either not std::string or needs conversion
+ operator wxStdWideString() const
+ // FIXME-UTF8: broken for embedded NULs
+ { return wxStdWideString(wc_str()); }
+ #endif
+
+ #if !wxUSE_UNICODE && wxUSE_STL_BASED_WXSTRING
+ // FIXME-UTF8: do this in UTF8 build #if wxUSE_UTF8_LOCALE_ONLY, too
+ // wxStringImpl is std::string in the encoding we want
+ operator const std::string&() const { return m_impl; }
+ #else
+ // wxStringImpl is either not std::string or needs conversion
+ operator std::string() const
+ // FIXME-UTF8: broken for embedded NULs
+ { return std::string(mb_str()); }
+ #endif
+#endif // wxUSE_STD_STRING
// first valid index position
const_iterator begin() const { return const_iterator(m_impl.begin()); }
{
size_t pos, len;
PosLenToImpl(nStart, nLen, &pos, &len);
- return m_impl.substr(pos, len);
+ return FromImpl(m_impl.substr(pos, len));
}
// generic attributes & operations
{ return *this = cstr.AsString(); }
// from a character
wxString& operator=(wxUniChar ch)
- { m_impl = EncodeChar(ch); return *this; }
+ { m_impl = wxStringOperations::EncodeChar(ch); return *this; }
wxString& operator=(wxUniCharRef ch)
{ return operator=((wxUniChar)ch); }
wxString& operator=(char ch)
{
#if wxUSE_UNICODE_UTF8
if ( !ch.IsAscii() )
- m_impl.append(EncodeNChars(n, ch));
+ m_impl.append(wxStringOperations::EncodeNChars(n, ch));
else
#endif
m_impl.append(n, (wxStringCharType)ch);
{
#if wxUSE_UNICODE_UTF8
if ( !ch.IsAscii() )
- m_impl.assign(EncodeNChars(n, ch));
+ m_impl.assign(wxStringOperations::EncodeNChars(n, ch));
else
#endif
m_impl.assign(n, (wxStringCharType)ch);
{
#if wxUSE_UNICODE_UTF8
if ( !ch.IsAscii() )
- m_impl.insert(PosToImpl(nPos), EncodeNChars(n, ch));
+ m_impl.insert(PosToImpl(nPos), wxStringOperations::EncodeNChars(n, ch));
else
#endif
m_impl.insert(PosToImpl(nPos), n, (wxStringCharType)ch);
if ( !ch.IsAscii() )
{
size_t pos = IterToImplPos(it);
- m_impl.insert(pos, EncodeChar(ch));
+ m_impl.insert(pos, wxStringOperations::EncodeChar(ch));
return iterator(this, m_impl.begin() + pos);
}
else
{
#if wxUSE_UNICODE_UTF8
if ( !ch.IsAscii() )
- m_impl.insert(IterToImplPos(it), EncodeNChars(n, ch));
+ m_impl.insert(IterToImplPos(it), wxStringOperations::EncodeNChars(n, ch));
else
#endif
m_impl.insert(it.impl(), n, (wxStringCharType)ch);
PosLenToImpl(nStart, nLen, &from, &len);
#if wxUSE_UNICODE_UTF8
if ( !ch.IsAscii() )
- m_impl.replace(from, len, EncodeNChars(nCount, ch));
+ m_impl.replace(from, len, wxStringOperations::EncodeNChars(nCount, ch));
else
#endif
m_impl.replace(from, len, nCount, (wxStringCharType)ch);
{
#if wxUSE_UNICODE_UTF8
if ( !ch.IsAscii() )
- m_impl.replace(first.impl(), last.impl(), EncodeNChars(n, ch));
+ m_impl.replace(first.impl(), last.impl(),
+ wxStringOperations::EncodeNChars(n, ch));
else
#endif
m_impl.replace(first.impl(), last.impl(), n, (wxStringCharType)ch);
// find the first occurence of character ch after nStart
size_t find(wxUniChar ch, size_t nStart = 0) const
- { return PosFromImpl(m_impl.find(EncodeChar(ch), PosToImpl(nStart))); }
+ {
+ return PosFromImpl(m_impl.find(wxStringOperations::EncodeChar(ch),
+ PosToImpl(nStart)));
+ }
size_t find(wxUniCharRef ch, size_t nStart = 0) const
{ return find(wxUniChar(ch), nStart); }
size_t find(char ch, size_t nStart = 0) const
}
// as find, but from the end
size_t rfind(wxUniChar ch, size_t nStart = npos) const
- { return PosFromImpl(m_impl.rfind(EncodeChar(ch), PosToImpl(nStart))); }
+ {
+ return PosFromImpl(m_impl.rfind(wxStringOperations::EncodeChar(ch),
+ PosToImpl(nStart)));
+ }
size_t rfind(wxUniCharRef ch, size_t nStart = npos) const
{ return rfind(wxUniChar(ch), nStart); }
size_t rfind(char ch, size_t nStart = npos) const
{ m_impl += s.AsString().m_impl; return *this; }
// string += char
wxString& operator+=(wxUniChar ch)
- { m_impl += EncodeChar(ch); return *this; }
+ { m_impl += wxStringOperations::EncodeChar(ch); return *this; }
wxString& operator+=(wxUniCharRef ch) { return *this += wxUniChar(ch); }
wxString& operator+=(int ch) { return *this += wxUniChar(ch); }
wxString& operator+=(char ch) { return *this += wxUniChar(ch); }
// wxString comparison functions: operator versions are always case sensitive
// ---------------------------------------------------------------------------
-#define wxCMP_WXCHAR_STRING(p, s, op) s.Cmp(p) op 0
+#define wxCMP_WXCHAR_STRING(p, s, op) 0 op s.Cmp(p)
wxDEFINE_ALL_COMPARISONS(const wxChar *, const wxString&, wxCMP_WXCHAR_STRING)
inline wxUniChar wxCStrData::operator[](size_t n) const
{
- return m_str->at(m_offset + n);
+ // NB: we intentionally use operator[] and not at() here because the former
+ // works for the terminating NUL while the latter does not
+ return (*m_str)[m_offset + n];
}
// ----------------------------------------------------------------------------
projects / wxWidgets.git / blobdiff