supporting clang memory management annotations

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

diff --git a/include/wx/arrstr.h b/include/wx/arrstr.h
index 55de7f04f00ba14be721262bd6105521b7349c89..49f5f21d920e1a17b0aa4dc3d0b1b42e2632f0b3 100644 (file)
--- a/include/wx/arrstr.h
+++ b/include/wx/arrstr.h
@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////

-// Name:        include/wx/arrstr.h
+// Name:        wx/arrstr.h

 // Purpose:     wxArrayString class
 // Author:      Mattia Barbon and Vadim Zeitlin
 // Modified by:
 // Purpose:     wxArrayString class
 // Author:      Mattia Barbon and Vadim Zeitlin
 // Modified by:


@@ -15,10 +15,20 @@
 #include "wx/defs.h"
 #include "wx/string.h"
 
 #include "wx/defs.h"
 #include "wx/string.h"
 

-WXDLLIMPEXP_BASE int wxCMPFUNC_CONV wxStringSortAscending(wxString*, wxString*);
-WXDLLIMPEXP_BASE int wxCMPFUNC_CONV wxStringSortDescending(wxString*, wxString*);
+// these functions are only used in STL build now but we define them in any
+// case for compatibility with the existing code outside of the library which
+// could be using them
+inline int wxCMPFUNC_CONV wxStringSortAscending(wxString* s1, wxString* s2)
+{
+    return s1->Cmp(*s2);
+}
+
+inline int wxCMPFUNC_CONV wxStringSortDescending(wxString* s1, wxString* s2)
+{
+    return wxStringSortAscending(s2, s1);
+}

 
 

-#if wxUSE_STL
+#if wxUSE_STD_CONTAINERS

 
 #include "wx/dynarray.h"
 
 
 #include "wx/dynarray.h"
 


@@ -77,9 +87,36 @@ public:
     }
 
     int Index(const wxString& str, bool bCase = true, bool bFromEnd = false) const;
     }
 
     int Index(const wxString& str, bool bCase = true, bool bFromEnd = false) const;

+
+private:
+    void Insert()
+    {
+        wxFAIL_MSG( "wxSortedArrayString::Insert() is not to be used" );
+    }
+
+    void Sort()
+    {
+        wxFAIL_MSG( "wxSortedArrayString::Sort() is not to be used" );
+    }

 };
 
 };
 

