Better place for coordinate mirroring and removal

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

diff --git a/src/common/dynarray.cpp b/src/common/dynarray.cpp
index 038947c6bade74dc367de3746e5b97e28450de0b..c856a651f64fbb57327357eb5eb55d3eb532b946 100644 (file)
--- a/src/common/dynarray.cpp
+++ b/src/common/dynarray.cpp
@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////

-// Name:        dynarray.cpp
+// Name:        src/common/dynarray.cpp

 // Purpose:     implementation of wxBaseArray class
 // Author:      Vadim Zeitlin
 // Modified by:
 // Purpose:     implementation of wxBaseArray class
 // Author:      Vadim Zeitlin
 // Modified by:


@@ -13,29 +13,24 @@
 // headers
 // ============================================================================
 
 // headers
 // ============================================================================
 

-#ifdef __GNUG__
-#pragma implementation "dynarray.h"
-#endif
-
+// For compilers that support precompilation, includes "wx.h".

 #include  "wx/wxprec.h"
 
 #ifdef __BORLANDC__
 #include  "wx/wxprec.h"
 
 #ifdef __BORLANDC__

-  #pragma hdrstop
+    #pragma hdrstop

 #endif
 
 #endif
 

-#include "wx/dynarray.h"
-#include "wx/intl.h"
+#ifndef WX_PRECOMP
+    #include "wx/dynarray.h"
+    #include "wx/intl.h"
+#endif //WX_PRECOMP

 
 #include <stdlib.h>
 #include <string.h> // for memmove
 
 
 #include <stdlib.h>
 #include <string.h> // for memmove
 

-#ifndef max
-  #define max(a, b)   (((a) > (b)) ? (a) : (b))
-#endif
-

 // we cast the value to long from which we cast it to void * in IndexForInsert:
 // this can't work if the pointers are not big enough
 // we cast the value to long from which we cast it to void * in IndexForInsert:
 // this can't work if the pointers are not big enough

-wxCOMPILE_TIME_ASSERT( sizeof(long) <= sizeof(void *),
+wxCOMPILE_TIME_ASSERT( sizeof(wxUIntPtr) <= sizeof(void *),

                        wxArraySizeOfPtrLessSizeOfLong ); // < 32 symbols
 
 // ============================================================================
                        wxArraySizeOfPtrLessSizeOfLong ); // < 32 symbols
 
 // ============================================================================


