ambiguous operator[] access

[wxWidgets.git] / src / common / dynarray.cpp

diff --git a/src/common/dynarray.cpp b/src/common/dynarray.cpp
index 7224e1db539af578934e89d239596f5c23862902..ef5203fc9f891cdc583e62d336d878a70a9ce80b 100644 (file)
--- a/src/common/dynarray.cpp
+++ b/src/common/dynarray.cpp
@@ -13,7 +13,7 @@
 // headers
 // ============================================================================
 
-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
 #pragma implementation "dynarray.h"
 #endif
 
@@ -78,28 +78,29 @@ int name::Index(T lItem, bool bFromEnd) const                               \
 }                                                                           \
                                                                             \
 /* add item assuming the array is sorted with fnCompare function */         \
-void name::Add(T lItem, CMPFUNC fnCompare)                                  \
+size_t name::Add(T lItem, CMPFUNC fnCompare)                                \
 {                                                                           \
-  Insert(lItem, IndexForInsert(lItem, fnCompare));                          \
-}                                                                           \
-                                                                            \
+  size_t idx = IndexForInsert(lItem, fnCompare);                            \
+  Insert(lItem, idx);                                                       \
+  return idx;                                                               \
+}
 
 #if wxUSE_STL
 
 #define _WX_DEFINE_BASEARRAY_NOCOMMON(T, name)                              \
 size_t name::IndexForInsert(T lItem, CMPFUNC fnCompare) const               \
 {                                                                           \
-    Predicate p(fnCompare);                                                 \
+    Predicate p((SCMPFUNC)fnCompare);                                       \
     const_iterator it = std::lower_bound(begin(), end(), lItem, p);         \
     return it - begin();                                                    \
 }                                                                           \
                                                                             \
 int name::Index(T lItem, CMPFUNC fnCompare) const                           \
 {                                                                           \
-    size_t n = IndexForInsert(lItem, fnCompare);                            \
-                                                                            \
-    return (n >= size() ||                                                  \
-           (*fnCompare)(&lItem, &(*this)[n])) ? wxNOT_FOUND : (int)n;       \
+    Predicate p((SCMPFUNC)fnCompare);                                       \
+    const_iterator it = std::lower_bound(begin(), end(), lItem, p);         \
+    return (it != end() &&                                                  \
+            p(lItem, *it)) ? (int)(it - begin()) : wxNOT_FOUND;             \
 }                                                                           \
                                                                             \
 void name::Shrink()                                                         \
@@ -378,6 +379,36 @@ void name::Remove(T lItem)                                                  \
 void name::Sort(CMPFUNC fCmp)                                               \
 {                                                                           \
   qsort(m_pItems, m_nCount, sizeof(T), fCmp);                               \
+}                                                                           \
+                                                                            \
+void name::assign(const_iterator first, const_iterator last)                \
+{                                                                           \
+  clear();                                                                  \
+  reserve(last - first);                                                    \
+  for(; first != last; ++first)                                             \
+    push_back(*first);                                                      \
+}                                                                           \
+                                                                            \
+void name::assign(size_type n, const_reference v)                           \
+{                                                                           \
+  clear();                                                                  \
+  reserve(n);                                                               \
+  for( size_type i = 0; i < n; ++i )                                        \
+    push_back(v);                                                           \
+}                                                                           \
+                                                                            \
+void name::insert(iterator it, const_iterator first, const_iterator last)   \
+{                                                                           \
+  size_t nInsert = last - first, nIndex = it - begin();                     \
+  if (nInsert == 0)                                                         \
+      return;                                                               \
+  Grow(nInsert);                                                            \
+                                                                            \
+  memmove(&m_pItems[nIndex + nInsert], &m_pItems[nIndex],                   \
+          (m_nCount - nIndex)*sizeof(T));                                   \
+  for (size_t i = 0; i < nInsert; ++i, ++it, ++first)                       \
+      *it = *first;                                                         \
+  m_nCount += nInsert;                                                      \
 }
 
 #endif
@@ -390,11 +421,57 @@ _WX_DEFINE_BASEARRAY(const void *, wxBaseArrayPtrVoid)
 _WX_DEFINE_BASEARRAY(short,        wxBaseArrayShort)
 _WX_DEFINE_BASEARRAY(int,          wxBaseArrayInt)
 _WX_DEFINE_BASEARRAY(long,         wxBaseArrayLong)
-//_WX_DEFINE_BASEARRAY(double,       wxBaseArrayDouble)
+_WX_DEFINE_BASEARRAY(double,       wxBaseArrayDouble)
 
 #if wxUSE_STL
 #include "wx/arrstr.h"
 
-_WX_DEFINE_BASEARRAY(wxString, wxBaseArrayStringBase)
+#include "wx/beforestd.h"
+#include <functional>
+#include "wx/afterstd.h"
+
+_WX_DEFINE_BASEARRAY(wxString, wxBaseArrayStringBase);
+
+int wxArrayString::Index(const wxChar* sz, bool bCase, bool WXUNUSED(bFromEnd)) const
+{
+    wxArrayString::const_iterator it;
+
+    if (bCase)
+        it = std::find_if(begin(), end(),
+                          std::not1(std::bind2nd(std::ptr_fun(wxStrcmp), sz)));
+    else
+        it = std::find_if(begin(), end(),
+                          std::not1(std::bind2nd(std::ptr_fun(wxStricmp), sz)));
+
+    return it == end() ? wxNOT_FOUND : it - begin();
+}
+
+class wxStringCompareLess
+{
+public:
+    typedef int (wxCMPFUNC_CONV * fnc)(const wxChar*, const wxChar*);
+public:
+    wxStringCompareLess(fnc f) : m_f(f) { }
+    bool operator()(const wxChar* s1, const wxChar* s2)
+        { return m_f(s1, s2) < 0; }
+private:
+    fnc m_f;
+};
+
+int wxSortedArrayString::Index(const wxChar* sz, bool bCase, bool WXUNUSED(bFromEnd)) const
+{
+    wxSortedArrayString::const_iterator it;
+
+    if (bCase)
+        it = std::lower_bound(begin(), end(), sz,
+                              wxStringCompareLess(wxStrcmp));
+    else
+        it = std::lower_bound(begin(), end(), sz,
+                              wxStringCompareLess(wxStricmp));
+
+    if (it == end() || (bCase ? wxStrcmp : wxStricmp)(it->c_str(), sz) != 0)
+        return wxNOT_FOUND;
+    return it - begin();
+}
 
 #endif