Add missing WXK constants for the control keys

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

diff --git a/src/common/dynarray.cpp b/src/common/dynarray.cpp
index c69cb4cd409a44bf5c85e741dee3dd9e4a538a20..0f556decb500d14f799701da81c8edf15cd82032 100644 (file)
--- a/src/common/dynarray.cpp
+++ b/src/common/dynarray.cpp
@@ -1,37 +1,34 @@
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////

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

 // Purpose:     implementation of wxBaseArray class
 // Author:      Vadim Zeitlin
 // Modified by:
 // Created:     12.09.97
 // RCS-ID:      $Id$
 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
 // Purpose:     implementation of wxBaseArray class
 // Author:      Vadim Zeitlin
 // Modified by:
 // Created:     12.09.97
 // RCS-ID:      $Id$
 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>

-// Licence:     wxWidgets licence
+// Licence:     wxWindows licence

 ///////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================
 // headers
 // ============================================================================
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================
 // headers
 // ============================================================================
 

-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-#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
+#if !wxUSE_STD_CONTAINERS

 
 // 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


@@ -53,7 +50,7 @@ wxCOMPILE_TIME_ASSERT( sizeof(wxUIntPtr) <= sizeof(void *),
 // wxBaseArray - dynamic array of 'T's
 // ----------------------------------------------------------------------------
 
 // wxBaseArray - dynamic array of 'T's
 // ----------------------------------------------------------------------------
 

-#define _WX_DEFINE_BASEARRAY_COMMON(T, name)                                \
+#define _WX_DEFINE_BASEARRAY(T, name)                                       \

 /* searches the array for an item (forward or backwards) */                 \
 int name::Index(T lItem, bool bFromEnd) const                               \
 {                                                                           \
 /* searches the array for an item (forward or backwards) */                 \
 int name::Index(T lItem, bool bFromEnd) const                               \
 {                                                                           \


@@ -83,41 +80,14 @@ size_t name::Add(T lItem, CMPFUNC fnCompare)                                \
   size_t idx = IndexForInsert(lItem, fnCompare);                            \
   Insert(lItem, idx);                                                       \
   return idx;                                                               \
   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((SCMPFUNC)fnCompare);                                       \
-    const_iterator it = std::lower_bound(begin(), end(), lItem, p);         \
-    return it - begin();                                                    \
-}                                                                           \
-                                                                            \
-int name::Index(T lItem, CMPFUNC fnCompare) const                           \
-{                                                                           \
-    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()                                                         \
-{                                                                           \
-    name tmp(*this);                                                        \
-    swap(tmp);                                                              \
-}
-
-#else // if !wxUSE_STL
-
-#define _WX_DEFINE_BASEARRAY_NOCOMMON(T, name)                              \

 /* ctor */                                                                  \
 name::name()                                                                \
 {                                                                           \
   m_nSize  =                                                                \
   m_nCount = 0;                                                             \
 /* ctor */                                                                  \
 name::name()                                                                \
 {                                                                           \
   m_nSize  =                                                                \
   m_nCount = 0;                                                             \

-  m_pItems = (T *)NULL;                                                     \
+  m_pItems = NULL;                                                     \

 }                                                                           \
                                                                             \
 /* copy ctor */                                                             \
 }                                                                           \
                                                                             \
 /* copy ctor */                                                             \


@@ -137,7 +107,7 @@ name::name(const name& src)                                                 \
       }                                                                     \
   }                                                                         \
   else                                                                      \
       }                                                                     \
   }                                                                         \
   else                                                                      \

-    m_pItems = (T *) NULL;                                                  \
+    m_pItems = NULL;                                                  \

 }                                                                           \
                                                                             \
 /* assignment operator */                                                   \
 }                                                                           \
                                                                             \
 /* assignment operator */                                                   \


@@ -159,7 +129,7 @@ name& name::operator=(const name& src)                                      \
       }                                                                     \
   }                                                                         \
   else                                                                      \
       }                                                                     \
   }                                                                         \
   else                                                                      \

-    m_pItems = (T *) NULL;                                                  \
+    m_pItems = NULL;                                                  \

                                                                             \
   return *this;                                                             \
 }                                                                           \
                                                                             \
   return *this;                                                             \
 }                                                                           \


