added copy ctor to wxCStrData to fix crashes when passing to vararg functions

[wxWidgets.git] / include / wx / arrstr.h

diff --git a/include/wx/arrstr.h b/include/wx/arrstr.h
index 11f32a466f21cfa7ac48d683be1efd5bd72bf094..4ce526be62e43ceff6b109577a5806d65843ceab 100644 (file)
--- a/include/wx/arrstr.h
+++ b/include/wx/arrstr.h
@@ -27,9 +27,9 @@ typedef wxString _wxArraywxBaseArrayStringBase;
 _WX_DECLARE_BASEARRAY_2(_wxArraywxBaseArrayStringBase, wxBaseArrayStringBase,
                         wxArray_SortFunction<wxString>,
                         class WXDLLIMPEXP_BASE);
 _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);
                                   wxBaseArrayStringBase, WXDLLIMPEXP_BASE);

-_WX_DEFINE_SORTED_TYPEARRAY_2(wxString, wxSortedArrayStringBase, 
+_WX_DEFINE_SORTED_TYPEARRAY_2(wxString, wxSortedArrayStringBase,

                               wxBaseArrayStringBase, = wxStringSortAscending,
                               class WXDLLIMPEXP_BASE, CMPFUNCwxString);
 
                               wxBaseArrayStringBase, = wxStringSortAscending,
                               class WXDLLIMPEXP_BASE, CMPFUNCwxString);
 


@@ -42,11 +42,20 @@ public:
 
     wxArrayString() { }
     wxArrayString(const wxArrayString& a) : wxArrayStringBase(a) { }
 
     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);
 
     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
 };
 
 class WXDLLIMPEXP_BASE wxSortedArrayString : public wxSortedArrayStringBase


@@ -71,21 +80,6 @@ public:
 
 #else // if !wxUSE_STL
 
 
 #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:
 class WXDLLIMPEXP_BASE wxArrayString
 {
 public:


@@ -109,6 +103,10 @@ public:
     //     of course, using explicit would be even better - if all compilers
     //     supported it...
   wxArrayString(int autoSort) { Init(autoSort != 0); }
     //     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
     // copy ctor
   wxArrayString(const wxArrayString& array);
     // assignment operator


@@ -141,7 +139,7 @@ public:
         wxASSERT_MSG( nIndex < m_nCount,
                       _T("wxArrayString: index out of bounds") );
 
         wxASSERT_MSG( nIndex < m_nCount,
                       _T("wxArrayString: index out of bounds") );
 

-        return *(wxString *)&(m_pItems[nIndex]);
+        return m_pItems[nIndex];

     }
 
     // same as Item()
     }
 
     // same as Item()


@@ -151,16 +149,9 @@ public:
   {
       wxASSERT_MSG( !IsEmpty(),
                     _T("wxArrayString: index out of bounds") );
   {
       wxASSERT_MSG( !IsEmpty(),
                     _T("wxArrayString: index out of bounds") );

-      return Item(Count() - 1);
+      return Item(GetCount() - 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
 
   // item management
     // Search the element in the array, starting from the beginning if


@@ -178,9 +169,6 @@ public:
     // remove first item matching this value
   void Remove(const wxChar *sz);
     // remove item by index
     // 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
   void RemoveAt(size_t nIndex, size_t nRemove = 1);
 
   // sorting


@@ -208,7 +196,7 @@ public:
   typedef int difference_type;
   typedef size_t size_type;
 
   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;
   class reverse_iterator
   {
     typedef wxString value_type;


@@ -226,13 +214,13 @@ public:
     reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { }
     reference operator*() const { return *m_ptr; }
     pointer operator->() const { return m_ptr; }
     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; }
       { 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
   };
 
   class const_reverse_iterator


@@ -253,13 +241,13 @@ public:
     const_reverse_iterator(const reverse_iterator& it) : m_ptr(it.m_ptr) { }
     reference operator*() const { return *m_ptr; }
     pointer operator->() const { return m_ptr; }
     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 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)
   };
 
   wxArrayString(const_iterator first, const_iterator last)


@@ -270,8 +258,8 @@ public:
     { clear(); Add(v, n); }
   reference back() { return *(end() - 1); }
   const_reference back() const { return *(end() - 1); }
     { 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(); }
   size_type capacity() const { return m_nSize; }
   void clear() { Clear(); }
   bool empty() const { return IsEmpty(); }


@@ -308,14 +296,13 @@ protected:
 
 private:
   void Grow(size_t nIncrement = 0);     // makes array bigger if needed
 
 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
 
 
   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
 };
 
   bool    m_autoSort; // if true, keep the array always sorted
 };


@@ -356,4 +343,21 @@ private:
     wxString* m_strings;
 };
 
     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