@@ -90,17 +85,17 @@ size_t name::Add(T lItem, CMPFUNC fnCompare)                                \
 #define _WX_DEFINE_BASEARRAY_NOCOMMON(T, name)                              \
 size_t name::IndexForInsert(T lItem, CMPFUNC fnCompare) const               \
 {                                                                           \
 #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                           \
 {                                                                           \
     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()                                                         \
 }                                                                           \
                                                                             \
 void name::Shrink()                                                         \


@@ -326,8 +321,8 @@ size_t name::IndexForInsert(T lItem, CMPFUNC fnCompare) const               \
   while ( lo < hi ) {                                                       \
     i = (lo + hi)/2;                                                        \
                                                                             \
   while ( lo < hi ) {                                                       \
     i = (lo + hi)/2;                                                        \
                                                                             \

-    res = (*fnCompare)((const void *)(long)lItem,                           \
-                       (const void *)(long)(m_pItems[i]));                  \
+    res = (*fnCompare)((const void *)(wxUIntPtr)lItem,                      \
+                       (const void *)(wxUIntPtr)(m_pItems[i]));             \

     if ( res < 0 )                                                          \
       hi = i;                                                               \
     else if ( res > 0 )                                                     \
     if ( res < 0 )                                                          \
       hi = i;                                                               \
     else if ( res > 0 )                                                     \


@@ -347,9 +342,10 @@ int name::Index(T lItem, CMPFUNC fnCompare) const                           \
     size_t n = IndexForInsert(lItem, fnCompare);                            \
                                                                             \
     return (n >= m_nCount ||                                                \
     size_t n = IndexForInsert(lItem, fnCompare);                            \
                                                                             \
     return (n >= m_nCount ||                                                \

-           (*fnCompare)((const void *)(long)lItem,                          \
-                        ((const void *)(long)m_pItems[n]))) ? wxNOT_FOUND   \
-                                                            : (int)n;       \
+           (*fnCompare)((const void *)(wxUIntPtr)lItem,                     \
+                        ((const void *)(wxUIntPtr)m_pItems[n])))            \
+                        ? wxNOT_FOUND                                       \
+                        : (int)n;                                           \

 }                                                                           \
                                                                             \
 /* removes item from array (by index) */                                    \
 }                                                                           \
                                                                             \
 /* removes item from array (by index) */                                    \


@@ -417,15 +413,131 @@ void name::insert(iterator it, const_iterator first, const_iterator last)   \
         _WX_DEFINE_BASEARRAY_COMMON(T, name)                                \
         _WX_DEFINE_BASEARRAY_NOCOMMON(T, name)
 
         _WX_DEFINE_BASEARRAY_COMMON(T, name)                                \
         _WX_DEFINE_BASEARRAY_NOCOMMON(T, name)
 

+#ifdef __INTELC__
+    #pragma warning(push)
+    #pragma warning(disable: 1684)
+    #pragma warning(disable: 1572)
+#endif
+

 _WX_DEFINE_BASEARRAY(const void *, wxBaseArrayPtrVoid)
 _WX_DEFINE_BASEARRAY(short,        wxBaseArrayShort)
 _WX_DEFINE_BASEARRAY(int,          wxBaseArrayInt)
 _WX_DEFINE_BASEARRAY(long,         wxBaseArrayLong)
 _WX_DEFINE_BASEARRAY(const void *, wxBaseArrayPtrVoid)
 _WX_DEFINE_BASEARRAY(short,        wxBaseArrayShort)
 _WX_DEFINE_BASEARRAY(int,          wxBaseArrayInt)
 _WX_DEFINE_BASEARRAY(long,         wxBaseArrayLong)

+_WX_DEFINE_BASEARRAY(size_t,       wxBaseArraySizeT)

 _WX_DEFINE_BASEARRAY(double,       wxBaseArrayDouble)
 
 _WX_DEFINE_BASEARRAY(double,       wxBaseArrayDouble)
 

+#ifdef __INTELC__
+    #pragma warning(pop)
+#endif
+

 #if wxUSE_STL
 #include "wx/arrstr.h"
 
 #if wxUSE_STL
 #include "wx/arrstr.h"
 

+#include "wx/beforestd.h"
+#include <functional>
+#include "wx/afterstd.h"
+

 _WX_DEFINE_BASEARRAY(wxString, wxBaseArrayStringBase)
 
 _WX_DEFINE_BASEARRAY(wxString, wxBaseArrayStringBase)
 

+// some compilers (Sun CC being the only known example) distinguish between
+// extern "C" functions and the functions with C++ linkage and ptr_fun and
+// wxStringCompareLess can't take wxStrcmp/wxStricmp directly as arguments in
+// this case, we need the wrappers below to make this work
+inline int wxStrcmpCppWrapper(const wxChar *p, const wxChar *q)
+{
+    return wxStrcmp(p, q);
+}
+
+inline int wxStricmpCppWrapper(const wxChar *p, const wxChar *q)
+{
+    return wxStricmp(p, q);
+}
+
+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(wxStrcmpCppWrapper), sz)));
+    }
+    else // !bCase
+    {
+        it = std::find_if(begin(), end(),
+                          std::not1(
+                              std::bind2nd(
+                                  std::ptr_fun(wxStricmpCppWrapper), sz)));
+    }
+
+    return it == end() ? wxNOT_FOUND : it - begin();
+}
+
+template<class F>
+class wxStringCompareLess
+{
+public:
+    wxStringCompareLess(F f) : m_f(f) { }
+    bool operator()(const wxChar* s1, const wxChar* s2)
+        { return m_f(s1, s2) < 0; }
+    bool operator()(const wxString& s1, const wxString& s2)
+        { return m_f(s1, s2) < 0; }
+private:
+    F m_f;
+};
+
+template<class F>
+wxStringCompareLess<F> wxStringCompare(F f)
+{
+    return wxStringCompareLess<F>(f);
+}
+
+void wxArrayString::Sort(CompareFunction function)
+{
+    std::sort(begin(), end(), wxStringCompare(function));
+}
+
+void wxArrayString::Sort(bool reverseOrder)
+{
+    if (reverseOrder)
+    {
+        std::sort(begin(), end(), std::greater<wxString>());
+    }
+    else
+    {
+        std::sort(begin(), end());
+    }
+}
+
+int wxSortedArrayString::Index(const wxChar* sz, bool bCase, bool WXUNUSED(bFromEnd)) const
+{
+    wxSortedArrayString::const_iterator it;
+    wxString s(sz);
+
+    if (bCase)
+        it = std::lower_bound(begin(), end(), s,
+                              wxStringCompare(wxStrcmpCppWrapper));
+    else
+        it = std::lower_bound(begin(), end(), s,
+                              wxStringCompare(wxStricmpCppWrapper));
+
+    if (it == end())
+        return wxNOT_FOUND;
+
+    if (bCase)
+    {
+        if (wxStrcmp(it->c_str(), sz) != 0)
+            return wxNOT_FOUND;
+    }
+    else
+    {
+        if (wxStricmp(it->c_str(), sz) != 0)
+            return wxNOT_FOUND;
+    }
+
+    return it - begin();
+}
+

 #endif
 #endif