@@ -188,13 +158,13 @@ void name::Grow(size_t nIncrement)                                          \
   if( (m_nCount == m_nSize) || ((m_nSize - m_nCount) < nIncrement) ) {      \
     if( m_nSize == 0 ) {                                                    \
       /* was empty, determine initial size */                               \
   if( (m_nCount == m_nSize) || ((m_nSize - m_nCount) < nIncrement) ) {      \
     if( m_nSize == 0 ) {                                                    \
       /* was empty, determine initial size */                               \

-      size_t size = WX_ARRAY_DEFAULT_INITIAL_SIZE;                          \
-      if (size < nIncrement) size = nIncrement;                             \
+      size_t sz = WX_ARRAY_DEFAULT_INITIAL_SIZE;                            \
+      if (sz < nIncrement) sz = nIncrement;                                 \

       /* allocate some memory */                                            \
       /* allocate some memory */                                            \

-      m_pItems = new T[size];                                               \
+      m_pItems = new T[sz];                                                 \

       /* only grow if allocation succeeded */                               \
       if ( m_pItems ) {                                                     \
       /* only grow if allocation succeeded */                               \
       if ( m_pItems ) {                                                     \

-          m_nSize = size;                                                   \
+          m_nSize = sz;                                                     \

       }                                                                     \
     }                                                                       \
     else                                                                    \
       }                                                                     \
     }                                                                       \
     else                                                                    \


@@ -249,23 +219,6 @@ void name::Clear()                                                          \
   wxDELETEA(m_pItems);                                                      \
 }                                                                           \
                                                                             \
   wxDELETEA(m_pItems);                                                      \
 }                                                                           \
                                                                             \

-/* pre-allocates memory (frees the previous data!) */                       \
-void name::Alloc(size_t nSize)                                              \
-{                                                                           \
-  /* only if old buffer was not big enough */                               \
-  if ( nSize > m_nSize ) {                                                  \
-    wxDELETEA(m_pItems);                                                    \
-    m_nSize  = 0;                                                           \
-    m_pItems = new T[nSize];                                                \
-    /* only alloc if allocation succeeded */                                \
-    if ( m_pItems ) {                                                       \
-        m_nSize  = nSize;                                                   \
-    }                                                                       \
-  }                                                                         \
-                                                                            \
-  m_nCount = 0;                                                             \
-}                                                                           \
-                                                                            \

 /* minimizes the memory usage by freeing unused memory */                   \
 void name::Shrink()                                                         \
 {                                                                           \
 /* minimizes the memory usage by freeing unused memory */                   \
 void name::Shrink()                                                         \
 {                                                                           \


@@ -405,6 +358,9 @@ void name::insert(iterator it, const_iterator first, const_iterator last)   \
       return;                                                               \
   Grow(nInsert);                                                            \
                                                                             \
       return;                                                               \
   Grow(nInsert);                                                            \
                                                                             \

+  /* old iterator could have been invalidated by Grow(). */                 \
+  it = begin() + nIndex;                                                    \
+                                                                            \

   memmove(&m_pItems[nIndex + nInsert], &m_pItems[nIndex],                   \
           (m_nCount - nIndex)*sizeof(T));                                   \
   for (size_t i = 0; i < nInsert; ++i, ++it, ++first)                       \
   memmove(&m_pItems[nIndex + nInsert], &m_pItems[nIndex],                   \
           (m_nCount - nIndex)*sizeof(T));                                   \
   for (size_t i = 0; i < nInsert; ++i, ++it, ++first)                       \


@@ -412,68 +368,130 @@ void name::insert(iterator it, const_iterator first, const_iterator last)   \
   m_nCount += nInsert;                                                      \
 }
 
   m_nCount += nInsert;                                                      \
 }
 

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

 #endif
 
 #endif
 

-#define _WX_DEFINE_BASEARRAY(T, name)                                       \
-        _WX_DEFINE_BASEARRAY_COMMON(T, name)                                \
-        _WX_DEFINE_BASEARRAY_NOCOMMON(T, name)
-

 _WX_DEFINE_BASEARRAY(const void *, wxBaseArrayPtrVoid)
 _WX_DEFINE_BASEARRAY(const void *, wxBaseArrayPtrVoid)

