]> git.saurik.com Git - wxWidgets.git/blobdiff - include/wx/arrstr.h
derive wxConfig classes from wxObject and add wxRTTI macros to them (patch 1587607)
[wxWidgets.git] / include / wx / arrstr.h
index 34011d8df7e0355219f5734b67e794934063c79a..95b3519e80b0bd5d357a4086a19af77c9fffcd98 100644 (file)
@@ -27,19 +27,35 @@ typedef wxString _wxArraywxBaseArrayStringBase;
 _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
@@ -92,10 +108,8 @@ public:
 
   // constructors and destructor
     // default ctor
-  wxArrayString()
-      : m_nSize(0), m_nCount(0), m_pItems(NULL), m_autoSort(FALSE)
-      { Init(FALSE); }
-    // if autoSort is TRUE, the array is always sorted (in alphabetical order)
+  wxArrayString() { Init(false); }
+    // if autoSort is true, the array is always sorted (in alphabetical order)
     //
     // NB: the reason for using int and not bool is that like this we can avoid
     //     using this ctor for implicit conversions from "const char *" (which
@@ -103,9 +117,11 @@ public:
     //
     //     of course, using explicit would be even better - if all compilers
     //     supported it...
-  wxArrayString(int autoSort)
-      : m_nSize(0), m_nCount(0), m_pItems(NULL), m_autoSort(FALSE)
-      { Init(autoSort != 0); }
+  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
@@ -151,20 +167,13 @@ public:
       return Item(Count() - 1);
   }
 
-#if WXWIN_COMPATIBILITY_2_4
-    // 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.
-  wxString* GetStringArray() const;
-#endif
 
   // item management
     // Search the element in the array, starting from the beginning if
-    // bFromEnd is FALSE or from end otherwise. If bCase, comparison is case
+    // bFromEnd is false or from end otherwise. If bCase, comparison is case
     // sensitive (default). Returns index of the first item matched or
     // wxNOT_FOUND
-  int  Index (const wxChar *sz, bool bCase = TRUE, bool bFromEnd = FALSE) const;
+  int  Index (const wxChar *sz, bool bCase = true, bool bFromEnd = false) const;
     // add new element at the end (if the array is not sorted), return its
     // index
   size_t Add(const wxString& str, size_t nInsert = 1);
@@ -175,15 +184,12 @@ public:
     // 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
     // sort array elements in alphabetical order (or reversed alphabetical
-    // order if reverseOrder parameter is TRUE)
-  void Sort(bool reverseOrder = FALSE);
+    // order if reverseOrder parameter is true)
+  void Sort(bool reverseOrder = false);
     // sort array elements using specified comparaison function
   void Sort(CompareFunction compareFunction);
   void Sort(CompareFunction2 compareFunction);
@@ -205,7 +211,7 @@ public:
   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;
@@ -223,13 +229,13 @@ public:
     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
@@ -250,15 +256,18 @@ 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; }
-    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)
+    { Init(false); assign(first, last); }
+  wxArrayString(size_type n, const_reference v) { Init(false); assign(n, v); }
   void assign(const_iterator first, const_iterator last);
   void assign(size_type n, const_reference v)
     { clear(); Add(v, n); }
@@ -309,20 +318,45 @@ private:
   size_t  m_nSize,    // current size of the array
           m_nCount;   // current number of elements
 
-  wxChar  **m_pItems; // pointer to data
+  const wxChar  **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
 };
 
 class WXDLLIMPEXP_BASE wxSortedArrayString : public wxArrayString
 {
 public:
-  wxSortedArrayString() : wxArrayString(TRUE)
+  wxSortedArrayString() : wxArrayString(true)
     { }
-  wxSortedArrayString(const wxArrayString& array) : wxArrayString(TRUE)
+  wxSortedArrayString(const wxArrayString& array) : wxArrayString(true)
     { Copy(array); }
 };
 
 #endif // !wxUSE_STL
 
+// this class provides a temporary wxString* from a
+// wxArrayString
+class WXDLLIMPEXP_BASE wxCArrayString
+{
+public:
+    wxCArrayString( const wxArrayString& array )
+        : m_array( array ), m_strings( NULL )
+    { }
+    ~wxCArrayString() { delete[] m_strings; }
+
+    size_t GetCount() const { return m_array.GetCount(); }
+    wxString* GetStrings()
+    {
+        if( m_strings ) return m_strings;
+        size_t count = m_array.GetCount();
+        m_strings = new wxString[count];
+        for( size_t i = 0; i < count; ++i )
+            m_strings[i] = m_array[i];
+        return m_strings;
+    }
+private:
+    const wxArrayString& m_array;
+    wxString* m_strings;
+};
+
 #endif