-#else // if !wxUSE_STL
+#else // if !wxUSE_STD_CONTAINERS
+
+// this shouldn't be defined for compilers not supporting template methods or
+// without std::distance()
+//
+// FIXME-VC6: currently it's only not defined for VC6 in DLL build as it
+//            doesn't export template methods from DLL correctly so even though
+//            it compiles them fine, we get link errors when using wxArrayString
+#if !defined(__VISUALC6__) || !(defined(WXMAKINGDLL) || defined(WXUSINGDLL))
+    #define wxHAS_VECTOR_TEMPLATE_ASSIGN
+#endif
+
+#ifdef wxHAS_VECTOR_TEMPLATE_ASSIGN
+    #include "wx/beforestd.h"
+    #include <iterator>
+    #include "wx/afterstd.h"
+#endif // wxHAS_VECTOR_TEMPLATE_ASSIGN

 
 class WXDLLIMPEXP_BASE wxArrayString
 {
 
 class WXDLLIMPEXP_BASE wxArrayString
 {


@@ -99,11 +136,11 @@ public:
     //
     // 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
     //
     // 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

-    //     we'd like to be implicitly converted to wxString instead!)
-    //
-    //     of course, using explicit would be even better - if all compilers
-    //     supported it...
-  wxArrayString(int autoSort) { Init(autoSort != 0); }
+    //     we'd like to be implicitly converted to wxString instead!). This
+    //     wouldn't be needed if the 'explicit' keyword was supported by all
+    //     compilers, or if this was protected ctor for wxSortedArrayString,
+    //     but we're stuck with it now.
+  wxEXPLICIT wxArrayString(int autoSort) { Init(autoSort != 0); }

     // C string array ctor
   wxArrayString(size_t sz, const char** a);
   wxArrayString(size_t sz, const wchar_t** a);
     // C string array ctor
   wxArrayString(size_t sz, const char** a);
   wxArrayString(size_t sz, const wchar_t** a);


@@ -136,23 +173,26 @@ public:
 
   // items access (range checking is done in debug version)
     // get item at position uiIndex
 
   // items access (range checking is done in debug version)
     // get item at position uiIndex

-  wxString& Item(size_t nIndex) const
+  wxString& Item(size_t nIndex)

     {
         wxASSERT_MSG( nIndex < m_nCount,
     {
         wxASSERT_MSG( nIndex < m_nCount,

-                      _T("wxArrayString: index out of bounds") );
+                      wxT("wxArrayString: index out of bounds") );

 
         return m_pItems[nIndex];
     }
 
         return m_pItems[nIndex];
     }

+  const wxString& Item(size_t nIndex) const { return const_cast<wxArrayString*>(this)->Item(nIndex); }

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

-  wxString& operator[](size_t nIndex) const { return Item(nIndex); }
+  wxString& operator[](size_t nIndex) { return Item(nIndex); }
+  const wxString& operator[](size_t nIndex) const { return Item(nIndex); }

     // get last item
     // get last item

-  wxString& Last() const
+  wxString& Last()

   {
       wxASSERT_MSG( !IsEmpty(),
   {
       wxASSERT_MSG( !IsEmpty(),

-                    _T("wxArrayString: index out of bounds") );
+                    wxT("wxArrayString: index out of bounds") );

       return Item(GetCount() - 1);
   }
       return Item(GetCount() - 1);
   }

+  const wxString& Last() const { return const_cast<wxArrayString*>(this)->Last(); }

 
 
   // item management
 
 
   // item management


@@ -177,7 +217,7 @@ public:
     // sort array elements in alphabetical order (or reversed alphabetical
     // order if reverseOrder parameter is true)
   void Sort(bool reverseOrder = false);
     // sort array elements in alphabetical order (or reversed alphabetical
     // order if reverseOrder parameter is true)
   void Sort(bool reverseOrder = false);

-    // sort array elements using specified comparaison function
+    // sort array elements using specified comparison function

   void Sort(CompareFunction compareFunction);
   void Sort(CompareFunction2 compareFunction);
 
   void Sort(CompareFunction compareFunction);
   void Sort(CompareFunction2 compareFunction);
 


@@ -212,7 +252,7 @@ public:
   public:
     pointer m_ptr;
     reverse_iterator() : m_ptr(NULL) { }
   public:
     pointer m_ptr;
     reverse_iterator() : m_ptr(NULL) { }

-    reverse_iterator(pointer ptr) : m_ptr(ptr) { }
+    wxEXPLICIT reverse_iterator(pointer ptr) : m_ptr(ptr) { }

     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; }


@@ -238,7 +278,7 @@ public:
   public:
     pointer m_ptr;
     const_reverse_iterator() : m_ptr(NULL) { }
   public:
     pointer m_ptr;
     const_reverse_iterator() : m_ptr(NULL) { }

-    const_reverse_iterator(pointer ptr) : m_ptr(ptr) { }
+    wxEXPLICIT const_reverse_iterator(pointer ptr) : m_ptr(ptr) { }

     const_reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { }
     const_reverse_iterator(const reverse_iterator& it) : m_ptr(it.m_ptr) { }
     reference operator*() const { return *m_ptr; }
     const_reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { }
     const_reverse_iterator(const reverse_iterator& it) : m_ptr(it.m_ptr) { }
     reference operator*() const { return *m_ptr; }


@@ -255,7 +295,26 @@ public:
   wxArrayString(const_iterator first, const_iterator last)
     { Init(false); assign(first, last); }
   wxArrayString(size_type n, const_reference v) { Init(false); assign(n, v); }
   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);