+_WX_DEFINE_BASEARRAY(char,         wxBaseArrayChar)

 _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(short,        wxBaseArrayShort)
 _WX_DEFINE_BASEARRAY(int,          wxBaseArrayInt)
 _WX_DEFINE_BASEARRAY(long,         wxBaseArrayLong)
 _WX_DEFINE_BASEARRAY(size_t,       wxBaseArraySizeT)
 _WX_DEFINE_BASEARRAY(double,       wxBaseArrayDouble)
 

-#if wxUSE_STL
+#ifdef __INTELC__
+    #pragma warning(pop)
+#endif
+
+#else // wxUSE_STD_CONTAINERS
+

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

-_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
+struct wxStringCmp
+{
+    typedef wxString first_argument_type;
+    typedef wxString second_argument_type;
+    typedef int result_type;

 
 

-int wxArrayString::Index(const wxChar* sz, bool bCase, bool WXUNUSED(bFromEnd)) const
+    int operator()(const wxString& s1, const wxString& s2) const
+    {
+        return s1.compare(s2);
+    }
+};
+
+struct wxStringCmpNoCase
+{
+    typedef wxString first_argument_type;
+    typedef wxString second_argument_type;
+    typedef int result_type;
+
+    int operator()(const wxString& s1, const wxString& s2) const
+    {
+        return s1.CmpNoCase(s2);
+    }
+};
+
+int wxArrayString::Index(const wxString& str, bool bCase, bool WXUNUSED(bFromEnd)) const

 {
     wxArrayString::const_iterator it;
 
     if (bCase)
 {
     wxArrayString::const_iterator it;
 
     if (bCase)

+    {

         it = std::find_if(begin(), end(),
         it = std::find_if(begin(), end(),

-                          std::not1(std::bind2nd(std::ptr_fun(wxStrcmp), sz)));
-    else
+                          std::not1(
+                              std::bind2nd(
+                                  wxStringCmp(), str)));
+    }
+    else // !bCase
+    {

         it = std::find_if(begin(), end(),
         it = std::find_if(begin(), end(),

-                          std::not1(std::bind2nd(std::ptr_fun(wxStricmp), sz)));
+                          std::not1(
+                              std::bind2nd(
+                                  wxStringCmpNoCase(), str)));
+    }

 
     return it == end() ? wxNOT_FOUND : it - begin();
 }
 
 
     return it == end() ? wxNOT_FOUND : it - begin();
 }
 

+template<class F>

 class wxStringCompareLess
 {
 public:
 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)
+    wxStringCompareLess(F f) : m_f(f) { }
+    bool operator()(const wxString& s1, const wxString& s2)

         { return m_f(s1, s2) < 0; }
 private:
         { return m_f(s1, s2) < 0; }
 private:

-    fnc m_f;
+    F m_f;

 };
 
 };
 

-int wxSortedArrayString::Index(const wxChar* sz, bool bCase, bool WXUNUSED(bFromEnd)) const
+template<class F>
+wxStringCompareLess<F> wxStringCompare(F f)

 {
 {

-    wxSortedArrayString::const_iterator it;
+    return wxStringCompareLess<F>(f);
+}

 
 

-    if (bCase)
-        it = std::lower_bound(begin(), end(), sz,
-                              wxStringCompareLess(wxStrcmp));
+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
     else

-        it = std::lower_bound(begin(), end(), sz,
-                              wxStringCompareLess(wxStricmp));
+    {
+        std::sort(begin(), end());
+    }
+}
+
+int wxSortedArrayString::Index(const wxString& str,
+                               bool WXUNUSED_UNLESS_DEBUG(bCase),
+                               bool WXUNUSED_UNLESS_DEBUG(bFromEnd)) const
+{
+    wxASSERT_MSG( bCase && !bFromEnd,
+                  "search parameters ignored for sorted array" );

 
 

-    if (it == end() || (bCase ? wxStrcmp : wxStricmp)(it->c_str(), sz) != 0)
+    wxSortedArrayString::const_iterator
+        it = std::lower_bound(begin(), end(), str, wxStringCompare(wxStringCmp()));
+
+    if ( it == end() || str.Cmp(*it) != 0 )

         return wxNOT_FOUND;
         return wxNOT_FOUND;

+

     return it - begin();
 }
 
     return it - begin();
 }
 

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