_WX_DECLARE_BASEARRAY_2(_wxArraywxBaseArrayStringBase, wxBaseArrayStringBase,
wxArray_SortFunction<wxString>,
class WXDLLIMPEXP_BASE);
-WX_DEFINE_USER_EXPORTED_TYPEARRAY(wxString, wxArrayStringBase,
+WX_DEFINE_USER_EXPORTED_TYPEARRAY(wxString, wxArrayStringBase,
wxBaseArrayStringBase, WXDLLIMPEXP_BASE);
-_WX_DEFINE_SORTED_TYPEARRAY_2(wxString, wxSortedArrayStringBase,
+_WX_DEFINE_SORTED_TYPEARRAY_2(wxString, wxSortedArrayStringBase,
wxBaseArrayStringBase, = wxStringSortAscending,
class WXDLLIMPEXP_BASE, CMPFUNCwxString);
class WXDLLIMPEXP_BASE wxArrayString : public wxArrayStringBase
{
public:
+ // type of function used by wxArrayString::Sort()
+ typedef int (wxCMPFUNC_CONV *CompareFunction)(const wxString& first,
+ const wxString& second);
+
wxArrayString() { }
wxArrayString(const wxArrayString& a) : wxArrayStringBase(a) { }
+ wxArrayString(size_t sz, const wxChar** a);
+ wxArrayString(size_t sz, const wxString* a);
int Index(const wxChar* sz, bool bCase = true, bool bFromEnd = false) const;
+
+ void Sort(bool reverseOrder = false);
+ void Sort(CompareFunction function);
+ void Sort(CMPFUNCwxString function) { wxArrayStringBase::Sort(function); }
+
+ size_t Add(const wxString& string, size_t copies = 1)
+ {
+ wxArrayStringBase::Add(string, copies);
+ return size() - copies;
+ }
};
class WXDLLIMPEXP_BASE wxSortedArrayString : public wxSortedArrayStringBase
#else // if !wxUSE_STL
-// ----------------------------------------------------------------------------
-// The string array uses it's knowledge of internal structure of the wxString
-// class to optimize string storage. Normally, we would store pointers to
-// string, but as wxString is, in fact, itself a pointer (sizeof(wxString) is
-// sizeof(char *)) we store these pointers instead. The cast to "wxString *" is
-// really all we need to turn such pointer into a string!
-//
-// Of course, it can be called a dirty hack, but we use twice less memory and
-// this approach is also more speed efficient, so it's probably worth it.
-//
-// Usage notes: when a string is added/inserted, a new copy of it is created,
-// so the original string may be safely deleted. When a string is retrieved
-// from the array (operator[] or Item() method), a reference is returned.
-// ----------------------------------------------------------------------------
-
class WXDLLIMPEXP_BASE wxArrayString
{
public:
// of course, using explicit would be even better - if all compilers
// supported it...
wxArrayString(int autoSort) { Init(autoSort != 0); }
+ // C string array ctor
+ wxArrayString(size_t sz, const wxChar** a);
+ // wxString string array ctor
+ wxArrayString(size_t sz, const wxString* a);
// copy ctor
wxArrayString(const wxArrayString& array);
// assignment operator
wxASSERT_MSG( nIndex < m_nCount,
_T("wxArrayString: index out of bounds") );
- return *(wxString *)&(m_pItems[nIndex]);
+ return m_pItems[nIndex];
}
// same as Item()
return Item(Count() - 1);
}
- // return a wxString[], useful for the controls which
- // take one in their ctor. You must delete[] it yourself
- // once you are done with it. Will return NULL if the
- // ArrayString was empty.
-#if WXWIN_COMPATIBILITY_2_4
- wxString* GetStringArray() const;
-#endif
// item management
// Search the element in the array, starting from the beginning if
// remove first item matching this value
void Remove(const wxChar *sz);
// remove item by index
-#if WXWIN_COMPATIBILITY_2_4
- void Remove(size_t nIndex, size_t nRemove = 1) { RemoveAt(nIndex, nRemove); }
-#endif
void RemoveAt(size_t nIndex, size_t nRemove = 1);
// sorting
typedef int difference_type;
typedef size_t size_type;
- // FIXME: same in dynarray.h
+ // TODO: this code duplicates the one in dynarray.h
class reverse_iterator
{
typedef wxString value_type;
reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { }
reference operator*() const { return *m_ptr; }
pointer operator->() const { return m_ptr; }
- itor operator++() { --m_ptr; return *this; }
- itor operator++(int)
+ itor& operator++() { --m_ptr; return *this; }
+ const itor operator++(int)
{ reverse_iterator tmp = *this; --m_ptr; return tmp; }
- itor operator--() { ++m_ptr; return *this; }
- itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; }
- bool operator ==(const itor& it) { return m_ptr == it.m_ptr; }
- bool operator !=(const itor& it) { return m_ptr != it.m_ptr; }
+ itor& operator--() { ++m_ptr; return *this; }
+ const itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; }
+ bool operator ==(const itor& it) const { return m_ptr == it.m_ptr; }
+ bool operator !=(const itor& it) const { return m_ptr != it.m_ptr; }
};
class const_reverse_iterator
const_reverse_iterator(const reverse_iterator& it) : m_ptr(it.m_ptr) { }
reference operator*() const { return *m_ptr; }
pointer operator->() const { return m_ptr; }
- itor operator++() { --m_ptr; return *this; }
- itor operator++(int)
+ itor& operator++() { --m_ptr; return *this; }
+ const itor operator++(int)
{ itor tmp = *this; --m_ptr; return tmp; }
- itor operator--() { ++m_ptr; return *this; }
- itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; }
- bool operator ==(const itor& it) { return m_ptr == it.m_ptr; }
- bool operator !=(const itor& it) { return m_ptr != it.m_ptr; }
+ itor& operator--() { ++m_ptr; return *this; }
+ const itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; }
+ bool operator ==(const itor& it) const { return m_ptr == it.m_ptr; }
+ bool operator !=(const itor& it) const { return m_ptr != it.m_ptr; }
};
wxArrayString(const_iterator first, const_iterator last)
{ clear(); Add(v, n); }
reference back() { return *(end() - 1); }
const_reference back() const { return *(end() - 1); }
- iterator begin() { return (wxString *)&(m_pItems[0]); }
- const_iterator begin() const { return (wxString *)&(m_pItems[0]); }
+ iterator begin() { return m_pItems; }
+ const_iterator begin() const { return m_pItems; }
size_type capacity() const { return m_nSize; }
void clear() { Clear(); }
bool empty() const { return IsEmpty(); }
private:
void Grow(size_t nIncrement = 0); // makes array bigger if needed
- void Free(); // free all the strings stored
void DoSort(); // common part of all Sort() variants
size_t m_nSize, // current size of the array
m_nCount; // current number of elements
- wxChar **m_pItems; // pointer to data
+ wxString *m_pItems; // pointer to data
bool m_autoSort; // if true, keep the array always sorted
};
wxString* m_strings;
};
-#endif
+
+// ----------------------------------------------------------------------------
+// helper functions for working with arrays
+// ----------------------------------------------------------------------------
+
+// by default, these functions use the escape character to escape the
+// separators occuring inside the string to be joined, this can be disabled by
+// passing '\0' as escape
+
+WXDLLIMPEXP_BASE wxString wxJoin(const wxArrayString& arr,
+ const wxChar sep,
+ const wxChar escape = wxT('\\'));
+
+WXDLLIMPEXP_BASE wxArrayString wxSplit(const wxString& str,
+ const wxChar sep,
+ const wxChar escape = wxT('\\'));
+
+#endif // _WX_ARRSTR_H
projects / wxWidgets.git / blobdiff