+
+#ifdef wxHAS_VECTOR_TEMPLATE_ASSIGN
+  template <class Iterator>
+  void assign(Iterator first, Iterator last)
+  {
+      clear();
+      reserve(std::distance(first, last));
+      for(; first != last; ++first)
+          push_back(*first);
+  }
+#else // !wxHAS_VECTOR_TEMPLATE_ASSIGN
+  void assign(const_iterator first, const_iterator last)
+  {
+      clear();
+      reserve(last - first);
+      for(; first != last; ++first)
+          push_back(*first);
+  }
+#endif // wxHAS_VECTOR_TEMPLATE_ASSIGN/!wxHAS_VECTOR_TEMPLATE_ASSIGN
+

   void assign(size_type n, const_reference v)
     { clear(); Add(v, n); }
   reference back() { return *(end() - 1); }
   void assign(size_type n, const_reference v)
     { clear(); Add(v, n); }
   reference back() { return *(end() - 1); }


@@ -285,12 +344,21 @@ public:
   void pop_back() { RemoveAt(GetCount() - 1); }
   void push_back(const_reference v) { Add(v); }
   reverse_iterator rbegin() { return reverse_iterator(end() - 1); }
   void pop_back() { RemoveAt(GetCount() - 1); }
   void push_back(const_reference v) { Add(v); }
   reverse_iterator rbegin() { return reverse_iterator(end() - 1); }

-  const_reverse_iterator rbegin() const;
+  const_reverse_iterator rbegin() const
+    { return const_reverse_iterator(end() - 1); }

   reverse_iterator rend() { return reverse_iterator(begin() - 1); }
   reverse_iterator rend() { return reverse_iterator(begin() - 1); }

-  const_reverse_iterator rend() const;
+  const_reverse_iterator rend() const
+    { return const_reverse_iterator(begin() - 1); }

   void reserve(size_type n) /* base::reserve*/;
   void resize(size_type n, value_type v = value_type());
   size_type size() const { return GetCount(); }
   void reserve(size_type n) /* base::reserve*/;
   void resize(size_type n, value_type v = value_type());
   size_type size() const { return GetCount(); }

+  void swap(wxArrayString& other)
+  {
+      wxSwap(m_nSize, other.m_nSize);
+      wxSwap(m_nCount, other.m_nCount);
+      wxSwap(m_pItems, other.m_pItems);
+      wxSwap(m_autoSort, other.m_autoSort);
+  }

 
 protected:
   void Init(bool autoSort);             // common part of all ctors
 
 protected:
   void Init(bool autoSort);             // common part of all ctors


@@ -299,8 +367,6 @@ 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 DoSort();                        // common part of all Sort() variants
-

   size_t  m_nSize,    // current size of the array
           m_nCount;   // current number of elements
 
   size_t  m_nSize,    // current size of the array
           m_nCount;   // current number of elements
 


@@ -318,7 +384,7 @@ public:
     { Copy(array); }
 };
 
     { Copy(array); }
 };
 

-#endif // !wxUSE_STL
+#endif // !wxUSE_STD_CONTAINERS

 
 // this class provides a temporary wxString* from a
 // wxArrayString
 
 // this class provides a temporary wxString* from a
 // wxArrayString


@@ -340,6 +406,14 @@ public:
             m_strings[i] = m_array[i];
         return m_strings;
     }
             m_strings[i] = m_array[i];
         return m_strings;
     }

+
+    wxString* Release()
+    {
+        wxString *r = GetStrings();
+        m_strings = NULL;
+        return r;
+    }
+

 private:
     const wxArrayString& m_array;
     wxString* m_strings;
 private:
     const wxArrayString& m_array;
     wxString* m_strings;


@@ -436,7 +510,7 @@ private:
         const wxArrayString * array;
     } m_data;
 
         const wxArrayString * array;
     } m_data;
 

-    DECLARE_NO_ASSIGN_CLASS(wxArrayStringsAdapter)
+    wxDECLARE_NO_ASSIGN_CLASS(wxArrayStringsAdapter);

 };
 
 #endif // _WX_ARRSTR_H
 };
 
 #endif // _WX_ARRSTR_H