#include "wx/defs.h" // everybody should include this
+#ifndef __WXPALMOS5__
#if defined(__WXMAC__) || defined(__VISAGECPP__)
#include <ctype.h>
#endif
#ifdef HAVE_STRCASECMP_IN_STRINGS_H
#include <strings.h> // for strcasecmp()
#endif // HAVE_STRCASECMP_IN_STRINGS_H
-
-#ifdef __WXPALMOS__
- #include <StringMgr.h>
-#endif
+#endif // ! __WXPALMOS5__
#include "wx/wxcrtbase.h" // for wxChar, wxStrlen() etc.
#include "wx/strvararg.h"
#include "wx/stringops.h"
#include "wx/unichar.h"
+// by default we cache the mapping of the positions in UTF-8 string to the byte
+// offset as this results in noticeable performance improvements for loops over
+// strings using indices; comment out this line to disable this
+//
+// notice that this optimization is well worth using even in debug builds as it
+// changes asymptotic complexity of algorithms using indices to iterate over
+// wxString back to expected linear from quadratic
+//
+// also notice that wxTLS_TYPE() (__declspec(thread) in this case) is unsafe to
+// use in DLL build under pre-Vista Windows so we disable this code for now, if
+// anybody really needs to use UTF-8 build under Windows with this optimization
+// it would have to be re-tested and probably corrected
+// CS: under OSX release builds the string destructor/cache cleanup sometimes
+// crashes, disable until we find the true reason or a better workaround
+#if wxUSE_UNICODE_UTF8 && !defined(__WXMSW__) && !defined(__WXOSX__)
+ #define wxUSE_STRING_POS_CACHE 1
+#else
+ #define wxUSE_STRING_POS_CACHE 0
+#endif
+
+#if wxUSE_STRING_POS_CACHE
+ #include "wx/tls.h"
+
+ // change this 0 to 1 to enable additional (very expensive) asserts
+ // verifying that string caching logic works as expected
+ #if 0
+ #define wxSTRING_CACHE_ASSERT(cond) wxASSERT(cond)
+ #else
+ #define wxSTRING_CACHE_ASSERT(cond)
+ #endif
+#endif // wxUSE_STRING_POS_CACHE
+
class WXDLLIMPEXP_FWD_BASE wxString;
// unless this symbol is predefined to disable the compatibility functions, do
#define WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER 1
#endif
+namespace wxPrivate
+{
+ template <typename T> struct wxStringAsBufHelper;
+}
+
// ---------------------------------------------------------------------------
// macros
// ---------------------------------------------------------------------------
// 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)
+ wxDECLARE_NO_COPY_CLASS(wxStringIteratorNode);
};
#endif // wxUSE_UNICODE_UTF8
size_t len;
SubstrBufFromType(const T& data_, size_t len_)
- : data(data_), len(len_) {}
+ : data(data_), len(len_)
+ {
+ wxASSERT_MSG( len != npos, "must have real length" );
+ }
};
#if wxUSE_UNICODE_UTF8
static size_t LenToImpl(size_t len) { return len; }
static size_t PosFromImpl(size_t pos) { return pos; }
+ // we don't want to define these as empty inline functions as it could
+ // result in noticeable (and quite unnecessary in non-UTF-8 build) slowdown
+ // in debug build where the inline functions are not effectively inlined
+ #define wxSTRING_INVALIDATE_CACHE()
+ #define wxSTRING_INVALIDATE_CACHED_LENGTH()
+ #define wxSTRING_UPDATE_CACHED_LENGTH(n)
+ #define wxSTRING_SET_CACHED_LENGTH(n)
+
#else // wxUSE_UNICODE_UTF8
static wxCharBuffer ImplStr(const char* str,
static SubstrBufFromWC ImplStr(const wchar_t* str, size_t n)
{ return ConvertStr(str, n, wxMBConvUTF8()); }
+#if wxUSE_STRING_POS_CACHE
+ // this is an extremely simple cache used by PosToImpl(): each cache element
+ // contains the string it applies to and the index corresponding to the last
+ // used position in this wxString in its m_impl string
+ //
+ // NB: notice that this struct (and nested Element one) must be a POD or we
+ // wouldn't be able to use a thread-local variable of this type, in
+ // particular it should have no ctor -- we rely on statics being
+ // initialized to 0 instead
+ struct Cache
+ {
+ enum { SIZE = 8 };
+
+ struct Element
+ {
+ const wxString *str; // the string to which this element applies
+ size_t pos, // the cached index in this string
+ impl, // the corresponding position in its m_impl
+ len; // cached length or npos if unknown
+
+ // reset cached index to 0
+ void ResetPos() { pos = impl = 0; }
+
+ // reset position and length
+ void Reset() { ResetPos(); len = npos; }
+ };
+
+ // cache the indices mapping for the last few string used
+ Element cached[SIZE];
+
+ // the last used index
+ unsigned lastUsed;
+ };
+
+#ifndef wxHAS_COMPILER_TLS
+ // we must use an accessor function and not a static variable when the TLS
+ // variables support is implemented in the library (and not by the compiler)
+ // because the global s_cache variable could be not yet initialized when a
+ // ctor of another global object is executed and if that ctor uses any
+ // wxString methods, bad things happen
+ //
+ // however notice that this approach does not work when compiler TLS is used,
+ // at least not with g++ 4.1.2 under amd64 as it apparently compiles code
+ // using this accessor incorrectly when optimizations are enabled (-O2 is
+ // enough) -- luckily we don't need it then neither as static __thread
+ // variables are initialized by 0 anyhow then and so we can use the variable
+ // directly
+ WXEXPORT static Cache& GetCache()
+ {
+ static wxTLS_TYPE(Cache) s_cache;
+
+ return wxTLS_VALUE(s_cache);
+ }
+
+ // this helper struct is used to ensure that GetCache() is called during
+ // static initialization time, i.e. before any threads creation, as otherwise
+ // the static s_cache construction inside GetCache() wouldn't be MT-safe
+ friend struct wxStrCacheInitializer;
+#else // wxHAS_COMPILER_TLS
+ static wxTLS_TYPE(Cache) ms_cache;
+ static Cache& GetCache() { return wxTLS_VALUE(ms_cache); }
+#endif // !wxHAS_COMPILER_TLS/wxHAS_COMPILER_TLS
+
+ static Cache::Element *GetCacheBegin() { return GetCache().cached; }
+ static Cache::Element *GetCacheEnd() { return GetCacheBegin() + Cache::SIZE; }
+ static unsigned& LastUsedCacheElement() { return GetCache().lastUsed; }
+
+ // this is used in debug builds only to provide a convenient function,
+ // callable from a debugger, to show the cache contents
+ friend struct wxStrCacheDumper;
+
+ // uncomment this to have access to some profiling statistics on program
+ // termination
+ //#define wxPROFILE_STRING_CACHE
+
+#ifdef wxPROFILE_STRING_CACHE
+ static struct PosToImplCacheStats
+ {
+ unsigned postot, // total non-trivial calls to PosToImpl
+ poshits, // cache hits from PosToImpl()
+ mishits, // cached position beyond the needed one
+ sumpos, // sum of all positions, used to compute the
+ // average position after dividing by postot
+ sumofs, // sum of all offsets after using the cache, used to
+ // compute the average after dividing by hits
+ lentot, // number of total calls to length()
+ lenhits; // number of cache hits in length()
+ } ms_cacheStats;
+
+ friend struct wxStrCacheStatsDumper;
+
+ #define wxCACHE_PROFILE_FIELD_INC(field) ms_cacheStats.field++
+ #define wxCACHE_PROFILE_FIELD_ADD(field, val) ms_cacheStats.field += (val)
+#else // !wxPROFILE_STRING_CACHE
+ #define wxCACHE_PROFILE_FIELD_INC(field)
+ #define wxCACHE_PROFILE_FIELD_ADD(field, val)
+#endif // wxPROFILE_STRING_CACHE/!wxPROFILE_STRING_CACHE
+
+ // note: it could seem that the functions below shouldn't be inline because
+ // they are big, contain loops and so the compiler shouldn't be able to
+ // inline them anyhow, however moving them into string.cpp does decrease the
+ // code performance by ~5%, at least when using g++ 4.1 so do keep them here
+ // unless tests show that it's not advantageous any more
+
+ // return the pointer to the cache element for this string or NULL if not
+ // cached
+ Cache::Element *FindCacheElement() const
+ {
+ // profiling seems to show a small but consistent gain if we use this
+ // simple loop instead of starting from the last used element (there are
+ // a lot of misses in this function...)
+ Cache::Element * const cacheBegin = GetCacheBegin();
+#ifndef wxHAS_COMPILER_TLS
+ // during destruction tls calls may return NULL, in this case return NULL
+ // immediately without accessing anything else
+ if ( cacheBegin == NULL )
+ return NULL;
+#endif
+ Cache::Element * const cacheEnd = GetCacheEnd();
+ for ( Cache::Element *c = cacheBegin; c != cacheEnd; c++ )
+ {
+ if ( c->str == this )
+ return c;
+ }
+
+ return NULL;
+ }
+
+ // unlike FindCacheElement(), this one always returns a valid pointer to the
+ // cache element for this string, it may have valid last cached position and
+ // its corresponding index in the byte string or not
+ Cache::Element *GetCacheElement() const
+ {
+ Cache::Element * const cacheBegin = GetCacheBegin();
+ Cache::Element * const cacheEnd = GetCacheEnd();
+ Cache::Element * const cacheStart = cacheBegin + LastUsedCacheElement();
+
+ // check the last used first, this does no (measurable) harm for a miss
+ // but does help for simple loops addressing the same string all the time
+ if ( cacheStart->str == this )
+ return cacheStart;
+
+ // notice that we're going to check cacheStart again inside this call but
+ // profiling shows that it's still faster to use a simple loop like
+ // inside FindCacheElement() than manually looping with wrapping starting
+ // from the cache entry after the start one
+ Cache::Element *c = FindCacheElement();
+ if ( !c )
+ {
+ // claim the next cache entry for this string
+ c = cacheStart;
+ if ( ++c == cacheEnd )
+ c = cacheBegin;
+
+ c->str = this;
+ c->Reset();
+
+ // and remember the last used element
+ LastUsedCacheElement() = c - cacheBegin;
+ }
+
+ return c;
+ }
+
+ size_t DoPosToImpl(size_t pos) const
+ {
+ wxCACHE_PROFILE_FIELD_INC(postot);
+
+ // NB: although the case of pos == 1 (and offset from cached position
+ // equal to 1) are common, nothing is gained by writing special code
+ // for handling them, the compiler (at least g++ 4.1 used) seems to
+ // optimize the code well enough on its own
+
+ wxCACHE_PROFILE_FIELD_ADD(sumpos, pos);
+
+ Cache::Element * const cache = GetCacheElement();
+
+ // cached position can't be 0 so if it is, it means that this entry was
+ // used for length caching only so far, i.e. it doesn't count as a hit
+ // from our point of view
+ if ( cache->pos )
+ {
+ wxCACHE_PROFILE_FIELD_INC(poshits);
+ }
+
+ if ( pos == cache->pos )
+ return cache->impl;
+
+ // this seems to happen only rarely so just reset the cache in this case
+ // instead of complicating code even further by seeking backwards in this
+ // case
+ if ( cache->pos > pos )
+ {
+ wxCACHE_PROFILE_FIELD_INC(mishits);
+
+ cache->ResetPos();
+ }
+
+ wxCACHE_PROFILE_FIELD_ADD(sumofs, pos - cache->pos);
+
+
+ wxStringImpl::const_iterator i(m_impl.begin() + cache->impl);
+ for ( size_t n = cache->pos; n < pos; n++ )
+ wxStringOperations::IncIter(i);
+
+ cache->pos = pos;
+ cache->impl = i - m_impl.begin();
+
+ wxSTRING_CACHE_ASSERT(
+ (int)cache->impl == (begin() + pos).impl() - m_impl.begin() );
+
+ return cache->impl;
+ }
+
+ void InvalidateCache()
+ {
+ Cache::Element * const cache = FindCacheElement();
+ if ( cache )
+ cache->Reset();
+ }
+
+ void InvalidateCachedLength()
+ {
+ Cache::Element * const cache = FindCacheElement();
+ if ( cache )
+ cache->len = npos;
+ }
+
+ void SetCachedLength(size_t len)
+ {
+ // we optimistically cache the length here even if the string wasn't
+ // present in the cache before, this seems to do no harm and the
+ // potential for avoiding length recomputation for long strings looks
+ // interesting
+ GetCacheElement()->len = len;
+ }
+
+ void UpdateCachedLength(ptrdiff_t delta)
+ {
+ Cache::Element * const cache = FindCacheElement();
+ if ( cache && cache->len != npos )
+ {
+ wxSTRING_CACHE_ASSERT( (ptrdiff_t)cache->len + delta >= 0 );
+
+ cache->len += delta;
+ }
+ }
+
+ #define wxSTRING_INVALIDATE_CACHE() InvalidateCache()
+ #define wxSTRING_INVALIDATE_CACHED_LENGTH() InvalidateCachedLength()
+ #define wxSTRING_UPDATE_CACHED_LENGTH(n) UpdateCachedLength(n)
+ #define wxSTRING_SET_CACHED_LENGTH(n) SetCachedLength(n)
+#else // !wxUSE_STRING_POS_CACHE
+ size_t DoPosToImpl(size_t pos) const
+ {
+ return (begin() + pos).impl() - m_impl.begin();
+ }
+
+ #define wxSTRING_INVALIDATE_CACHE()
+ #define wxSTRING_INVALIDATE_CACHED_LENGTH()
+ #define wxSTRING_UPDATE_CACHED_LENGTH(n)
+ #define wxSTRING_SET_CACHED_LENGTH(n)
+#endif // wxUSE_STRING_POS_CACHE/!wxUSE_STRING_POS_CACHE
+
size_t PosToImpl(size_t pos) const
{
- if ( pos == 0 || pos == npos )
- return pos;
- else
- return (begin() + pos).impl() - m_impl.begin();
+ return pos == 0 || pos == npos ? pos : DoPosToImpl(pos);
}
void PosLenToImpl(size_t pos, size_t len, size_t *implPos, size_t *implLen) const;
typedef size_t size_type;
typedef wxUniChar const_reference;
-#if wxUSE_STL
+#if wxUSE_STD_STRING
#if wxUSE_UNICODE_UTF8
// random access is not O(1), as required by Random Access Iterator
#define WX_STR_ITERATOR_TAG std::bidirectional_iterator_tag
#else
#define WX_STR_ITERATOR_TAG std::random_access_iterator_tag
#endif
+ #define WX_DEFINE_ITERATOR_CATEGORY(cat) typedef cat iterator_category;
#else
- #define WX_STR_ITERATOR_TAG void /* dummy type */
+ // not defining iterator_category at all in this case is better than defining
+ // it as some dummy type -- at least it results in more intelligible error
+ // messages
+ #define WX_DEFINE_ITERATOR_CATEGORY(cat)
#endif
#define WX_STR_ITERATOR_IMPL(iterator_name, pointer_type, reference_type) \
private: \
typedef wxStringImpl::iterator_name underlying_iterator; \
public: \
- typedef WX_STR_ITERATOR_TAG iterator_category; \
+ WX_DEFINE_ITERATOR_CATEGORY(WX_STR_ITERATOR_TAG) \
typedef wxUniChar value_type; \
typedef int difference_type; \
typedef reference_type reference; \
}
reference operator*()
- { return wxUniCharRef::CreateForString(m_node, m_cur); }
+ { return wxUniCharRef::CreateForString(*str(), m_cur); }
iterator operator+(ptrdiff_t n) const
{ return iterator(str(), wxStringOperations::AddToIter(m_cur, n)); }
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); }
+ wxString* str() const { return const_cast<wxString*>(m_node.m_str); }
wxStringIteratorNode m_node;
size_t IterToImplPos(wxString::iterator i) const
{ return wxStringImpl::const_iterator(i.impl()) - m_impl.begin(); }
+ iterator GetIterForNthChar(size_t n)
+ { return iterator(this, m_impl.begin() + PosToImpl(n)); }
+ const_iterator GetIterForNthChar(size_t n) const
+ { return const_iterator(this, m_impl.begin() + PosToImpl(n)); }
#else // !wxUSE_UNICODE_UTF8
class WXDLLIMPEXP_BASE iterator
const_iterator(const wxString *WXUNUSED(str), underlying_iterator ptr)
: m_cur(ptr) {}
};
+
+ iterator GetIterForNthChar(size_t n) { return begin() + n; }
+ const_iterator GetIterForNthChar(size_t n) const { return begin() + n; }
#endif // wxUSE_UNICODE_UTF8/!wxUSE_UNICODE_UTF8
#undef WX_STR_ITERATOR_TAG
public:
typedef T iterator_type;
- typedef typename T::iterator_category iterator_category;
+ WX_DEFINE_ITERATOR_CATEGORY(typename T::iterator_category)
typedef typename T::value_type value_type;
typedef typename T::difference_type difference_type;
typedef typename T::reference reference;
wxString(const wxWCharBuffer& buf)
{ assign(buf.data()); } // FIXME-UTF8: fix for embedded NUL and buffer length
+ // NB: this version uses m_impl.c_str() to force making a copy of the
+ // string, so that "wxString(str.c_str())" idiom for passing strings
+ // between threads works
wxString(const wxCStrData& cstr)
- : m_impl(cstr.AsString().m_impl) { }
+ : m_impl(cstr.AsString().m_impl.c_str()) { }
// as we provide both ctors with this signature for both char and unsigned
// char string, we need to provide one for wxCStrData to resolve ambiguity
wxString(const wxString& str, size_t nLength)
{ assign(str, nLength); }
+
+#if wxUSE_STRING_POS_CACHE
+ ~wxString()
+ {
+ // we need to invalidate our cache entry as another string could be
+ // recreated at the same address (unlikely, but still possible, with the
+ // heap-allocated strings but perfectly common with stack-allocated ones)
+ InvalidateCache();
+ }
+#endif // wxUSE_STRING_POS_CACHE
+
// even if we're not built with wxUSE_STL == 1 it is very convenient to allow
// 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
#endif
#endif // wxUSE_STL
+ wxString Clone() const
+ {
+ // make a deep copy of the string, i.e. the returned string will have
+ // ref count = 1 with refcounted implementation
+ return wxString::FromImpl(wxStringImpl(m_impl.c_str(), m_impl.length()));
+ }
+
// first valid index position
const_iterator begin() const { return const_iterator(this, m_impl.begin()); }
iterator begin() { return iterator(this, m_impl.begin()); }
// std::string methods:
#if wxUSE_UNICODE_UTF8
- size_t length() const { return end() - begin(); } // FIXME-UTF8: optimize!
+ size_t length() const
+ {
+#if wxUSE_STRING_POS_CACHE
+ wxCACHE_PROFILE_FIELD_INC(lentot);
+
+ Cache::Element * const cache = GetCacheElement();
+
+ if ( cache->len == npos )
+ {
+ // it's probably not worth trying to be clever and using cache->pos
+ // here as it's probably 0 anyhow -- you usually call length() before
+ // starting to index the string
+ cache->len = end() - begin();
+ }
+ else
+ {
+ wxCACHE_PROFILE_FIELD_INC(lenhits);
+
+ wxSTRING_CACHE_ASSERT( (int)cache->len == end() - begin() );
+ }
+
+ return cache->len;
+#else // !wxUSE_STRING_POS_CACHE
+ return end() - begin();
+#endif // wxUSE_STRING_POS_CACHE/!wxUSE_STRING_POS_CACHE
+ }
#else
size_t length() const { return m_impl.length(); }
#endif
bool empty() const { return m_impl.empty(); }
- size_type capacity() const { return m_impl.capacity(); } // FIXME-UTF8
- void reserve(size_t sz) { m_impl.reserve(sz); } // FIXME-UTF8
+ // NB: these methods don't have a well-defined meaning in UTF-8 case
+ size_type capacity() const { return m_impl.capacity(); }
+ void reserve(size_t sz) { m_impl.reserve(sz); }
void resize(size_t nSize, wxUniChar ch = wxT('\0'))
{
#if wxUSE_UNICODE_UTF8
if ( nSize < len )
{
+ wxSTRING_INVALIDATE_CACHE();
+
// we can't use wxStringImpl::resize() for truncating the string as it
// counts in bytes, not characters
erase(nSize);
// 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
+ }
+ else // can use (presumably faster) resize() version
#endif // wxUSE_UNICODE_UTF8
+ {
+ wxSTRING_INVALIDATE_CACHED_LENGTH();
+
m_impl.resize(nSize, (wxStringCharType)ch);
+ }
}
wxString substr(size_t nStart = 0, size_t nLen = npos) const
// truncate the string to given length
wxString& Truncate(size_t uiLen);
// empty string contents
- void Empty()
- {
- Truncate(0);
-
- wxASSERT_MSG( empty(), _T("string not empty after call to Empty()?") );
- }
+ void Empty() { clear(); }
// empty the string and free memory
- void Clear()
- {
- wxString tmp(wxEmptyString);
- swap(tmp);
- }
+ void Clear() { clear(); }
// contents test
// Is an ascii value
// data access (all indexes are 0 based)
// read access
wxUniChar at(size_t n) const
- { return *(begin() + n); } // FIXME-UTF8: optimize?
+ { return wxStringOperations::DecodeChar(m_impl.begin() + PosToImpl(n)); }
wxUniChar GetChar(size_t n) const
{ return at(n); }
// read/write access
wxUniCharRef at(size_t n)
- { return *(begin() + n); } // FIXME-UTF8: optimize?
+ { return *GetIterForNthChar(n); }
wxUniCharRef GetWritableChar(size_t n)
{ return at(n); }
// write access
- void SetChar(size_t n, wxUniChar ch)
+ void SetChar(size_t n, wxUniChar ch)
{ at(n) = ch; }
// get last character
{ return at(n); }
#endif // size_t != unsigned int
- // explicit conversion to C string (use this with printf()!)
+
+ /*
+ Overview of wxString conversions, implicit and explicit:
+
+ - wxString has a std::[w]string-like c_str() method, however it does
+ not return a C-style string directly but instead returns wxCStrData
+ helper object which is convertible to either "char *" narrow string
+ or "wchar_t *" wide string. Usually the correct conversion will be
+ applied by the compiler automatically but if this doesn't happen you
+ need to explicitly choose one using wxCStrData::AsChar() or AsWChar()
+ methods or another wxString conversion function.
+
+ - One of the places where the conversion does *NOT* happen correctly is
+ when c_str() is passed to a vararg function such as printf() so you
+ must *NOT* use c_str() with them. Either use wxPrintf() (all wx
+ functions do handle c_str() correctly, even if they appear to be
+ vararg (but they're not, really)) or add an explicit AsChar() or, if
+ compatibility with previous wxWidgets versions is important, add a
+ cast to "const char *".
+
+ - In non-STL mode only, wxString is also implicitly convertible to
+ wxCStrData. The same warning as above applies.
+
+ - c_str() is polymorphic as it can be converted to either narrow or
+ wide string. If you explicitly need one or the other, choose to use
+ mb_str() (for narrow) or wc_str() (for wide) instead. Notice that
+ these functions can return either the pointer to string directly (if
+ this is what the string uses internally) or a temporary buffer
+ containing the string and convertible to it. Again, conversion will
+ usually be done automatically by the compiler but beware of the
+ vararg functions: you need an explicit cast when using them.
+
+ - There are also non-const versions of mb_str() and wc_str() called
+ char_str() and wchar_str(). They are only meant to be used with
+ non-const-correct functions and they always return buffers.
+
+ - Finally wx_str() returns whatever string representation is used by
+ wxString internally. It may be either a narrow or wide string
+ depending on wxWidgets build mode but it will always be a raw pointer
+ (and not a buffer).
+ */
+
+ // explicit conversion to wxCStrData
wxCStrData c_str() const { return wxCStrData(this); }
wxCStrData data() const { return c_str(); }
- // implicit conversion to C string
+ // implicit conversion to wxCStrData
operator wxCStrData() const { return c_str(); }
// the first two operators conflict with operators for conversion to
{ return mb_str(conv); }
wxWritableWCharBuffer wchar_str() const { return wc_str(); }
+ // conversion to the buffer of the given type T (= char or wchar_t) and
+ // also optionally return the buffer length
+ //
+ // this is mostly/only useful for the template functions
+ //
+ // FIXME-VC6: the second argument only exists for VC6 which doesn't support
+ // explicit template function selection, do not use it unless
+ // you must support VC6!
+ template <typename T>
+ wxCharTypeBuffer<T> tchar_str(size_t *len = NULL,
+ T * WXUNUSED(dummy) = NULL) const
+ {
+#if wxUSE_UNICODE
+ // we need a helper dispatcher depending on type
+ return wxPrivate::wxStringAsBufHelper<T>::Get(*this, len);
+#else // ANSI
+ // T can only be char in ANSI build
+ if ( len )
+ *len = length();
+
+ return wxCharTypeBuffer<T>::CreateNonOwned(wx_str());
+#endif // Unicode build kind
+ }
+
// conversion to/from plain (i.e. 7 bit) ASCII: this is useful for
// converting numbers or strings which are certain not to contain special
// chars (typically system functions, X atoms, environment variables etc.)
// conversion to/from UTF-8:
#if wxUSE_UNICODE_UTF8
- static wxString FromUTF8(const char *utf8)
+ static wxString FromUTF8Unchecked(const char *utf8)
{
if ( !utf8 )
return wxEmptyString;
wxASSERT( wxStringOperations::IsValidUtf8String(utf8) );
return FromImpl(wxStringImpl(utf8));
}
- static wxString FromUTF8(const char *utf8, size_t len)
+ static wxString FromUTF8Unchecked(const char *utf8, size_t len)
{
if ( !utf8 )
return wxEmptyString;
if ( len == npos )
- return FromUTF8(utf8);
+ return FromUTF8Unchecked(utf8);
wxASSERT( wxStringOperations::IsValidUtf8String(utf8, len) );
return FromImpl(wxStringImpl(utf8, len));
}
+
+ static wxString FromUTF8(const char *utf8)
+ {
+ if ( !utf8 || !wxStringOperations::IsValidUtf8String(utf8) )
+ return "";
+
+ return FromImpl(wxStringImpl(utf8));
+ }
+ static wxString FromUTF8(const char *utf8, size_t len)
+ {
+ if ( len == npos )
+ return FromUTF8(utf8);
+
+ if ( !utf8 || !wxStringOperations::IsValidUtf8String(utf8, len) )
+ return "";
+
+ return FromImpl(wxStringImpl(utf8, len));
+ }
+
const char* utf8_str() const { return wx_str(); }
const char* ToUTF8() const { return wx_str(); }
+
+ // this function exists in UTF-8 build only and returns the length of the
+ // internal UTF-8 representation
+ size_t utf8_length() const { return m_impl.length(); }
#elif wxUSE_UNICODE_WCHAR
- static wxString FromUTF8(const char *utf8)
- { return wxString(utf8, wxMBConvUTF8()); }
- static wxString FromUTF8(const char *utf8, size_t len)
+ static wxString FromUTF8(const char *utf8, size_t len = npos)
{ return wxString(utf8, wxMBConvUTF8(), len); }
+ static wxString FromUTF8Unchecked(const char *utf8, size_t len = npos)
+ {
+ const wxString s(utf8, wxMBConvUTF8(), len);
+ wxASSERT_MSG( !utf8 || !*utf8 || !s.empty(),
+ "string must be valid UTF-8" );
+ return s;
+ }
const wxCharBuffer utf8_str() const { return mb_str(wxMBConvUTF8()); }
const wxCharBuffer ToUTF8() const { return utf8_str(); }
#else // ANSI
{ return wxString(wxMBConvUTF8().cMB2WC(utf8)); }
static wxString FromUTF8(const char *utf8, size_t len)
{
- size_t wlen;
- wxWCharBuffer buf(wxMBConvUTF8().cMB2WC(utf8, len == npos ? wxNO_LEN : len, &wlen));
- return wxString(buf.data(), wlen);
+ size_t wlen;
+ wxWCharBuffer buf(wxMBConvUTF8().cMB2WC(utf8, len == npos ? wxNO_LEN : len, &wlen));
+ return wxString(buf.data(), wlen);
+ }
+ static wxString FromUTF8Unchecked(const char *utf8, size_t len = npos)
+ {
+ size_t wlen;
+ wxWCharBuffer buf(wxMBConvUTF8().cMB2WC(utf8,
+ len == npos ? wxNO_LEN : len,
+ &wlen));
+ wxASSERT_MSG( !utf8 || !*utf8 || wlen,
+ "string must be valid UTF-8" );
+
+ return wxString(buf.data(), wlen);
}
const wxCharBuffer utf8_str() const
{ return wxMBConvUTF8().cWC2MB(wc_str()); }
const wxWX2MBbuf mbc_str() const { return mb_str(*wxConvCurrent); }
#if wxUSE_UNICODE_WCHAR
- const wxChar* wc_str() const { return wx_str(); }
+ const wchar_t* wc_str() const { return wx_str(); }
#elif wxUSE_UNICODE_UTF8
const wxWCharBuffer wc_str() const;
#endif
const wxChar* mb_str() const { return wx_str(); }
// for compatibility with wxUSE_UNICODE version
- const wxChar* mb_str(const wxMBConv& WXUNUSED(conv)) const { return wx_str(); }
+ const char* mb_str(const wxMBConv& WXUNUSED(conv)) const { return wx_str(); }
const wxWX2MBbuf mbc_str() const { return mb_str(); }
const wxCharBuffer fn_str() const { return wxConvFile.cWC2WX( wc_str( wxConvLibc ) ); }
#endif // Unicode/ANSI
+#if wxUSE_UNICODE_UTF8
+ const wxWCharBuffer t_str() const { return wc_str(); }
+#elif wxUSE_UNICODE_WCHAR
+ const wchar_t* t_str() const { return wx_str(); }
+#else
+ const char* t_str() const { return wx_str(); }
+#endif
+
+
// overloaded assignment
// from another wxString
wxString& operator=(const wxString& stringSrc)
- { if (&stringSrc != this) m_impl = stringSrc.m_impl; return *this; }
+ {
+ if ( this != &stringSrc )
+ {
+ wxSTRING_INVALIDATE_CACHE();
+
+ m_impl = stringSrc.m_impl;
+ }
+
+ return *this;
+ }
+
wxString& operator=(const wxCStrData& cstr)
{ return *this = cstr.AsString(); }
// from a character
wxString& operator=(wxUniChar ch)
- { m_impl = wxStringOperations::EncodeChar(ch); return *this; }
+ {
+ wxSTRING_INVALIDATE_CACHE();
+
+#if wxUSE_UNICODE_UTF8
+ if ( !ch.IsAscii() )
+ m_impl = wxStringOperations::EncodeChar(ch);
+ else
+#endif // wxUSE_UNICODE_UTF8
+ m_impl = (wxStringCharType)ch;
+ return *this;
+ }
+
wxString& operator=(wxUniCharRef ch)
{ return operator=((wxUniChar)ch); }
wxString& operator=(char ch)
// so we need to compensate in that case
#if wxUSE_STL_BASED_WXSTRING
wxString& operator=(const char *psz)
- { if (psz) m_impl = ImplStr(psz); else Clear(); return *this; }
+ {
+ wxSTRING_INVALIDATE_CACHE();
+
+ if ( psz )
+ m_impl = ImplStr(psz);
+ else
+ clear();
+
+ return *this;
+ }
+
wxString& operator=(const wchar_t *pwz)
- { if (pwz) m_impl = ImplStr(pwz); else Clear(); return *this; }
-#else
+ {
+ wxSTRING_INVALIDATE_CACHE();
+
+ if ( pwz )
+ m_impl = ImplStr(pwz);
+ else
+ clear();
+
+ return *this;
+ }
+#else // !wxUSE_STL_BASED_WXSTRING
wxString& operator=(const char *psz)
- { m_impl = ImplStr(psz); return *this; }
+ {
+ wxSTRING_INVALIDATE_CACHE();
+
+ m_impl = ImplStr(psz);
+
+ return *this;
+ }
+
wxString& operator=(const wchar_t *pwz)
- { m_impl = ImplStr(pwz); return *this; }
-#endif
+ {
+ wxSTRING_INVALIDATE_CACHE();
+
+ m_impl = ImplStr(pwz);
+
+ return *this;
+ }
+#endif // wxUSE_STL_BASED_WXSTRING/!wxUSE_STL_BASED_WXSTRING
+
wxString& operator=(const unsigned char *psz)
{ return operator=((const char*)psz); }
{ append(psz); return *this; }
wxString& Append(const wxWCharBuffer& psz)
{ append(psz); return *this; }
+ wxString& Append(const char* psz, size_t nLen)
+ { append(psz, nLen); return *this; }
+ wxString& Append(const wchar_t* pwz, size_t nLen)
+ { append(pwz, nLen); return *this; }
+ wxString& Append(const wxCStrData& psz, size_t nLen)
+ { append(psz, nLen); return *this; }
+ wxString& Append(const wxCharBuffer& psz, size_t nLen)
+ { append(psz, nLen); return *this; }
+ wxString& Append(const wxWCharBuffer& psz, size_t nLen)
+ { append(psz, nLen); return *this; }
// append count copies of given character
wxString& Append(wxUniChar ch, size_t count = 1u)
{ append(count, ch); return *this; }
{ append(count, ch); return *this; }
wxString& Append(wchar_t ch, size_t count = 1u)
{ append(count, ch); return *this; }
- wxString& Append(const char* psz, size_t nLen)
- { append(psz, nLen); return *this; }
- wxString& Append(const wchar_t* pwz, size_t nLen)
- { append(pwz, nLen); return *this; }
// prepend a string, return the string itself
wxString& Prepend(const wxString& str)
const wxChar *fmt = _T("%") wxLongLongFmtSpec _T("u");
return (*this) << Format(fmt , ull);
}
-#endif
+#endif // wxLongLong_t && !wxLongLongIsLong
// insert a float into string
wxString& operator<<(float f)
{ return (*this) << Format(_T("%f"), f); }
wxString Left(size_t nCount) const;
// get last nCount characters
wxString Right(size_t nCount) const;
- // get all characters before the first occurance of ch
+ // get all characters before the first occurrence of ch
// (returns the whole string if ch not found)
wxString BeforeFirst(wxUniChar ch) const;
- // get all characters before the last occurence of ch
+ // get all characters before the last occurrence of ch
// (returns empty string if ch not found)
wxString BeforeLast(wxUniChar ch) const;
- // get all characters after the first occurence of ch
+ // get all characters after the first occurrence of ch
// (returns empty string if ch not found)
wxString AfterFirst(wxUniChar ch) const;
- // get all characters after the last occurence of ch
+ // get all characters after the last occurrence of ch
// (returns the whole string if ch not found)
wxString AfterLast(wxUniChar ch) const;
// convert to upper case in place, return the string itself
wxString& MakeUpper();
// convert to upper case, return the copy of the string
- // Here's something to remember: BC++ doesn't like returns in inlines.
- wxString Upper() const ;
+ wxString Upper() const { return wxString(*this).MakeUpper(); }
// convert to lower case in place, return the string itself
wxString& MakeLower();
// convert to lower case, return the copy of the string
- wxString Lower() const ;
+ wxString Lower() const { return wxString(*this).MakeLower(); }
+ // convert the first character to the upper case and the rest to the
+ // lower one, return the modified string itself
+ wxString& MakeCapitalized();
+ // convert the first character to the upper case and the rest to the
+ // lower one, return the copy of the string
+ wxString Capitalize() const { return wxString(*this).MakeCapitalized(); }
// trimming/padding whitespace (either side) and truncating
// remove spaces from left or from right (default) side
int Find(const wxWCharBuffer& sub) const
{ return Find(sub.data()); }
- // replace first (or all of bReplaceAll) occurences of substring with
+ // replace first (or all of bReplaceAll) occurrences of substring with
// another string, returns the number of replacements made
size_t Replace(const wxString& strOld,
const wxString& strNew,
// raw access to string memory
// ensure that string has space for at least nLen characters
// only works if the data of this string is not shared
- bool Alloc(size_t nLen) { reserve(nLen); /*return capacity() >= nLen;*/ return true; }
+ bool Alloc(size_t nLen) { reserve(nLen); return capacity() >= nLen; }
// minimize the string's memory
// only works if the data of this string is not shared
bool Shrink();
#endif // wxNEEDS_WXSTRING_PRINTF_MIXIN
// use Cmp()
- inline int CompareTo(const wxChar* psz, caseCompare cmp = exact) const
+ int CompareTo(const wxChar* psz, caseCompare cmp = exact) const
{ return cmp == exact ? Cmp(psz) : CmpNoCase(psz); }
// use length()
// append elements str[pos], ..., str[pos+n]
wxString& append(const wxString& str, size_t pos, size_t n)
{
- size_t from, len;
- str.PosLenToImpl(pos, n, &from, &len);
- m_impl.append(str.m_impl, from, len);
- return *this;
+ wxSTRING_UPDATE_CACHED_LENGTH(n);
+
+ size_t from, len;
+ str.PosLenToImpl(pos, n, &from, &len);
+ m_impl.append(str.m_impl, from, len);
+ return *this;
}
// append a string
wxString& append(const wxString& str)
- { m_impl.append(str.m_impl); return *this; }
+ {
+ wxSTRING_UPDATE_CACHED_LENGTH(str.length());
+
+ m_impl.append(str.m_impl);
+ return *this;
+ }
+
// append first n (or all if n == npos) characters of sz
wxString& append(const char *sz)
- { m_impl.append(ImplStr(sz)); return *this; }
+ {
+ wxSTRING_INVALIDATE_CACHED_LENGTH();
+
+ m_impl.append(ImplStr(sz));
+ return *this;
+ }
+
wxString& append(const wchar_t *sz)
- { m_impl.append(ImplStr(sz)); return *this; }
+ {
+ wxSTRING_INVALIDATE_CACHED_LENGTH();
+
+ m_impl.append(ImplStr(sz));
+ return *this;
+ }
+
wxString& append(const char *sz, size_t n)
{
- SubstrBufFromMB str(ImplStr(sz, n));
- m_impl.append(str.data, str.len);
- return *this;
+ wxSTRING_INVALIDATE_CACHED_LENGTH();
+
+ SubstrBufFromMB str(ImplStr(sz, n));
+ m_impl.append(str.data, str.len);
+ return *this;
}
wxString& append(const wchar_t *sz, size_t n)
{
- SubstrBufFromWC str(ImplStr(sz, n));
- m_impl.append(str.data, str.len);
- return *this;
+ wxSTRING_UPDATE_CACHED_LENGTH(n);
+
+ SubstrBufFromWC str(ImplStr(sz, n));
+ m_impl.append(str.data, str.len);
+ return *this;
}
wxString& append(const wxCStrData& str)
{ return append(str.data()); }
wxString& append(const wxWCharBuffer& str)
{ return append(str.data()); }
+ wxString& append(const wxCStrData& str, size_t n)
+ { return append(str.AsString(), 0, n); }
+ wxString& append(const wxCharBuffer& str, size_t n)
+ { return append(str.data(), n); }
+ wxString& append(const wxWCharBuffer& str, size_t n)
+ { return append(str.data(), n); }
// append n copies of ch
wxString& append(size_t n, wxUniChar ch)
{
#if wxUSE_UNICODE_UTF8
- if ( !ch.IsAscii() )
- m_impl.append(wxStringOperations::EncodeNChars(n, ch));
- else
+ if ( !ch.IsAscii() )
+ {
+ wxSTRING_INVALIDATE_CACHED_LENGTH();
+
+ m_impl.append(wxStringOperations::EncodeNChars(n, ch));
+ }
+ else // ASCII
#endif
- m_impl.append(n, (wxStringCharType)ch);
- return *this;
+ {
+ wxSTRING_UPDATE_CACHED_LENGTH(n);
+
+ m_impl.append(n, (wxStringCharType)ch);
+ }
+
+ return *this;
}
+
+ wxString& append(size_t n, wxUniCharRef ch)
+ { return append(n, wxUniChar(ch)); }
+ wxString& append(size_t n, char ch)
+ { return append(n, wxUniChar(ch)); }
+ wxString& append(size_t n, unsigned char ch)
+ { return append(n, wxUniChar(ch)); }
+ wxString& append(size_t n, wchar_t ch)
+ { return append(n, wxUniChar(ch)); }
+
// append from first to last
wxString& append(const_iterator first, const_iterator last)
- { m_impl.append(first.impl(), last.impl()); return *this; }
+ {
+ wxSTRING_INVALIDATE_CACHED_LENGTH();
+
+ m_impl.append(first.impl(), last.impl());
+ return *this;
+ }
#if WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
wxString& append(const char *first, const char *last)
{ return append(first, last - first); }
// same as `this_string = str'
wxString& assign(const wxString& str)
- { m_impl = str.m_impl; return *this; }
+ {
+ wxSTRING_SET_CACHED_LENGTH(str.length());
+
+ m_impl = str.m_impl;
+
+ return *this;
+ }
+
wxString& assign(const wxString& str, size_t len)
{
- m_impl.assign(str.m_impl, 0, str.LenToImpl(len));
- return *this;
+ wxSTRING_SET_CACHED_LENGTH(len);
+
+ m_impl.assign(str.m_impl, 0, str.LenToImpl(len));
+
+ return *this;
}
+
// same as ` = str[pos..pos + n]
wxString& assign(const wxString& str, size_t pos, size_t n)
{
- size_t from, len;
- str.PosLenToImpl(pos, n, &from, &len);
- m_impl.assign(str.m_impl, from, len);
- return *this;
+ size_t from, len;
+ str.PosLenToImpl(pos, n, &from, &len);
+ m_impl.assign(str.m_impl, from, len);
+
+ // it's important to call this after PosLenToImpl() above in case str is
+ // the same string as this one
+ wxSTRING_SET_CACHED_LENGTH(n);
+
+ return *this;
}
+
// same as `= first n (or all if n == npos) characters of sz'
wxString& assign(const char *sz)
- { m_impl.assign(ImplStr(sz)); return *this; }
+ {
+ wxSTRING_INVALIDATE_CACHE();
+
+ m_impl.assign(ImplStr(sz));
+
+ return *this;
+ }
+
wxString& assign(const wchar_t *sz)
- { m_impl.assign(ImplStr(sz)); return *this; }
+ {
+ wxSTRING_INVALIDATE_CACHE();
+
+ m_impl.assign(ImplStr(sz));
+
+ return *this;
+ }
+
wxString& assign(const char *sz, size_t n)
{
- SubstrBufFromMB str(ImplStr(sz, n));
- m_impl.assign(str.data, str.len);
- return *this;
+ wxSTRING_SET_CACHED_LENGTH(n);
+
+ SubstrBufFromMB str(ImplStr(sz, n));
+ m_impl.assign(str.data, str.len);
+
+ return *this;
}
+
wxString& assign(const wchar_t *sz, size_t n)
{
- SubstrBufFromWC str(ImplStr(sz, n));
- m_impl.assign(str.data, str.len);
- return *this;
+ wxSTRING_SET_CACHED_LENGTH(n);
+
+ SubstrBufFromWC str(ImplStr(sz, n));
+ m_impl.assign(str.data, str.len);
+
+ return *this;
}
wxString& assign(const wxCStrData& str)
// same as `= n copies of ch'
wxString& assign(size_t n, wxUniChar ch)
{
+ wxSTRING_SET_CACHED_LENGTH(n);
+
#if wxUSE_UNICODE_UTF8
- if ( !ch.IsAscii() )
- m_impl.assign(wxStringOperations::EncodeNChars(n, ch));
- else
+ if ( !ch.IsAscii() )
+ m_impl.assign(wxStringOperations::EncodeNChars(n, ch));
+ else
#endif
- m_impl.assign(n, (wxStringCharType)ch);
- return *this;
+ m_impl.assign(n, (wxStringCharType)ch);
+
+ return *this;
}
wxString& assign(size_t n, wxUniCharRef ch)
// assign from first to last
wxString& assign(const_iterator first, const_iterator last)
- { m_impl.assign(first.impl(), last.impl()); return *this; }
+ {
+ wxSTRING_INVALIDATE_CACHE();
+
+ m_impl.assign(first.impl(), last.impl());
+
+ return *this;
+ }
#if WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
wxString& assign(const char *first, const char *last)
{ return assign(first, last - first); }
// insert another string
wxString& insert(size_t nPos, const wxString& str)
- { insert(begin() + nPos, str.begin(), str.end()); return *this; }
+ { insert(GetIterForNthChar(nPos), str.begin(), str.end()); return *this; }
// insert n chars of str starting at nStart (in str)
wxString& insert(size_t nPos, const wxString& str, size_t nStart, size_t n)
{
- size_t from, len;
- str.PosLenToImpl(nStart, n, &from, &len);
- m_impl.insert(PosToImpl(nPos), str.m_impl, from, len);
- return *this;
+ wxSTRING_UPDATE_CACHED_LENGTH(n);
+
+ size_t from, len;
+ str.PosLenToImpl(nStart, n, &from, &len);
+ m_impl.insert(PosToImpl(nPos), str.m_impl, from, len);
+
+ return *this;
}
+
// insert first n (or all if n == npos) characters of sz
wxString& insert(size_t nPos, const char *sz)
- { m_impl.insert(PosToImpl(nPos), ImplStr(sz)); return *this; }
+ {
+ wxSTRING_INVALIDATE_CACHE();
+
+ m_impl.insert(PosToImpl(nPos), ImplStr(sz));
+
+ return *this;
+ }
+
wxString& insert(size_t nPos, const wchar_t *sz)
- { m_impl.insert(PosToImpl(nPos), ImplStr(sz)); return *this; }
+ {
+ wxSTRING_INVALIDATE_CACHE();
+
+ m_impl.insert(PosToImpl(nPos), ImplStr(sz)); return *this;
+ }
+
wxString& insert(size_t nPos, const char *sz, size_t n)
{
- SubstrBufFromMB str(ImplStr(sz, n));
- m_impl.insert(PosToImpl(nPos), str.data, str.len);
- return *this;
+ wxSTRING_UPDATE_CACHED_LENGTH(n);
+
+ SubstrBufFromMB str(ImplStr(sz, n));
+ m_impl.insert(PosToImpl(nPos), str.data, str.len);
+
+ return *this;
}
+
wxString& insert(size_t nPos, const wchar_t *sz, size_t n)
{
- SubstrBufFromWC str(ImplStr(sz, n));
- m_impl.insert(PosToImpl(nPos), str.data, str.len);
- return *this;
+ wxSTRING_UPDATE_CACHED_LENGTH(n);
+
+ SubstrBufFromWC str(ImplStr(sz, n));
+ m_impl.insert(PosToImpl(nPos), str.data, str.len);
+
+ return *this;
}
+
// insert n copies of ch
wxString& insert(size_t nPos, size_t n, wxUniChar ch)
{
+ wxSTRING_UPDATE_CACHED_LENGTH(n);
+
#if wxUSE_UNICODE_UTF8
- if ( !ch.IsAscii() )
- m_impl.insert(PosToImpl(nPos), wxStringOperations::EncodeNChars(n, ch));
- else
+ if ( !ch.IsAscii() )
+ m_impl.insert(PosToImpl(nPos), wxStringOperations::EncodeNChars(n, ch));
+ else
#endif
- m_impl.insert(PosToImpl(nPos), n, (wxStringCharType)ch);
- return *this;
+ m_impl.insert(PosToImpl(nPos), n, (wxStringCharType)ch);
+ return *this;
}
+
iterator insert(iterator it, wxUniChar ch)
{
+ wxSTRING_UPDATE_CACHED_LENGTH(1);
+
#if wxUSE_UNICODE_UTF8
- if ( !ch.IsAscii() )
- {
- size_t pos = IterToImplPos(it);
- m_impl.insert(pos, wxStringOperations::EncodeChar(ch));
- return iterator(this, m_impl.begin() + pos);
- }
- else
+ if ( !ch.IsAscii() )
+ {
+ size_t pos = IterToImplPos(it);
+ m_impl.insert(pos, wxStringOperations::EncodeChar(ch));
+ return iterator(this, m_impl.begin() + pos);
+ }
+ else
#endif
- return iterator(this, m_impl.insert(it.impl(), (wxStringCharType)ch));
+ return iterator(this, m_impl.insert(it.impl(), (wxStringCharType)ch));
}
+
void insert(iterator it, const_iterator first, const_iterator last)
- { m_impl.insert(it.impl(), first.impl(), last.impl()); }
+ {
+ wxSTRING_INVALIDATE_CACHE();
+
+ m_impl.insert(it.impl(), first.impl(), last.impl());
+ }
+
#if WXWIN_COMPATIBILITY_STRING_PTR_AS_ITER
void insert(iterator it, const char *first, const char *last)
{ insert(it - begin(), first, last - first); }
void insert(iterator it, size_type n, wxUniChar ch)
{
+ wxSTRING_UPDATE_CACHED_LENGTH(n);
+
#if wxUSE_UNICODE_UTF8
- if ( !ch.IsAscii() )
- m_impl.insert(IterToImplPos(it), wxStringOperations::EncodeNChars(n, ch));
- else
+ if ( !ch.IsAscii() )
+ m_impl.insert(IterToImplPos(it), wxStringOperations::EncodeNChars(n, ch));
+ else
#endif
- m_impl.insert(it.impl(), n, (wxStringCharType)ch);
+ m_impl.insert(it.impl(), n, (wxStringCharType)ch);
}
// delete characters from nStart to nStart + nLen
wxString& erase(size_type pos = 0, size_type n = npos)
{
- size_t from, len;
- PosLenToImpl(pos, n, &from, &len);
- m_impl.erase(from, len);
- return *this;
+ wxSTRING_INVALIDATE_CACHE();
+
+ size_t from, len;
+ PosLenToImpl(pos, n, &from, &len);
+ m_impl.erase(from, len);
+
+ return *this;
}
+
// delete characters from first up to last
iterator erase(iterator first, iterator last)
- { return iterator(this, m_impl.erase(first.impl(), last.impl())); }
+ {
+ wxSTRING_INVALIDATE_CACHE();
+
+ return iterator(this, m_impl.erase(first.impl(), last.impl()));
+ }
+
iterator erase(iterator first)
- { return iterator(this, m_impl.erase(first.impl())); }
+ {
+ wxSTRING_UPDATE_CACHED_LENGTH(-1);
+
+ return iterator(this, m_impl.erase(first.impl()));
+ }
#ifdef wxSTRING_BASE_HASNT_CLEAR
void clear() { erase(); }
#else
- void clear() { m_impl.clear(); }
+ void clear()
+ {
+ wxSTRING_SET_CACHED_LENGTH(0);
+
+ m_impl.clear();
+ }
#endif
// replaces the substring of length nLen starting at nStart
wxString& replace(size_t nStart, size_t nLen, const char* sz)
{
- size_t from, len;
- PosLenToImpl(nStart, nLen, &from, &len);
- m_impl.replace(from, len, ImplStr(sz));
- return *this;
+ wxSTRING_INVALIDATE_CACHE();
+
+ size_t from, len;
+ PosLenToImpl(nStart, nLen, &from, &len);
+ m_impl.replace(from, len, ImplStr(sz));
+
+ return *this;
}
+
wxString& replace(size_t nStart, size_t nLen, const wchar_t* sz)
{
- size_t from, len;
- PosLenToImpl(nStart, nLen, &from, &len);
- m_impl.replace(from, len, ImplStr(sz));
- return *this;
+ wxSTRING_INVALIDATE_CACHE();
+
+ size_t from, len;
+ PosLenToImpl(nStart, nLen, &from, &len);
+ m_impl.replace(from, len, ImplStr(sz));
+
+ return *this;
}
+
// replaces the substring of length nLen starting at nStart
wxString& replace(size_t nStart, size_t nLen, const wxString& str)
{
- size_t from, len;
- PosLenToImpl(nStart, nLen, &from, &len);
- m_impl.replace(from, len, str.m_impl);
- return *this;
+ wxSTRING_INVALIDATE_CACHE();
+
+ size_t from, len;
+ PosLenToImpl(nStart, nLen, &from, &len);
+ m_impl.replace(from, len, str.m_impl);
+
+ return *this;
}
+
// replaces the substring with nCount copies of ch
wxString& replace(size_t nStart, size_t nLen, size_t nCount, wxUniChar ch)
{
- size_t from, len;
- PosLenToImpl(nStart, nLen, &from, &len);
+ wxSTRING_INVALIDATE_CACHE();
+
+ size_t from, len;
+ PosLenToImpl(nStart, nLen, &from, &len);
#if wxUSE_UNICODE_UTF8
- if ( !ch.IsAscii() )
- m_impl.replace(from, len, wxStringOperations::EncodeNChars(nCount, ch));
- else
+ if ( !ch.IsAscii() )
+ m_impl.replace(from, len, wxStringOperations::EncodeNChars(nCount, ch));
+ else
#endif
- m_impl.replace(from, len, nCount, (wxStringCharType)ch);
- return *this;
+ m_impl.replace(from, len, nCount, (wxStringCharType)ch);
+
+ return *this;
}
+
// replaces a substring with another substring
wxString& replace(size_t nStart, size_t nLen,
const wxString& str, size_t nStart2, size_t nLen2)
{
- size_t from, len;
- PosLenToImpl(nStart, nLen, &from, &len);
+ wxSTRING_INVALIDATE_CACHE();
- size_t from2, len2;
- str.PosLenToImpl(nStart2, nLen2, &from2, &len2);
+ size_t from, len;
+ PosLenToImpl(nStart, nLen, &from, &len);
- m_impl.replace(from, len, str.m_impl, from2, len2);
- return *this;
+ size_t from2, len2;
+ str.PosLenToImpl(nStart2, nLen2, &from2, &len2);
+
+ m_impl.replace(from, len, str.m_impl, from2, len2);
+
+ return *this;
}
+
// replaces the substring with first nCount chars of sz
wxString& replace(size_t nStart, size_t nLen,
const char* sz, size_t nCount)
{
- size_t from, len;
- PosLenToImpl(nStart, nLen, &from, &len);
+ wxSTRING_INVALIDATE_CACHE();
- SubstrBufFromMB str(ImplStr(sz, nCount));
+ size_t from, len;
+ PosLenToImpl(nStart, nLen, &from, &len);
- m_impl.replace(from, len, str.data, str.len);
- return *this;
+ SubstrBufFromMB str(ImplStr(sz, nCount));
+
+ m_impl.replace(from, len, str.data, str.len);
+
+ return *this;
}
+
wxString& replace(size_t nStart, size_t nLen,
const wchar_t* sz, size_t nCount)
{
- size_t from, len;
- PosLenToImpl(nStart, nLen, &from, &len);
+ wxSTRING_INVALIDATE_CACHE();
- SubstrBufFromWC str(ImplStr(sz, nCount));
+ size_t from, len;
+ PosLenToImpl(nStart, nLen, &from, &len);
- m_impl.replace(from, len, str.data, str.len);
- return *this;
+ SubstrBufFromWC str(ImplStr(sz, nCount));
+
+ m_impl.replace(from, len, str.data, str.len);
+
+ return *this;
}
+
wxString& replace(size_t nStart, size_t nLen,
const wxString& s, size_t nCount)
{
- size_t from, len;
- PosLenToImpl(nStart, nLen, &from, &len);
- m_impl.replace(from, len, s.m_impl.c_str(), s.LenToImpl(nCount));
- return *this;
+ wxSTRING_INVALIDATE_CACHE();
+
+ size_t from, len;
+ PosLenToImpl(nStart, nLen, &from, &len);
+ m_impl.replace(from, len, s.m_impl.c_str(), s.LenToImpl(nCount));
+
+ return *this;
}
wxString& replace(iterator first, iterator last, const char* s)
- { m_impl.replace(first.impl(), last.impl(), ImplStr(s)); return *this; }
+ {
+ wxSTRING_INVALIDATE_CACHE();
+
+ m_impl.replace(first.impl(), last.impl(), ImplStr(s));
+
+ return *this;
+ }
+
wxString& replace(iterator first, iterator last, const wchar_t* s)
- { m_impl.replace(first.impl(), last.impl(), ImplStr(s)); return *this; }
+ {
+ wxSTRING_INVALIDATE_CACHE();
+
+ m_impl.replace(first.impl(), last.impl(), ImplStr(s));
+
+ return *this;
+ }
+
wxString& replace(iterator first, iterator last, const char* s, size_type n)
{
- SubstrBufFromMB str(ImplStr(s, n));
- m_impl.replace(first.impl(), last.impl(), str.data, str.len);
- return *this;
+ wxSTRING_INVALIDATE_CACHE();
+
+ SubstrBufFromMB str(ImplStr(s, n));
+ m_impl.replace(first.impl(), last.impl(), str.data, str.len);
+
+ return *this;
}
+
wxString& replace(iterator first, iterator last, const wchar_t* s, size_type n)
{
- SubstrBufFromWC str(ImplStr(s, n));
- m_impl.replace(first.impl(), last.impl(), str.data, str.len);
- return *this;
+ wxSTRING_INVALIDATE_CACHE();
+
+ SubstrBufFromWC str(ImplStr(s, n));
+ m_impl.replace(first.impl(), last.impl(), str.data, str.len);
+
+ return *this;
}
+
wxString& replace(iterator first, iterator last, const wxString& s)
- { m_impl.replace(first.impl(), last.impl(), s.m_impl); return *this; }
+ {
+ wxSTRING_INVALIDATE_CACHE();
+
+ m_impl.replace(first.impl(), last.impl(), s.m_impl);
+
+ return *this;
+ }
+
wxString& replace(iterator first, iterator last, size_type n, wxUniChar ch)
{
+ wxSTRING_INVALIDATE_CACHE();
+
#if wxUSE_UNICODE_UTF8
- if ( !ch.IsAscii() )
- m_impl.replace(first.impl(), last.impl(),
- wxStringOperations::EncodeNChars(n, ch));
- else
+ if ( !ch.IsAscii() )
+ m_impl.replace(first.impl(), last.impl(),
+ wxStringOperations::EncodeNChars(n, ch));
+ else
#endif
- m_impl.replace(first.impl(), last.impl(), n, (wxStringCharType)ch);
- return *this;
+ m_impl.replace(first.impl(), last.impl(), n, (wxStringCharType)ch);
+
+ return *this;
}
+
wxString& replace(iterator first, iterator last,
const_iterator first1, const_iterator last1)
{
- m_impl.replace(first.impl(), last.impl(), first1.impl(), last1.impl());
- return *this;
+ wxSTRING_INVALIDATE_CACHE();
+
+ m_impl.replace(first.impl(), last.impl(), first1.impl(), last1.impl());
+
+ return *this;
}
+
wxString& replace(iterator first, iterator last,
const char *first1, const char *last1)
{ replace(first, last, first1, last1 - first1); return *this; }
// swap two strings
void swap(wxString& str)
- { m_impl.swap(str.m_impl); }
+ {
+#if wxUSE_STRING_POS_CACHE
+ // we modify not only this string but also the other one directly so we
+ // need to invalidate cache for both of them (we could also try to
+ // exchange their cache entries but it seems unlikely to be worth it)
+ InvalidateCache();
+ str.InvalidateCache();
+#endif // wxUSE_STRING_POS_CACHE
+
+ m_impl.swap(str.m_impl);
+ }
// find a substring
size_t find(const wxString& str, size_t nStart = 0) const
size_t find(const wxCStrData& s, size_t nStart = 0, size_t n = npos) const
{ return find(s.AsWChar(), nStart, n); }
- // find the first occurence of character ch after nStart
+ // find the first occurrence of character ch after nStart
size_t find(wxUniChar ch, size_t nStart = 0) const
{
- return PosFromImpl(m_impl.find(wxStringOperations::EncodeChar(ch),
- PosToImpl(nStart)));
+#if wxUSE_UNICODE_UTF8
+ if ( !ch.IsAscii() )
+ return PosFromImpl(m_impl.find(wxStringOperations::EncodeChar(ch),
+ PosToImpl(nStart)));
+ else
+#endif
+ return PosFromImpl(m_impl.find((wxStringCharType)ch,
+ PosToImpl(nStart)));
+
}
size_t find(wxUniCharRef ch, size_t nStart = 0) const
{ return find(wxUniChar(ch), nStart); }
// as find, but from the end
size_t rfind(wxUniChar ch, size_t nStart = npos) const
{
- return PosFromImpl(m_impl.rfind(wxStringOperations::EncodeChar(ch),
- PosToImpl(nStart)));
+#if wxUSE_UNICODE_UTF8
+ if ( !ch.IsAscii() )
+ return PosFromImpl(m_impl.rfind(wxStringOperations::EncodeChar(ch),
+ PosToImpl(nStart)));
+ else
+#endif
+ return PosFromImpl(m_impl.rfind((wxStringCharType)ch,
+ PosToImpl(nStart)));
}
size_t rfind(wxUniCharRef ch, size_t nStart = npos) const
{ return rfind(wxUniChar(ch), nStart); }
size_t rfind(wchar_t ch, size_t nStart = npos) const
{ return rfind(wxUniChar(ch), nStart); }
- // find first/last occurence of any character (not) in the set:
+ // find first/last occurrence of any character (not) in the set:
#if wxUSE_STL_BASED_WXSTRING && !wxUSE_UNICODE_UTF8
// FIXME-UTF8: this is not entirely correct, because it doesn't work if
// sizeof(wchar_t)==2 and surrogates are present in the string;
size_t find_last_of(wxUniChar c, size_t nStart = npos) const
{ return rfind(c, nStart); }
- // find first/last occurence of any character not in the set
+ // find first/last occurrence of any character not in the set
// as strspn() (starting from nStart), returns npos on failure
size_t find_first_not_of(const wxString& str, size_t nStart = 0) const
// string += string
wxString& operator+=(const wxString& s)
- { m_impl += s.m_impl; return *this; }
+ {
+ wxSTRING_INVALIDATE_CACHED_LENGTH();
+
+ m_impl += s.m_impl;
+ return *this;
+ }
// string += C string
wxString& operator+=(const char *psz)
- { m_impl += ImplStr(psz); return *this; }
+ {
+ wxSTRING_INVALIDATE_CACHED_LENGTH();
+
+ m_impl += ImplStr(psz);
+ return *this;
+ }
wxString& operator+=(const wchar_t *pwz)
- { m_impl += ImplStr(pwz); return *this; }
+ {
+ wxSTRING_INVALIDATE_CACHED_LENGTH();
+
+ m_impl += ImplStr(pwz);
+ return *this;
+ }
wxString& operator+=(const wxCStrData& s)
- { m_impl += s.AsString().m_impl; return *this; }
+ {
+ wxSTRING_INVALIDATE_CACHED_LENGTH();
+
+ m_impl += s.AsString().m_impl;
+ return *this;
+ }
wxString& operator+=(const wxCharBuffer& s)
{ return operator+=(s.data()); }
wxString& operator+=(const wxWCharBuffer& s)
{ return operator+=(s.data()); }
// string += char
wxString& operator+=(wxUniChar ch)
- { m_impl += wxStringOperations::EncodeChar(ch); return *this; }
+ {
+ wxSTRING_UPDATE_CACHED_LENGTH(1);
+
+#if wxUSE_UNICODE_UTF8
+ if ( !ch.IsAscii() )
+ m_impl += wxStringOperations::EncodeChar(ch);
+ else
+#endif
+ m_impl += (wxStringCharType)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); }
#if !wxUSE_STL_BASED_WXSTRING
// helpers for wxStringBuffer and wxStringBufferLength
wxStringCharType *DoGetWriteBuf(size_t nLen)
- { return m_impl.DoGetWriteBuf(nLen); }
+ {
+ return m_impl.DoGetWriteBuf(nLen);
+ }
+
void DoUngetWriteBuf()
- { m_impl.DoUngetWriteBuf(); }
+ {
+ wxSTRING_INVALIDATE_CACHE();
+
+ m_impl.DoUngetWriteBuf();
+ }
+
void DoUngetWriteBuf(size_t nLen)
- { m_impl.DoUngetWriteBuf(nLen); }
+ {
+ wxSTRING_SET_CACHED_LENGTH(nLen);
+
+ m_impl.DoUngetWriteBuf(nLen);
+ }
#endif // !wxUSE_STL_BASED_WXSTRING
#ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN
// copying is disallowed as it would result in more than one pointer into
// the same linked list
- DECLARE_NO_COPY_CLASS(wxStringIteratorNodeHead)
+ wxDECLARE_NO_COPY_CLASS(wxStringIteratorNodeHead);
};
wxStringIteratorNodeHead m_iterators;
#define wxGetEmptyString() wxString()
+// ----------------------------------------------------------------------------
+// helper functions which couldn't be defined inline
+// ----------------------------------------------------------------------------
+
+namespace wxPrivate
+{
+
+#if wxUSE_UNICODE_WCHAR
+
+template <>
+struct wxStringAsBufHelper<char>
+{
+ static wxCharBuffer Get(const wxString& s, size_t *len)
+ {
+ wxCharBuffer buf(s.mb_str());
+ if ( len )
+ *len = buf ? strlen(buf) : 0;
+ return buf;
+ }
+};
+
+template <>
+struct wxStringAsBufHelper<wchar_t>
+{
+ static wxWCharBuffer Get(const wxString& s, size_t *len)
+ {
+ if ( len )
+ *len = s.length();
+ return wxWCharBuffer::CreateNonOwned(s.wx_str());
+ }
+};
+
+#elif wxUSE_UNICODE_UTF8
+
+template <>
+struct wxStringAsBufHelper<char>
+{
+ static wxCharBuffer Get(const wxString& s, size_t *len)
+ {
+ if ( len )
+ *len = s.utf8_length();
+ return wxCharBuffer::CreateNonOwned(s.wx_str());
+ }
+};
+
+template <>
+struct wxStringAsBufHelper<wchar_t>
+{
+ static wxWCharBuffer Get(const wxString& s, size_t *len)
+ {
+ wxWCharBuffer wbuf(s.wc_str());
+ if ( len )
+ *len = wxWcslen(wbuf);
+ return wbuf;
+ }
+};
+
+#endif // Unicode build kind
+
+} // namespace wxPrivate
+
// ----------------------------------------------------------------------------
// wxStringBuffer: a tiny class allowing to get a writable pointer into string
// ----------------------------------------------------------------------------
wxString& m_str;
wxStringCharType *m_buf;
- DECLARE_NO_COPY_CLASS(wxStringInternalBuffer)
+ wxDECLARE_NO_COPY_CLASS(wxStringInternalBuffer);
};
class wxStringInternalBufferLength
size_t m_len;
bool m_lenSet;
- DECLARE_NO_COPY_CLASS(wxStringInternalBufferLength)
+ wxDECLARE_NO_COPY_CLASS(wxStringInternalBufferLength);
};
#endif // !wxUSE_STL_BASED_WXSTRING
template<typename T>
-class WXDLLIMPEXP_BASE wxStringTypeBufferBase
+class wxStringTypeBufferBase
{
public:
typedef T CharType;
wxStringTypeBufferBase(wxString& str, size_t lenWanted = 1024)
: m_str(str), m_buf(lenWanted)
- { }
-
+ {
+ // for compatibility with old wxStringBuffer which provided direct
+ // access to wxString internal buffer, initialize ourselves with the
+ // string initial contents
+
+ // FIXME-VC6: remove the ugly (CharType *)NULL and use normal
+ // tchar_str<CharType>
+ size_t len;
+ const wxCharTypeBuffer<CharType> buf(str.tchar_str(&len, (CharType *)NULL));
+ if ( buf )
+ {
+ if ( len > lenWanted )
+ {
+ // in this case there is not enough space for terminating NUL,
+ // ensure that we still put it there
+ m_buf.data()[lenWanted] = 0;
+ len = lenWanted - 1;
+ }
+
+ memcpy(m_buf.data(), buf, (len + 1)*sizeof(CharType));
+ }
+ //else: conversion failed, this can happen when trying to get Unicode
+ // string contents into a char string
+ }
operator CharType*() { return m_buf.data(); }
};
template<typename T>
-class WXDLLIMPEXP_BASE wxStringTypeBufferLengthBase
+class wxStringTypeBufferLengthBase : public wxStringTypeBufferBase<T>
{
public:
- typedef T CharType;
-
wxStringTypeBufferLengthBase(wxString& str, size_t lenWanted = 1024)
- : m_str(str), m_buf(lenWanted), m_len(0), m_lenSet(false)
+ : wxStringTypeBufferBase<T>(str, lenWanted),
+ m_len(0),
+ m_lenSet(false)
{ }
- operator CharType*() { return m_buf.data(); }
+ ~wxStringTypeBufferLengthBase()
+ {
+ wxASSERT_MSG( this->m_lenSet, "forgot to call SetLength()" );
+ }
+
void SetLength(size_t length) { m_len = length; m_lenSet = true; }
protected:
- wxString& m_str;
- wxCharTypeBuffer<CharType> m_buf;
- size_t m_len;
- bool m_lenSet;
+ size_t m_len;
+ bool m_lenSet;
};
template<typename T>
{
public:
wxStringTypeBuffer(wxString& str, size_t lenWanted = 1024)
- : wxStringTypeBufferBase<T>(str, lenWanted) {}
+ : wxStringTypeBufferBase<T>(str, lenWanted)
+ { }
+
~wxStringTypeBuffer()
{
this->m_str.assign(this->m_buf.data());
}
- DECLARE_NO_COPY_CLASS(wxStringTypeBuffer)
+ wxDECLARE_NO_COPY_CLASS(wxStringTypeBuffer);
};
template<typename T>
{
public:
wxStringTypeBufferLength(wxString& str, size_t lenWanted = 1024)
- : wxStringTypeBufferLengthBase<T>(str, lenWanted) {}
+ : wxStringTypeBufferLengthBase<T>(str, lenWanted)
+ { }
~wxStringTypeBufferLength()
{
- wxASSERT(this->m_lenSet);
this->m_str.assign(this->m_buf.data(), this->m_len);
}
- DECLARE_NO_COPY_CLASS(wxStringTypeBufferLength)
+ wxDECLARE_NO_COPY_CLASS(wxStringTypeBufferLength);
};
#if wxUSE_STL_BASED_WXSTRING
~wxStringInternalBuffer()
{ m_str.m_impl.assign(m_buf.data()); }
- DECLARE_NO_COPY_CLASS(wxStringInternalBuffer)
+ wxDECLARE_NO_COPY_CLASS(wxStringInternalBuffer);
};
WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE(
~wxStringInternalBufferLength()
{
- wxASSERT(m_lenSet);
m_str.m_impl.assign(m_buf.data(), m_len);
}
- DECLARE_NO_COPY_CLASS(wxStringInternalBufferLength)
+ wxDECLARE_NO_COPY_CLASS(wxStringInternalBufferLength);
};
+
#endif // wxUSE_STL_BASED_WXSTRING
WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxStringTypeBufferBase<char> )
-class WXDLLIMPEXP_BASE wxUTF8StringBuffer : public wxStringTypeBufferBase<char>
+// Note about inlined dtors in the classes below: this is done not for
+// performance reasons but just to avoid linking errors in the MSVC DLL build
+// under Windows: if a class has non-inline methods it must be declared as
+// being DLL-exported but, due to an extremely interesting feature of MSVC 7
+// and later, any template class which is used as a base of a DLL-exported
+// class is implicitly made DLL-exported too, as explained at the bottom of
+// http://msdn.microsoft.com/en-us/library/twa2aw10.aspx (just to confirm: yes,
+// _inheriting_ from a class can change whether it is being exported from DLL)
+//
+// But this results in link errors because the base template class is not DLL-
+// exported, whether it is declared with WXDLLIMPEXP_BASE or not, because it
+// does have only inline functions. So the simplest fix is to just make all the
+// functions of these classes inline too.
+
+class wxUTF8StringBuffer : public wxStringTypeBufferBase<char>
{
public:
wxUTF8StringBuffer(wxString& str, size_t lenWanted = 1024)
: wxStringTypeBufferBase<char>(str, lenWanted) {}
- ~wxUTF8StringBuffer();
+ ~wxUTF8StringBuffer()
+ {
+ wxMBConvStrictUTF8 conv;
+ size_t wlen = conv.ToWChar(NULL, 0, m_buf);
+ wxCHECK_RET( wlen != wxCONV_FAILED, "invalid UTF-8 data in string buffer?" );
- DECLARE_NO_COPY_CLASS(wxUTF8StringBuffer)
+ wxStringInternalBuffer wbuf(m_str, wlen);
+ conv.ToWChar(wbuf, wlen, m_buf);
+ }
+
+ wxDECLARE_NO_COPY_CLASS(wxUTF8StringBuffer);
};
WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxStringTypeBufferLengthBase<char> )
-class WXDLLIMPEXP_BASE wxUTF8StringBufferLength
- : public wxStringTypeBufferLengthBase<char>
+class wxUTF8StringBufferLength : public wxStringTypeBufferLengthBase<char>
{
public:
wxUTF8StringBufferLength(wxString& str, size_t lenWanted = 1024)
: wxStringTypeBufferLengthBase<char>(str, lenWanted) {}
- ~wxUTF8StringBufferLength();
+ ~wxUTF8StringBufferLength()
+ {
+ wxCHECK_RET(m_lenSet, "length not set");
+
+ wxMBConvStrictUTF8 conv;
+ size_t wlen = conv.ToWChar(NULL, 0, m_buf, m_len);
+ wxCHECK_RET( wlen != wxCONV_FAILED, "invalid UTF-8 data in string buffer?" );
- DECLARE_NO_COPY_CLASS(wxUTF8StringBufferLength)
+ wxStringInternalBufferLength wbuf(m_str, wlen);
+ conv.ToWChar(wbuf, wlen, m_buf, m_len);
+ wbuf.SetLength(wlen);
+ }
+
+ wxDECLARE_NO_COPY_CLASS(wxUTF8StringBufferLength);
};
#endif // wxUSE_UNICODE_UTF8/wxUSE_UNICODE_WCHAR
inline wxCStrData::~wxCStrData()
{
if ( m_owned )
- delete wx_const_cast(wxString*, m_str); // cast to silence warnings
+ delete const_cast<wxString*>(m_str); // cast to silence warnings
}
// simple cases for AsChar() and AsWChar(), the complicated ones are
if ( str )
{
m_next = str->m_iterators.ptr;
- wx_const_cast(wxString*, m_str)->m_iterators.ptr = this;
+ const_cast<wxString*>(m_str)->m_iterators.ptr = this;
if ( m_next )
m_next->m_prev = this;
}
if ( m_prev )
m_prev->m_next = m_next;
else if ( m_str ) // first in the list
- wx_const_cast(wxString*, m_str)->m_iterators.ptr = m_next;
+ const_cast<wxString*>(m_str)->m_iterators.ptr = m_next;
m_next = m_prev = NULL;
m_citer = NULL;
#include "wx/crt.h"
#endif
+// ----------------------------------------------------------------------------
+// Checks on wxString characters
+// ----------------------------------------------------------------------------
+
+template<bool (T)(const wxUniChar& c)>
+ inline bool wxStringCheck(const wxString& val)
+ {
+ for ( wxString::const_iterator i = val.begin();
+ i != val.end();
+ ++i )
+ if (T(*i) == 0)
+ return false;
+ return true;
+ }
+
#endif // _WX_WXSTRING_H_
projects / wxWidgets.git / blobdiff