///////////////////////////////////////////////////////////////////////////////
-// Name: dynarray.cpp
+// Name: src/common/dynarray.cpp
// Purpose: implementation of wxBaseArray class
// Author: Vadim Zeitlin
// Modified by:
// headers
// ============================================================================
-#ifdef __GNUG__
-#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_STL
// 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
// ============================================================================
// ----------------------------------------------------------------------------
#define _WX_DEFINE_BASEARRAY(T, name) \
+/* searches the array for an item (forward or backwards) */ \
+int name::Index(T lItem, bool bFromEnd) const \
+{ \
+ if ( bFromEnd ) { \
+ if ( size() > 0 ) { \
+ size_t n = size(); \
+ do { \
+ if ( (*this)[--n] == lItem ) \
+ return n; \
+ } \
+ while ( n != 0 ); \
+ } \
+ } \
+ else { \
+ for( size_t n = 0; n < size(); n++ ) { \
+ if( (*this)[n] == lItem ) \
+ return n; \
+ } \
+ } \
+ \
+ return wxNOT_FOUND; \
+} \
+ \
+/* add item assuming the array is sorted with fnCompare function */ \
+size_t name::Add(T lItem, CMPFUNC fnCompare) \
+{ \
+ size_t idx = IndexForInsert(lItem, fnCompare); \
+ Insert(lItem, idx); \
+ return idx; \
+} \
+ \
/* 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() \
{ \
} \
} \
\
-/* searches the array for an item (forward or backwards) */ \
-int name::Index(T lItem, bool bFromEnd) const \
+/* add item at the end */ \
+void name::Add(T lItem, size_t nInsert) \
{ \
- if ( bFromEnd ) { \
- if ( m_nCount > 0 ) { \
- size_t n = m_nCount; \
- do { \
- if ( m_pItems[--n] == lItem ) \
- return n; \
- } \
- while ( n != 0 ); \
- } \
- } \
- else { \
- for( size_t n = 0; n < m_nCount; n++ ) { \
- if( m_pItems[n] == lItem ) \
- return n; \
- } \
- } \
+ if (nInsert == 0) \
+ return; \
+ Grow(nInsert); \
+ for (size_t i = 0; i < nInsert; i++) \
+ m_pItems[m_nCount++] = lItem; \
+} \
\
- return wxNOT_FOUND; \
+/* add item at the given position */ \
+void name::Insert(T lItem, size_t nIndex, size_t nInsert) \
+{ \
+ wxCHECK_RET( nIndex <= m_nCount, wxT("bad index in wxArray::Insert") ); \
+ wxCHECK_RET( m_nCount <= m_nCount + nInsert, \
+ wxT("array size overflow in wxArray::Insert") ); \
+ \
+ 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++) \
+ m_pItems[nIndex + i] = lItem; \
+ m_nCount += nInsert; \
} \
\
/* search for a place to insert item into sorted array (binary search) */ \
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 && m_pItems[n] == lItem ? (int)n : wxNOT_FOUND; \
-} \
- \
-/* add item at the end */ \
-void name::Add(T lItem, size_t nInsert) \
-{ \
- if (nInsert == 0) \
- return; \
- Grow(nInsert); \
- for (size_t i = 0; i < nInsert; i++) \
- m_pItems[m_nCount++] = lItem; \
-} \
- \
-/* add item assuming the array is sorted with fnCompare function */ \
-void name::Add(T lItem, CMPFUNC fnCompare) \
-{ \
- Insert(lItem, IndexForInsert(lItem, fnCompare)); \
-} \
- \
-/* add item at the given position */ \
-void name::Insert(T lItem, size_t nIndex, size_t nInsert) \
-{ \
- wxCHECK_RET( nIndex <= m_nCount, wxT("bad index in wxArray::Insert") ); \
- wxCHECK_RET( m_nCount <= m_nCount + nInsert, \
- wxT("array size overflow in wxArray::Insert") ); \
- \
- 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++) \
- m_pItems[nIndex + i] = lItem; \
- m_nCount += nInsert; \
+ return (n >= m_nCount || \
+ (*fnCompare)((const void *)(wxUIntPtr)lItem, \
+ ((const void *)(wxUIntPtr)m_pItems[n]))) \
+ ? wxNOT_FOUND \
+ : (int)n; \
} \
\
/* removes item from array (by index) */ \
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; \
}
+#ifdef __INTELC__
+ #pragma warning(push)
+ #pragma warning(disable: 1684)
+ #pragma warning(disable: 1572)
+#endif
+
_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(double, wxBaseArrayDouble)
+_WX_DEFINE_BASEARRAY(size_t, wxBaseArraySizeT)
+_WX_DEFINE_BASEARRAY(double, wxBaseArrayDouble)
+
+#ifdef __INTELC__
+ #pragma warning(pop)
+#endif
+
+#else // wxUSE_STL
+
+#include "wx/arrstr.h"
+
+#include "wx/beforestd.h"
+#include <functional>
+#include "wx/afterstd.h"
+
+// 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 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(
+ wxStringCmp(), str)));
+ }
+ else // !bCase
+ {
+ it = std::find_if(begin(), end(),
+ std::not1(
+ std::bind2nd(
+ wxStringCmpNoCase(), str)));
+ }
+
+ return it == end() ? wxNOT_FOUND : it - begin();
+}
+
+template<class F>
+class wxStringCompareLess
+{
+public:
+ wxStringCompareLess(F f) : m_f(f) { }
+ 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 wxString& str,
+ bool WXUNUSED_UNLESS_DEBUG(bCase),
+ bool WXUNUSED_UNLESS_DEBUG(bFromEnd)) const
+{
+ wxASSERT_MSG( bCase && !bFromEnd,
+ "search parameters ignored for sorted array" );
+
+ 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 // !wxUSE_STL/wxUSE_STL
projects / wxWidgets.git / blobdiff