///////////////////////////////////////////////////////////////////////////////
-// Name: dynarray.cpp
+// Name: src/common/dynarray.cpp
// Purpose: implementation of wxBaseArray class
// Author: Vadim Zeitlin
// Modified by:
// 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__
- #pragma hdrstop
+ #pragma hdrstop
#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
-#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
-wxCOMPILE_TIME_ASSERT( sizeof(long) <= sizeof(void *),
+wxCOMPILE_TIME_ASSERT( sizeof(wxUIntPtr) <= sizeof(void *),
wxArraySizeOfPtrLessSizeOfLong ); // < 32 symbols
// ============================================================================
// 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 \
{ \
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; \
- m_pItems = (T *)NULL; \
+ m_pItems = NULL; \
} \
\
/* copy ctor */ \
} \
} \
else \
- m_pItems = (T *) NULL; \
+ m_pItems = NULL; \
} \
\
/* assignment operator */ \
} \
} \
else \
- m_pItems = (T *) NULL; \
+ m_pItems = NULL; \
\
return *this; \
} \
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() \
{ \
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 ) \
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) */ \
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) \
m_nCount += nInsert; \
}
+#ifdef __INTELC__
+ #pragma warning(push)
+ #pragma warning(disable: 1684)
+ #pragma warning(disable: 1572)
#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(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)
-#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"
-_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)
+ {
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(),
- std::not1(std::bind2nd(std::ptr_fun(wxStricmp), sz)));
+ std::not1(
+ std::bind2nd(
+ wxStringCmpNoCase(), str)));
+ }
return it == end() ? wxNOT_FOUND : it - begin();
}
+template<class F>
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:
- 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
- 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 it - begin();
}
-#endif
+#endif // !wxUSE_STD_CONTAINERS/wxUSE_STD_CONTAINERS
projects / wxWidgets.git / blobdiff