#pragma warning (disable:4275)
#endif
+#if wxUSE_UNICODE_UTF8
+// see the comment near wxString::iterator for why we need this
+struct WXDLLIMPEXP_BASE wxStringIteratorNode
+{
+ inline wxStringIteratorNode(const wxString *str,
+ wxStringImpl::const_iterator *citer);
+ inline wxStringIteratorNode(const wxString *str,
+ wxStringImpl::iterator *iter);
+ inline ~wxStringIteratorNode();
+
+ const wxString *m_str;
+ wxStringImpl::const_iterator *m_citer;
+ wxStringImpl::iterator *m_iter;
+ wxStringIteratorNode *m_prev, *m_next;
+};
+#endif // wxUSE_UNICODE_UTF8
+
class WXDLLIMPEXP_BASE wxString
#ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
: public wxStringPrintfMixin
if ( pos == 0 || pos == npos )
return pos;
else
- return const_iterator(m_impl.begin() + pos) - begin();
+ return const_iterator(this, m_impl.begin() + pos) - begin();
}
#endif // !wxUSE_UNICODE_UTF8/wxUSE_UNICODE_UTF8
#define WX_STR_ITERATOR_TAG void /* dummy type */
#endif
- #define WX_STR_ITERATOR_IMPL(iterator_name, pointer_type, \
- reference_type, reference_ctor) \
+ #define WX_STR_ITERATOR_IMPL(iterator_name, pointer_type, reference_type) \
private: \
typedef wxStringImpl::iterator_name underlying_iterator; \
public: \
typedef reference_type reference; \
typedef pointer_type pointer; \
\
- reference operator*() const { return reference_ctor; } \
reference operator[](size_t n) const { return *(*this + n); } \
\
iterator_name& operator++() \
class const_iterator;
#if wxUSE_UNICODE_UTF8
+ // NB: In UTF-8 build, (non-const) iterator needs to keep reference
+ // to the underlying wxStringImpl, because UTF-8 is variable-length
+ // encoding and changing the value pointer to by an iterator (using
+ // its operator*) requires calling wxStringImpl::replace() if the old
+ // and new values differ in their encoding's length.
+ //
+ // Furthermore, the replace() call may invalid all iterators for the
+ // string, so we have to keep track of outstanding iterators and update
+ // them if replace() happens.
+ //
+ // This is implemented by maintaining linked list of iterators for every
+ // string and traversing it in wxUniCharRef::operator=(). Head of the
+ // list is stored in wxString. (FIXME-UTF8)
+
class iterator
{
- // NB: In UTF-8 build, (non-const) iterator needs to keep reference
- // to the underlying wxStringImpl, because UTF-8 is variable-length
- // encoding and changing the value pointer to by an iterator using
- // its operator* requires calling wxStringImpl::replace() if the old
- // and new values differ in their encoding's length.
-
- WX_STR_ITERATOR_IMPL(iterator, wxChar*, wxUniCharRef,
- wxUniCharRef::CreateForString(m_str, m_cur));
+ WX_STR_ITERATOR_IMPL(iterator, wxChar*, wxUniCharRef);
public:
- iterator(const iterator& i) : m_cur(i.m_cur), m_str(i.m_str) {}
+ iterator(const iterator& i)
+ : m_cur(i.m_cur), m_node(i.str(), &m_cur) {}
+
+ reference operator*()
+ { return wxUniCharRef::CreateForString(m_node, m_cur); }
iterator operator+(int n) const
- { return iterator(m_str, wxStringOperations::AddToIter(m_cur, n)); }
+ { return iterator(str(), wxStringOperations::AddToIter(m_cur, n)); }
iterator operator+(size_t n) const
- { return iterator(m_str, wxStringOperations::AddToIter(m_cur, (int)n)); }
+ { return iterator(str(), wxStringOperations::AddToIter(m_cur, (int)n)); }
iterator operator-(int n) const
- { return iterator(m_str, wxStringOperations::AddToIter(m_cur, -n)); }
+ { return iterator(str(), wxStringOperations::AddToIter(m_cur, -n)); }
iterator operator-(size_t n) const
- { return iterator(m_str, wxStringOperations::AddToIter(m_cur, -(int)n)); }
+ { return iterator(str(), wxStringOperations::AddToIter(m_cur, -(int)n)); }
private:
iterator(wxString *str, underlying_iterator ptr)
- : m_cur(ptr), m_str(str->m_impl) {}
- iterator(wxStringImpl& str, underlying_iterator ptr)
- : m_cur(ptr), m_str(str) {}
+ : m_cur(ptr), m_node(str, &m_cur) {}
+ iterator(wxString& str, underlying_iterator ptr)
+ : m_cur(ptr), m_node(&str, &m_cur) {}
- wxStringImpl& m_str;
+ wxString* str() const { return wx_const_cast(wxString*, m_node.m_str); }
+
+ wxStringIteratorNode m_node;
friend class const_iterator;
};
+ class const_iterator
+ {
+ // 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);
+
+ public:
+ const_iterator(const const_iterator& i)
+ : m_cur(i.m_cur), m_node(i.str(), &m_cur) {}
+ const_iterator(const iterator& i)
+ : m_cur(i.m_cur), m_node(i.str(), &m_cur) {}
+
+ reference operator*() const
+ { return wxStringOperations::DecodeChar(m_cur); }
+
+ const_iterator operator+(int n) const
+ { return const_iterator(str(), wxStringOperations::AddToIter(m_cur, n)); }
+ const_iterator operator+(size_t n) const
+ { return const_iterator(str(), wxStringOperations::AddToIter(m_cur, (int)n)); }
+ const_iterator operator-(int n) const
+ { return const_iterator(str(), wxStringOperations::AddToIter(m_cur, -n)); }
+ const_iterator operator-(size_t n) const
+ { return const_iterator(str(), wxStringOperations::AddToIter(m_cur, -(int)n)); }
+
+ private:
+ // 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; }
+
+ wxStringIteratorNode m_node;
+ };
+
size_t IterToImplPos(wxString::iterator i) const
{ return wxStringImpl::const_iterator(i.impl()) - m_impl.begin(); }
class iterator
{
- WX_STR_ITERATOR_IMPL(iterator, wxChar*, wxUniCharRef,
- wxUniCharRef::CreateForString(m_cur));
+ WX_STR_ITERATOR_IMPL(iterator, wxChar*, wxUniCharRef);
public:
iterator(const iterator& i) : m_cur(i.m_cur) {}
+ reference operator*()
+ { return wxUniCharRef::CreateForString(m_cur); }
+
iterator operator+(int n) const
{ return iterator(wxStringOperations::AddToIter(m_cur, n)); }
iterator operator+(size_t n) const
friend class const_iterator;
};
-#endif // wxUSE_UNICODE_UTF8/!wxUSE_UNICODE_UTF8
class const_iterator
{
// 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,
- wxStringOperations::DecodeChar(m_cur));
+ WX_STR_ITERATOR_IMPL(const_iterator, const wxChar*, wxUniChar);
public:
const_iterator(const const_iterator& i) : m_cur(i.m_cur) {}
const_iterator(const iterator& i) : m_cur(i.m_cur) {}
+ reference operator*() const
+ { return wxStringOperations::DecodeChar(m_cur); }
+
const_iterator operator+(int n) const
{ return const_iterator(wxStringOperations::AddToIter(m_cur, n)); }
const_iterator operator+(size_t n) const
private:
// for internal wxString use only:
const_iterator(underlying_iterator ptr) : m_cur(ptr) {}
+ const_iterator(const wxString *WXUNUSED(str), underlying_iterator ptr)
+ : m_cur(ptr) {}
};
+#endif // wxUSE_UNICODE_UTF8/!wxUSE_UNICODE_UTF8
#undef WX_STR_ITERATOR_TAG
#undef WX_STR_ITERATOR_IMPL
// wxCStrData) to an iterator into the string
static const_iterator CreateConstIterator(const wxCStrData& data)
{
- return const_iterator(data.m_str->begin() + data.m_offset);
+ return const_iterator(data.m_str,
+ (data.m_str->begin() + data.m_offset).impl());
}
// in UTF-8 STL build, creation from std::string requires conversion under
#endif // wxUSE_STL
// first valid index position
- const_iterator begin() const { return const_iterator(m_impl.begin()); }
+ const_iterator begin() const { return const_iterator(this, m_impl.begin()); }
iterator begin() { return iterator(this, m_impl.begin()); }
// position one after the last valid one
- const_iterator end() const { return const_iterator(m_impl.end()); }
+ const_iterator end() const { return const_iterator(this, m_impl.end()); }
iterator end() { return iterator(this, m_impl.end()); }
// first element of the reversed string
ConvertedBuffer<wchar_t> m_convertedToWChar;
#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
+ // change the underlying wxStringImpl iterator, so we have to
+ // keep track of all iterators and update them as necessary:
+ struct wxStringIteratorNodeHead
+ {
+ wxStringIteratorNodeHead() : ptr(NULL) {}
+ wxStringIteratorNode *ptr;
+ };
+
+ wxStringIteratorNodeHead m_iterators;
+
+ friend class WXDLLIMPEXP_BASE wxStringIteratorNode;
+ friend class WXDLLIMPEXP_BASE wxUniCharRef;
+#endif // wxUSE_UNICODE_UTF8
+
friend class WXDLLIMPEXP_BASE wxCStrData;
friend class wxImplStringBuffer;
friend class wxImplStringBufferLength;
{
}
+#if wxUSE_UNICODE_UTF8
+// ----------------------------------------------------------------------------
+// implementation of wxStringIteratorNode inline methods
+// ----------------------------------------------------------------------------
+
+wxStringIteratorNode::wxStringIteratorNode(const wxString *str,
+ wxStringImpl::const_iterator *citer)
+ : m_str(str),
+ m_citer(citer),
+ m_iter(NULL),
+ m_prev(NULL),
+ m_next(str->m_iterators.ptr)
+{
+ wx_const_cast(wxString*, m_str)->m_iterators.ptr = this;
+ if ( m_next )
+ m_next->m_prev = this;
+}
+
+wxStringIteratorNode::wxStringIteratorNode(const wxString *str,
+ wxStringImpl::iterator *iter)
+ : m_str(str),
+ m_citer(NULL),
+ m_iter(iter),
+ m_prev(NULL),
+ m_next(str->m_iterators.ptr)
+{
+ wx_const_cast(wxString*, m_str)->m_iterators.ptr = this;
+ if ( m_next)
+ m_next->m_prev = this;
+}
+
+wxStringIteratorNode::~wxStringIteratorNode()
+{
+ if ( m_next )
+ m_next->m_prev = m_prev;
+ if ( m_prev )
+ m_prev->m_next = m_next;
+ else // first in the list
+ wx_const_cast(wxString*, m_str)->m_iterators.ptr = m_next;
+}
+#endif // wxUSE_UNICODE_UTF8
+
#if WXWIN_COMPATIBILITY_2_8
// lot of code out there doesn't explicitly include wx/wxchar.h, but uses
// CRT wrappers that are now declared in wx/wxcrt.h and wx/wxcrtvararg.h,
if ( lenNew == lenOld )
{
+ // this is the simpler case: if the new value's UTF-8 code has the
+ // same length, we can just replace it:
+
iterator pos(m_pos);
for ( size_t i = 0; i < lenNew; ++i, ++pos )
*pos = utf[i];
}
else
{
- size_t idx = m_pos - m_str.begin();
-
- m_str.replace(m_pos, m_pos + lenOld, utf, lenNew);
-
- // this is needed to keep m_pos valid:
- m_pos = m_str.begin() + idx;
+ // the worse case is when the new value has either longer or shorter
+ // code -- in that case, we have to use wxStringImpl::replace() and
+ // this invalidates all iterators, so we have to update them too:
+
+ wxString& str = *wx_const_cast(wxString*, m_node.m_str);
+ wxStringImpl& strimpl = str.m_impl;
+
+ int iterDiff = lenNew - lenOld;
+ size_t posIdx = m_pos - strimpl.begin();
+
+ // compute positions of outstanding iterators for this string after the
+ // replacement is done (there is only a small number of iterators at
+ // any time, so we use an array on the stack to avoid unneeded
+ // allocation):
+ static const size_t STATIC_SIZE = 32;
+ size_t indexes_a[STATIC_SIZE];
+ size_t *indexes = indexes_a;
+ size_t iterNum = 0;
+ wxStringIteratorNode *it;
+ for ( it = str.m_iterators.ptr; it; it = it->m_next, ++iterNum )
+ {
+ wxASSERT( it->m_iter || it->m_citer );
+
+ if ( iterNum == STATIC_SIZE )
+ {
+ wxLogTrace( _T("utf8"), _T("unexpectedly many iterators") );
+
+ size_t total = iterNum + 1;
+ for ( wxStringIteratorNode *it2 = it; it2; it2 = it2->m_next )
+ total++;
+ indexes = new size_t[total];
+ memcpy(indexes, indexes_a, sizeof(size_t) * STATIC_SIZE);
+ }
+
+ size_t idx = it->m_iter
+ ? (*it->m_iter - strimpl.begin())
+ : (*it->m_citer - strimpl.begin());
+
+ if ( idx > posIdx )
+ idx += iterDiff;
+
+ indexes[iterNum] = idx;
+ }
+
+ // update the string:
+ strimpl.replace(m_pos, m_pos + lenOld, utf, lenNew);
+
+ // finally, set the iterators to valid values again (note that this
+ // updates m_pos as well):
+ size_t i;
+ for ( i = 0, it = str.m_iterators.ptr; it; it = it->m_next, ++i )
+ {
+ wxASSERT( i < iterNum );
+ wxASSERT( it->m_iter || it->m_citer );
+
+ if ( it->m_iter )
+ *it->m_iter = strimpl.begin() + indexes[i];
+ else // it->m_citer
+ *it->m_citer = strimpl.begin() + indexes[i];
+ }
+
+ if ( indexes != indexes_a )
+ delete[] indexes;
}
return *this;
projects / wxWidgets.git / commitdiff
