Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

get rid of base arrays in wxUSE_STL build, we don't need them there and deriving wxFooPtr from wxBaseArrayPtrVoid makes it iterators return void pointers instead of those of the correct type; added test case to check for this

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@54761 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
2008-07-22 01:01:56 +00:00
parent 87ec008f42
commit 35d5da677d
3 changed files with 79 additions and 89 deletions
Download Patch File Download Diff File Expand all files Collapse all files

109
include/wx/dynarray.h
View File

@@ -54,6 +54,8 @@
*/ */
#define WX_ARRAY_DEFAULT_INITIAL_SIZE (16) #define WX_ARRAY_DEFAULT_INITIAL_SIZE (16)
#define _WX_ERROR_REMOVE "removing inexistent element in wxArray::Remove"
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// types // types
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@@ -119,7 +121,10 @@ classexp name : public std::vector<T> \
typedef predicate::CMPFUNC SCMPFUNC; \ typedef predicate::CMPFUNC SCMPFUNC; \
public: \ public: \
typedef wxArray_SortFunction<T>::CMPFUNC CMPFUNC; \ typedef wxArray_SortFunction<T>::CMPFUNC CMPFUNC; \
\
public: \ public: \
typedef T base_type; \
\
name() : std::vector<T>() { } \ name() : std::vector<T>() { } \
name(size_type n) : std::vector<T>(n) { } \ name(size_type n) : std::vector<T>(n) { } \
name(size_type n, const_reference v) : std::vector<T>(n, v) { } \ name(size_type n, const_reference v) : std::vector<T>(n, v) { } \
@@ -127,28 +132,67 @@ public: \
void Empty() { clear(); } \ void Empty() { clear(); } \
void Clear() { clear(); } \ void Clear() { clear(); } \
void Alloc(size_t uiSize) { reserve(uiSize); } \ void Alloc(size_t uiSize) { reserve(uiSize); } \
void Shrink(); \ void Shrink() { name tmp(*this); swap(tmp); } \
\ \
size_t GetCount() const { return size(); } \ size_t GetCount() const { return size(); } \
void SetCount(size_t n, T v = T()) { resize(n, v); } \ void SetCount(size_t n, T v = T()) { resize(n, v); } \
bool IsEmpty() const { return empty(); } \ bool IsEmpty() const { return empty(); } \
size_t Count() const { return size(); } \ size_t Count() const { return size(); } \
\ \
typedef T base_type; \
\
protected: \
T& Item(size_t uiIndex) const \ T& Item(size_t uiIndex) const \
{ wxASSERT( uiIndex < size() ); return (T&)operator[](uiIndex); } \ { wxASSERT( uiIndex < size() ); return (T&)operator[](uiIndex); } \
T& Last() const { return Item(size() - 1); } \
\ \
int Index(T e, bool bFromEnd = false) const; \ int Index(T item, bool bFromEnd = false) const \
int Index(T lItem, CMPFUNC fnCompare) const; \ { \
size_t IndexForInsert(T lItem, CMPFUNC fnCompare) const; \ if ( bFromEnd ) \
{ \
const const_reverse_iterator b = rbegin(), \
e = rend(); \
for ( const_reverse_iterator i = b; i != e; ++i ) \
if ( *i == item ) \
return (int)(i - b); \
} \
else \
{ \
const const_iterator b = begin(), \
e = end(); \
for ( const_iterator i = b; i != e; ++i ) \
if ( *i == item ) \
return (int)(i - b); \
} \
\
return wxNOT_FOUND; \
} \
int Index(T lItem, CMPFUNC fnCompare) const \
{ \
Predicate p((SCMPFUNC)fnCompare); \
const_iterator i = std::lower_bound(begin(), end(), lItem, p);\
return i != end() && !p(lItem, *i) ? (int)(i - begin()) \
: wxNOT_FOUND; \
} \
size_t IndexForInsert(T lItem, CMPFUNC fnCompare) const \
{ \
Predicate p((SCMPFUNC)fnCompare); \
const_iterator i = std::lower_bound(begin(), end(), lItem, p);\
return i - begin(); \
} \
void Add(T lItem, size_t nInsert = 1) \ void Add(T lItem, size_t nInsert = 1) \
{ insert(end(), nInsert, lItem); } \ { insert(end(), nInsert, lItem); } \
size_t Add(T lItem, CMPFUNC fnCompare); \ size_t Add(T lItem, CMPFUNC fnCompare) \
{ \
size_t n = IndexForInsert(lItem, fnCompare); \
Insert(lItem, n); \
return n; \
} \
void Insert(T lItem, size_t uiIndex, size_t nInsert = 1) \ void Insert(T lItem, size_t uiIndex, size_t nInsert = 1) \
{ insert(begin() + uiIndex, nInsert, lItem); } \ { insert(begin() + uiIndex, nInsert, lItem); } \
void Remove(T lItem); \ void Remove(T lItem) \
{ \
int n = Index(lItem); \
wxCHECK_RET( n != wxNOT_FOUND, _WX_ERROR_REMOVE ); \
RemoveAt((size_t)n); \
} \
void RemoveAt(size_t uiIndex, size_t nRemove = 1) \ void RemoveAt(size_t uiIndex, size_t nRemove = 1) \
{ erase(begin() + uiIndex, begin() + uiIndex + nRemove); } \ { erase(begin() + uiIndex, begin() + uiIndex + nRemove); } \
\ \
@@ -269,11 +313,6 @@ private: \
// so using a temporary variable instead. // so using a temporary variable instead.
// //
// The classes need a (even trivial) ~name() to link under Mac X // The classes need a (even trivial) ~name() to link under Mac X
//
// _WX_ERROR_REMOVE is needed to resolve the name conflict between the wxT()
// macro and T typedef: we can't use wxT() inside WX_DEFINE_ARRAY!
#define _WX_ERROR_REMOVE wxT("removing inexisting element in wxArray::Remove")
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// _WX_DEFINE_TYPEARRAY: array for simple types // _WX_DEFINE_TYPEARRAY: array for simple types
@@ -281,40 +320,10 @@ private: \
#if wxUSE_STL #if wxUSE_STL
// in STL case we don't need the entire base arrays hack as standard container
// don't suffer from alignment/storage problems as our home-grown do
#define _WX_DEFINE_TYPEARRAY(T, name, base, classexp) \ #define _WX_DEFINE_TYPEARRAY(T, name, base, classexp) \
typedef int (CMPFUNC_CONV *CMPFUNC##T)(T *pItem1, T *pItem2); \ _WX_DECLARE_BASEARRAY(T, name, classexp)
classexp name : public base \
{ \
public: \
name() : base() { } \
name(size_type n) : base(n) { } \
name(size_type n, const_reference v) : base(n, v) { } \
\
T& operator[](size_t uiIndex) const \
{ return (T&)(base::operator[](uiIndex)); } \
T& Item(size_t uiIndex) const \
{ return (T&)/*const cast*/base::operator[](uiIndex); } \
T& Last() const \
{ return Item(GetCount() - 1); } \
\
int Index(T e, bool bFromEnd = false) const \
{ return base::Index(e, bFromEnd); } \
\
void Add(T lItem, size_t nInsert = 1) \
{ insert(end(), nInsert, lItem); } \
void Insert(T lItem, size_t uiIndex, size_t nInsert = 1) \
{ insert(begin() + uiIndex, nInsert, lItem); } \
\
void RemoveAt(size_t uiIndex, size_t nRemove = 1) \
{ base::RemoveAt(uiIndex, nRemove); } \
void Remove(T lItem) \
{ int iIndex = Index(lItem); \
wxCHECK2_MSG( iIndex != wxNOT_FOUND, return, \
_WX_ERROR_REMOVE); \
RemoveAt((size_t)iIndex); } \
\
void Sort(CMPFUNC##T fCmp) { base::Sort((CMPFUNC)fCmp); } \
}
#define _WX_DEFINE_TYPEARRAY_PTR(T, name, base, classexp) \ #define _WX_DEFINE_TYPEARRAY_PTR(T, name, base, classexp) \
_WX_DEFINE_TYPEARRAY(T, name, base, classexp) _WX_DEFINE_TYPEARRAY(T, name, base, classexp)
@@ -353,8 +362,7 @@ public: \
{ base::RemoveAt(uiIndex, nRemove); } \ { base::RemoveAt(uiIndex, nRemove); } \
void Remove(T lItem) \ void Remove(T lItem) \
{ int iIndex = Index(lItem); \ { int iIndex = Index(lItem); \
wxCHECK2_MSG( iIndex != wxNOT_FOUND, return, \ wxCHECK_RET( iIndex != wxNOT_FOUND, _WX_ERROR_REMOVE); \
_WX_ERROR_REMOVE); \
base::RemoveAt((size_t)iIndex); } \ base::RemoveAt((size_t)iIndex); } \
\ \
void Sort(CMPFUNC##T fCmp) { base::Sort((CMPFUNC)fCmp); } \ void Sort(CMPFUNC##T fCmp) { base::Sort((CMPFUNC)fCmp); } \
@@ -535,8 +543,7 @@ public: \
{ base::erase(begin() + uiIndex, begin() + uiIndex + nRemove); } \ { base::erase(begin() + uiIndex, begin() + uiIndex + nRemove); } \
void Remove(T lItem) \ void Remove(T lItem) \
{ int iIndex = Index(lItem); \ { int iIndex = Index(lItem); \
wxCHECK2_MSG( iIndex != wxNOT_FOUND, return, \ wxCHECK_RET( iIndex != wxNOT_FOUND, _WX_ERROR_REMOVE ); \
_WX_ERROR_REMOVE ); \
base::erase(begin() + iIndex); } \ base::erase(begin() + iIndex); } \
\ \
private: \ private: \

44
src/common/dynarray.cpp
View File

@@ -28,6 +28,8 @@
#include <stdlib.h> #include <stdlib.h>
#include <string.h> // for memmove #include <string.h> // for memmove
#if !wxUSE_STL
// we cast the value to long from which we cast it to void * in IndexForInsert: // 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 // this can't work if the pointers are not big enough
wxCOMPILE_TIME_ASSERT( sizeof(wxUIntPtr) <= sizeof(void *), wxCOMPILE_TIME_ASSERT( sizeof(wxUIntPtr) <= sizeof(void *),
@@ -48,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) */ \ /* searches the array for an item (forward or backwards) */ \
int name::Index(T lItem, bool bFromEnd) const \ int name::Index(T lItem, bool bFromEnd) const \
{ \ { \
@@ -78,35 +80,8 @@ size_t name::Add(T lItem, CMPFUNC fnCompare) \
size_t idx = IndexForInsert(lItem, fnCompare); \ size_t idx = IndexForInsert(lItem, fnCompare); \
Insert(lItem, idx); \ Insert(lItem, idx); \
return 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 */ \ /* ctor */ \
name::name() \ name::name() \
{ \ { \
@@ -390,12 +365,6 @@ void name::insert(iterator it, const_iterator first, const_iterator last) \
m_nCount += nInsert; \ m_nCount += nInsert; \
} }
#endif
#define _WX_DEFINE_BASEARRAY(T, name) \
_WX_DEFINE_BASEARRAY_COMMON(T, name) \
_WX_DEFINE_BASEARRAY_NOCOMMON(T, name)
#ifdef __INTELC__ #ifdef __INTELC__
#pragma warning(push) #pragma warning(push)
#pragma warning(disable: 1684) #pragma warning(disable: 1684)
@@ -414,15 +383,14 @@ _WX_DEFINE_BASEARRAY(double, wxBaseArrayDouble)
#pragma warning(pop) #pragma warning(pop)
#endif #endif
#if wxUSE_STL #else // wxUSE_STL
#include "wx/arrstr.h" #include "wx/arrstr.h"
#include "wx/beforestd.h" #include "wx/beforestd.h"
#include <functional> #include <functional>
#include "wx/afterstd.h" #include "wx/afterstd.h"
_WX_DEFINE_BASEARRAY(wxString, wxBaseArrayStringBase)
// some compilers (Sun CC being the only known example) distinguish between // some compilers (Sun CC being the only known example) distinguish between
// extern "C" functions and the functions with C++ linkage and ptr_fun and // extern "C" functions and the functions with C++ linkage and ptr_fun and
// wxStringCompareLess can't take wxStrcmp/wxStricmp directly as arguments in // wxStringCompareLess can't take wxStrcmp/wxStricmp directly as arguments in
@@ -535,4 +503,4 @@ int wxSortedArrayString::Index(const wxString& str, bool bCase, bool WXUNUSED(bF
return it - begin(); return it - begin();
} }
#endif // wxUSE_STL #endif // !wxUSE_STL/wxUSE_STL

15
tests/arrays/arrays.cpp
View File

@@ -139,6 +139,15 @@ WX_DEFINE_SORTED_ARRAY_CMP_SHORT(ushort, UShortCompareValues, wxSortedArrayUShor
WX_DEFINE_SORTED_ARRAY_CMP_INT(int, IntCompareValues, wxSortedArrayInt); WX_DEFINE_SORTED_ARRAY_CMP_INT(int, IntCompareValues, wxSortedArrayInt);
struct Item
{
Item(int n_ = 0) : n(n_) { }
int n;
};
WX_DEFINE_ARRAY_PTR(Item *, ItemPtrArray);
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// test class // test class
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@@ -594,4 +603,10 @@ void ArraysTestCase::TestSTL()
{ {
CPPUNIT_ASSERT( *it == i ); CPPUNIT_ASSERT( *it == i );
} }
ItemPtrArray items;
items.push_back(new Item(17));
CPPUNIT_ASSERT_EQUAL( 17, (*(items.rbegin()))->n );
CPPUNIT_ASSERT_EQUAL( 17, (**items.begin()).n );
} }