no changes, just remove #if'd out code

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

diff --git a/include/wx/arrstr.h b/include/wx/arrstr.h
index 7c7b29290c8b4d92b01173c42e0071f6ce47fe61..a9e6f86f0473f53bc5f32b2f79cf690b968cd4a8 100644 (file)
--- a/include/wx/arrstr.h
+++ b/include/wx/arrstr.h
@@ -15,8 +15,18 @@
 #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_STL
 


@@ -42,7 +52,8 @@ 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 char** a);
+    wxArrayString(size_t sz, const wchar_t** a);

     wxArrayString(size_t sz, const wxString* a);
 
     int Index(const wxString& str, bool bCase = true, bool bFromEnd = false) const;
     wxArrayString(size_t sz, const wxString* a);
 
     int Index(const wxString& str, bool bCase = true, bool bFromEnd = false) const;


@@ -80,6 +91,22 @@ public:
 
 #else // if !wxUSE_STL
 
 
 #else // if !wxUSE_STL
 

+// 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
 {
 public:
 class WXDLLIMPEXP_BASE wxArrayString
 {
 public:


@@ -176,7 +203,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);
 


@@ -254,7 +281,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); }


@@ -284,12 +330,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


@@ -298,8 +353,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
 


@@ -339,6 +392,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;


@@ -361,4 +422,81 @@ WXDLLIMPEXP_BASE wxArrayString wxSplit(const wxString& str,
                                        const wxChar sep,
                                        const wxChar escape = wxT('\\'));
 
                                        const wxChar sep,
                                        const wxChar escape = wxT('\\'));
 

+
+// ----------------------------------------------------------------------------
+// This helper class allows to pass both C array of wxStrings or wxArrayString
+// using the same interface.
+//
+// Use it when you have two methods taking wxArrayString or (int, wxString[]),
+// that do the same thing. This class lets you iterate over input data in the
+// same way whether it is a raw array of strings or wxArrayString.
+//
+// The object does not take ownership of the data -- internally it keeps
+// pointers to the data, therefore the data must be disposed of by user
+// and only after this object is destroyed. Usually it is not a problem as
+// only temporary objects of this class are used.
+// ----------------------------------------------------------------------------
+
+class wxArrayStringsAdapter
+{
+public:
+    // construct an adapter from a wxArrayString
+    wxArrayStringsAdapter(const wxArrayString& strings)
+        : m_type(wxSTRING_ARRAY), m_size(strings.size())
+    {
+        m_data.array = &strings;
+    }
+
+    // construct an adapter from a wxString[]
+    wxArrayStringsAdapter(unsigned int n, const wxString *strings)
+        : m_type(wxSTRING_POINTER), m_size(n)
+    {
+        m_data.ptr = strings;
+    }
+
+    // construct an adapter from a single wxString
+    wxArrayStringsAdapter(const wxString& s)
+        : m_type(wxSTRING_POINTER), m_size(1)
+    {
+        m_data.ptr = &s;
+    }
+
+    // default copy constructor is ok
+
+    // iteration interface
+    size_t GetCount() const { return m_size; }
+    bool IsEmpty() const { return GetCount() == 0; }
+    const wxString& operator[] (unsigned int i) const
+    {
+        wxASSERT_MSG( i < GetCount(), wxT("index out of bounds") );
+        if(m_type == wxSTRING_POINTER)
+            return m_data.ptr[i];
+        return m_data.array->Item(i);
+    }
+    wxArrayString AsArrayString() const
+    {
+        if(m_type == wxSTRING_ARRAY)
+            return *m_data.array;
+        return wxArrayString(GetCount(), m_data.ptr);
+    }
+
+private:
+    // type of the data being held
+    enum wxStringContainerType
+    {
+        wxSTRING_ARRAY,  // wxArrayString
+        wxSTRING_POINTER // wxString[]
+    };
+
+    wxStringContainerType m_type;
+    size_t m_size;
+    union
+    {
+        const wxString *      ptr;
+        const wxArrayString * array;
+    } m_data;
+
+    wxDECLARE_NO_ASSIGN_CLASS(wxArrayStringsAdapter);
+};
+

 #endif // _WX_ARRSTR_H
 #endif // _WX_ARRSTR_H