wxArray<T> macros have been changed to fix runtime problems under 64 bit
architectures. The base class is now implemented once for each needed primitive type in order to avoid invalid reference casts. Macros are provided to implement new arrays using these primitive base arrays. git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@14458 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Gilles Depeyrot
@@ -76,92 +76,49 @@ typedef int (wxCMPFUNC_CONV *CMPFUNC)(const void* pItem1, const void* pItem2);
|
||||
// you cast "SomeArray *" as "BaseArray *" and then delete it)
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxBaseArray
|
||||
{
|
||||
public:
|
||||
/** @name ctors and dtor */
|
||||
//@{
|
||||
/// default ctor
|
||||
wxBaseArray();
|
||||
/// copy ctor
|
||||
wxBaseArray(const wxBaseArray& array);
|
||||
/// assignment operator
|
||||
wxBaseArray& operator=(const wxBaseArray& src);
|
||||
/// not virtual, see above
|
||||
~wxBaseArray();
|
||||
//@}
|
||||
|
||||
/** @name memory management */
|
||||
//@{
|
||||
/// empties the array, but doesn't release memory
|
||||
void Empty() { m_nCount = 0; }
|
||||
/// empties the array and releases memory
|
||||
void Clear();
|
||||
/// preallocates memory for given number of items
|
||||
void Alloc(size_t uiSize);
|
||||
/// minimizes the memory used by the array (frees unused memory)
|
||||
void Shrink();
|
||||
//@}
|
||||
|
||||
/** @name simple accessors */
|
||||
//@{
|
||||
/// number of elements in the array
|
||||
size_t GetCount() const { return m_nCount; }
|
||||
/// is it empty?
|
||||
bool IsEmpty() const { return m_nCount == 0; }
|
||||
/// this version is obsolete, use GetCount()
|
||||
size_t Count() const { return m_nCount; }
|
||||
//@}
|
||||
|
||||
protected:
|
||||
// these methods are protected because if they were public one could
|
||||
// mistakenly call one of them instead of DEFINE_ARRAY's or OBJARRAY's
|
||||
// type safe methods
|
||||
|
||||
/** @name items access */
|
||||
//@{
|
||||
/// get item at position uiIndex (range checking is done in debug version)
|
||||
long& Item(size_t uiIndex) const
|
||||
{ wxASSERT( uiIndex < m_nCount ); return m_pItems[uiIndex]; }
|
||||
/// same as Item()
|
||||
long& operator[](size_t uiIndex) const { return Item(uiIndex); }
|
||||
//@}
|
||||
|
||||
/** @name item management */
|
||||
//@{
|
||||
/**
|
||||
Search the element in the array, starting from the either side
|
||||
@param bFromEnd if TRUE, start from the end
|
||||
@return index of the first item matched or wxNOT_FOUND
|
||||
@see wxNOT_FOUND
|
||||
*/
|
||||
int Index(long lItem, bool bFromEnd = FALSE) const;
|
||||
/// search for an item using binary search in a sorted array
|
||||
int Index(long lItem, CMPFUNC fnCompare) const;
|
||||
/// search for a place to insert the element into a sorted array
|
||||
size_t IndexForInsert(long lItem, CMPFUNC fnCompare) const;
|
||||
/// add new element at the end
|
||||
void Add(long lItem);
|
||||
/// add item assuming the array is sorted with fnCompare function
|
||||
void Add(long lItem, CMPFUNC fnCompare);
|
||||
/// add new element at given position (it becomes Item[uiIndex])
|
||||
void Insert(long lItem, size_t uiIndex);
|
||||
/// remove first item matching this value
|
||||
void Remove(long lItem);
|
||||
/// remove item by index
|
||||
void RemoveAt(size_t uiIndex);
|
||||
//@}
|
||||
|
||||
/// sort array elements using given compare function
|
||||
void Sort(CMPFUNC fnCompare);
|
||||
|
||||
private:
|
||||
void Grow(); // makes array bigger if needed
|
||||
|
||||
size_t m_nSize, // current size of the array
|
||||
m_nCount; // current number of elements
|
||||
|
||||
long *m_pItems; // pointer to data
|
||||
#define _WX_DECLARE_BASEARRAY(T, name, classexp) \
|
||||
classexp name \
|
||||
{ \
|
||||
public: \
|
||||
name(); \
|
||||
name(const name& array); \
|
||||
name& operator=(const name& src); \
|
||||
~name(); \
|
||||
\
|
||||
void Empty() { m_nCount = 0; } \
|
||||
void Clear(); \
|
||||
void Alloc(size_t uiSize); \
|
||||
void Shrink(); \
|
||||
\
|
||||
size_t GetCount() const { return m_nCount; } \
|
||||
bool IsEmpty() const { return m_nCount == 0; } \
|
||||
size_t Count() const { return m_nCount; } \
|
||||
\
|
||||
protected: \
|
||||
T& Item(size_t uiIndex) const \
|
||||
{ wxASSERT( uiIndex < m_nCount ); return m_pItems[uiIndex]; } \
|
||||
T& operator[](size_t uiIndex) const { return Item(uiIndex); } \
|
||||
\
|
||||
int Index(T lItem, bool bFromEnd = FALSE) const; \
|
||||
int Index(T lItem, CMPFUNC fnCompare) const; \
|
||||
size_t IndexForInsert(T lItem, CMPFUNC fnCompare) const; \
|
||||
void Add(T lItem); \
|
||||
void Add(T lItem, CMPFUNC fnCompare); \
|
||||
void Insert(T lItem, size_t uiIndex); \
|
||||
void Remove(T lItem); \
|
||||
void RemoveAt(size_t uiIndex); \
|
||||
\
|
||||
void Sort(CMPFUNC fnCompare); \
|
||||
\
|
||||
private: \
|
||||
typedef T base_type; \
|
||||
\
|
||||
void Grow(); \
|
||||
\
|
||||
size_t m_nSize, \
|
||||
m_nCount; \
|
||||
\
|
||||
T *m_pItems; \
|
||||
};
|
||||
|
||||
// ============================================================================
|
||||
@@ -177,151 +134,152 @@ private:
|
||||
// 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()
|
||||
// macor and T typedef: we can't use wxT() inside WX_DEFINE_ARRAY!
|
||||
// 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_ARRAY: array for simple types
|
||||
// _WX_DEFINE_TYPEARRAY: array for simple types
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#define _WX_DEFINE_ARRAY(T, name, classexp) \
|
||||
wxCOMPILE_TIME_ASSERT2(sizeof(T) <= sizeof(long), \
|
||||
TypeIsTooBigToBeStoredInWxArray, \
|
||||
name); \
|
||||
typedef int (CMPFUNC_CONV *CMPFUNC##T)(T *pItem1, T *pItem2); \
|
||||
classexp name : public wxBaseArray \
|
||||
{ \
|
||||
public: \
|
||||
name() { } \
|
||||
~name() { } \
|
||||
\
|
||||
name& operator=(const name& src) \
|
||||
{ wxBaseArray* temp = (wxBaseArray*) this; \
|
||||
(*temp) = ((const wxBaseArray&)src); \
|
||||
return *this; } \
|
||||
\
|
||||
T& operator[](size_t uiIndex) const \
|
||||
{ return (T&)(wxBaseArray::Item(uiIndex)); } \
|
||||
T& Item(size_t uiIndex) const \
|
||||
{ return (T&)(wxBaseArray::Item(uiIndex)); } \
|
||||
T& Last() const \
|
||||
{ return (T&)(wxBaseArray::Item(Count() - 1)); } \
|
||||
\
|
||||
int Index(T Item, bool bFromEnd = FALSE) const \
|
||||
{ return wxBaseArray::Index((long)Item, bFromEnd); } \
|
||||
\
|
||||
void Add(T Item) \
|
||||
{ wxBaseArray::Add((long)Item); } \
|
||||
void Insert(T Item, size_t uiIndex) \
|
||||
{ wxBaseArray::Insert((long)Item, uiIndex) ; } \
|
||||
\
|
||||
void RemoveAt(size_t uiIndex) { wxBaseArray::RemoveAt(uiIndex); } \
|
||||
void Remove(T Item) \
|
||||
{ int iIndex = Index(Item); \
|
||||
wxCHECK2_MSG( iIndex != wxNOT_FOUND, return, \
|
||||
_WX_ERROR_REMOVE); \
|
||||
wxBaseArray::RemoveAt((size_t)iIndex); } \
|
||||
\
|
||||
void Sort(CMPFUNC##T fCmp) { wxBaseArray::Sort((CMPFUNC)fCmp); } \
|
||||
#define _WX_DEFINE_TYPEARRAY(T, name, base, classexp) \
|
||||
wxCOMPILE_TIME_ASSERT2(sizeof(T) <= sizeof(base::base_type), \
|
||||
TypeTooBigToBeStoredIn##base, \
|
||||
name); \
|
||||
typedef int (CMPFUNC_CONV *CMPFUNC##T)(T *pItem1, T *pItem2); \
|
||||
classexp name : public base \
|
||||
{ \
|
||||
public: \
|
||||
name() { } \
|
||||
~name() { } \
|
||||
\
|
||||
name& operator=(const name& src) \
|
||||
{ base* temp = (base*) this; \
|
||||
(*temp) = ((const base&)src); \
|
||||
return *this; } \
|
||||
\
|
||||
T& operator[](size_t uiIndex) const \
|
||||
{ return (T&)(base::Item(uiIndex)); } \
|
||||
T& Item(size_t uiIndex) const \
|
||||
{ return (T&)(base::Item(uiIndex)); } \
|
||||
T& Last() const \
|
||||
{ return (T&)(base::Item(Count() - 1)); } \
|
||||
\
|
||||
int Index(T Item, bool bFromEnd = FALSE) const \
|
||||
{ return base::Index(Item, bFromEnd); } \
|
||||
\
|
||||
void Add(T Item) \
|
||||
{ base::Add(Item); } \
|
||||
void Insert(T Item, size_t uiIndex) \
|
||||
{ base::Insert(Item, uiIndex) ; } \
|
||||
\
|
||||
void RemoveAt(size_t uiIndex) { base::RemoveAt(uiIndex); } \
|
||||
void Remove(T Item) \
|
||||
{ int iIndex = Index(Item); \
|
||||
wxCHECK2_MSG( iIndex != wxNOT_FOUND, return, \
|
||||
_WX_ERROR_REMOVE); \
|
||||
base::RemoveAt((size_t)iIndex); } \
|
||||
\
|
||||
void Sort(CMPFUNC##T fCmp) { base::Sort((CMPFUNC)fCmp); } \
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// _WX_DEFINE_SORTED_ARRAY: sorted array for simple data types
|
||||
// _WX_DEFINE_SORTED_TYPEARRAY: sorted array for simple data types
|
||||
// cannot handle types with size greater than pointer because of sorting
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#define _WX_DEFINE_SORTED_ARRAY(T, name, defcomp, classexp) \
|
||||
wxCOMPILE_TIME_ASSERT2(sizeof(T) <= sizeof(long), \
|
||||
TypeIsTooBigToBeStoredInWxArray, \
|
||||
name); \
|
||||
typedef int (CMPFUNC_CONV *SCMPFUNC##T)(T pItem1, T pItem2); \
|
||||
classexp name : public wxBaseArray \
|
||||
{ \
|
||||
public: \
|
||||
name(SCMPFUNC##T fn defcomp) { m_fnCompare = fn; } \
|
||||
\
|
||||
name& operator=(const name& src) \
|
||||
{ wxBaseArray* temp = (wxBaseArray*) this; \
|
||||
(*temp) = ((const wxBaseArray&)src); \
|
||||
m_fnCompare = src.m_fnCompare; \
|
||||
return *this; } \
|
||||
\
|
||||
T& operator[](size_t uiIndex) const \
|
||||
{ return (T&)(wxBaseArray::Item(uiIndex)); } \
|
||||
T& Item(size_t uiIndex) const \
|
||||
{ return (T&)(wxBaseArray::Item(uiIndex)); } \
|
||||
T& Last() const \
|
||||
{ return (T&)(wxBaseArray::Item(Count() - 1)); } \
|
||||
\
|
||||
int Index(T Item) const \
|
||||
{ return wxBaseArray::Index((long)Item, (CMPFUNC)m_fnCompare); }\
|
||||
\
|
||||
size_t IndexForInsert(T Item) const \
|
||||
{ return wxBaseArray::IndexForInsert((long)Item, \
|
||||
(CMPFUNC)m_fnCompare); } \
|
||||
\
|
||||
void AddAt(T item, size_t index) \
|
||||
{ wxBaseArray::Insert((long)item, index); } \
|
||||
\
|
||||
void Add(T Item) \
|
||||
{ wxBaseArray::Add((long)Item, (CMPFUNC)m_fnCompare); } \
|
||||
\
|
||||
void RemoveAt(size_t uiIndex) { wxBaseArray::RemoveAt(uiIndex); } \
|
||||
void Remove(T Item) \
|
||||
{ int iIndex = Index(Item); \
|
||||
wxCHECK2_MSG( iIndex != wxNOT_FOUND, return, \
|
||||
_WX_ERROR_REMOVE ); \
|
||||
wxBaseArray::RemoveAt((size_t)iIndex); } \
|
||||
\
|
||||
private: \
|
||||
SCMPFUNC##T m_fnCompare; \
|
||||
#define _WX_DEFINE_SORTED_TYPEARRAY(T, name, base, defcomp, classexp) \
|
||||
wxCOMPILE_TIME_ASSERT2(sizeof(T) <= sizeof(void *), \
|
||||
TypeTooBigToBeStoredInSorted##base, \
|
||||
name); \
|
||||
typedef int (CMPFUNC_CONV *SCMPFUNC##T)(T pItem1, T pItem2); \
|
||||
classexp name : public base \
|
||||
{ \
|
||||
public: \
|
||||
name(SCMPFUNC##T fn defcomp) { m_fnCompare = fn; } \
|
||||
\
|
||||
name& operator=(const name& src) \
|
||||
{ base* temp = (base*) this; \
|
||||
(*temp) = ((const base&)src); \
|
||||
m_fnCompare = src.m_fnCompare; \
|
||||
return *this; } \
|
||||
\
|
||||
T& operator[](size_t uiIndex) const \
|
||||
{ return (T&)(base::Item(uiIndex)); } \
|
||||
T& Item(size_t uiIndex) const \
|
||||
{ return (T&)(base::Item(uiIndex)); } \
|
||||
T& Last() const \
|
||||
{ return (T&)(base::Item(Count() - 1)); } \
|
||||
\
|
||||
int Index(T Item) const \
|
||||
{ return base::Index(Item, (CMPFUNC)m_fnCompare); } \
|
||||
\
|
||||
size_t IndexForInsert(T Item) const \
|
||||
{ return base::IndexForInsert(Item, (CMPFUNC)m_fnCompare); } \
|
||||
\
|
||||
void AddAt(T item, size_t index) \
|
||||
{ base::Insert(item, index); } \
|
||||
\
|
||||
void Add(T Item) \
|
||||
{ base::Add(Item, (CMPFUNC)m_fnCompare); } \
|
||||
\
|
||||
void RemoveAt(size_t uiIndex) { base::RemoveAt(uiIndex); } \
|
||||
void Remove(T Item) \
|
||||
{ int iIndex = Index(Item); \
|
||||
wxCHECK2_MSG( iIndex != wxNOT_FOUND, return, \
|
||||
_WX_ERROR_REMOVE ); \
|
||||
base::RemoveAt((size_t)iIndex); } \
|
||||
\
|
||||
private: \
|
||||
SCMPFUNC##T m_fnCompare; \
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// _WX_DECLARE_OBJARRAY: an array for pointers to type T with owning semantics
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#define _WX_DECLARE_OBJARRAY(T, name, classexp) \
|
||||
typedef int (CMPFUNC_CONV *CMPFUNC##T)(T** pItem1, T** pItem2); \
|
||||
classexp name : public wxBaseArray \
|
||||
{ \
|
||||
public: \
|
||||
name() { } \
|
||||
name(const name& src); \
|
||||
name& operator=(const name& src); \
|
||||
\
|
||||
~name(); \
|
||||
\
|
||||
T& operator[](size_t uiIndex) const \
|
||||
{ return *(T*)wxBaseArray::Item(uiIndex); } \
|
||||
T& Item(size_t uiIndex) const \
|
||||
{ return *(T*)wxBaseArray::Item(uiIndex); } \
|
||||
T& Last() const \
|
||||
{ return *(T*)(wxBaseArray::Item(Count() - 1)); } \
|
||||
\
|
||||
int Index(const T& Item, bool bFromEnd = FALSE) const; \
|
||||
\
|
||||
void Add(const T& Item); \
|
||||
void Add(const T* pItem) \
|
||||
{ wxBaseArray::Add((long)pItem); } \
|
||||
\
|
||||
void Insert(const T& Item, size_t uiIndex); \
|
||||
void Insert(const T* pItem, size_t uiIndex) \
|
||||
{ wxBaseArray::Insert((long)pItem, uiIndex); } \
|
||||
\
|
||||
void Empty() { DoEmpty(); wxBaseArray::Empty(); } \
|
||||
void Clear() { DoEmpty(); wxBaseArray::Clear(); } \
|
||||
\
|
||||
T* Detach(size_t uiIndex) \
|
||||
{ T* p = (T*)wxBaseArray::Item(uiIndex); \
|
||||
wxBaseArray::RemoveAt(uiIndex); return p; } \
|
||||
void RemoveAt(size_t uiIndex); \
|
||||
\
|
||||
void Sort(CMPFUNC##T fCmp) { wxBaseArray::Sort((CMPFUNC)fCmp); } \
|
||||
\
|
||||
private: \
|
||||
void DoEmpty(); \
|
||||
void DoCopy(const name& src); \
|
||||
#define _WX_DECLARE_OBJARRAY(T, name, base, classexp) \
|
||||
typedef int (CMPFUNC_CONV *CMPFUNC##T)(T **pItem1, T **pItem2); \
|
||||
classexp name : public base \
|
||||
{ \
|
||||
typedef int (CMPFUNC_CONV *CMPFUNC##base)(void **pItem1, void **pItem2); \
|
||||
public: \
|
||||
name() { } \
|
||||
name(const name& src); \
|
||||
name& operator=(const name& src); \
|
||||
\
|
||||
~name(); \
|
||||
\
|
||||
T& operator[](size_t uiIndex) const \
|
||||
{ return *(T*)base::Item(uiIndex); } \
|
||||
T& Item(size_t uiIndex) const \
|
||||
{ return *(T*)base::Item(uiIndex); } \
|
||||
T& Last() const \
|
||||
{ return *(T*)(base::Item(Count() - 1)); } \
|
||||
\
|
||||
int Index(const T& Item, bool bFromEnd = FALSE) const; \
|
||||
\
|
||||
void Add(const T& Item); \
|
||||
void Add(const T* pItem) \
|
||||
{ base::Add((T*)pItem); } \
|
||||
\
|
||||
void Insert(const T& Item, size_t uiIndex); \
|
||||
void Insert(const T* pItem, size_t uiIndex) \
|
||||
{ base::Insert((T*)pItem, uiIndex); } \
|
||||
\
|
||||
void Empty() { DoEmpty(); base::Empty(); } \
|
||||
void Clear() { DoEmpty(); base::Clear(); } \
|
||||
\
|
||||
T* Detach(size_t uiIndex) \
|
||||
{ T* p = (T*)base::Item(uiIndex); \
|
||||
base::RemoveAt(uiIndex); return p; } \
|
||||
void RemoveAt(size_t uiIndex); \
|
||||
\
|
||||
void Sort(CMPFUNC##T fCmp) { base::Sort((CMPFUNC##base)fCmp); } \
|
||||
\
|
||||
private: \
|
||||
void DoEmpty(); \
|
||||
void DoCopy(const name& src); \
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
@@ -343,25 +301,40 @@ private: \
|
||||
#define wxARRAY_DEFAULT_EXPORT
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// WX_DEFINE_ARRAY(T, name) define an array class named "name" containing the
|
||||
// elements of simple type T such that sizeof(T) <= sizeof(long)
|
||||
// WX_DECLARE_BASEARRAY(T, name) declare an array class named "name" containing
|
||||
// the elements of type T
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#define WX_DECLARE_BASEARRAY(T, name) \
|
||||
WX_DECLARE_USER_EXPORTED_BASEARRAY(T, name, wxARRAY_DEFAULT_EXPORT)
|
||||
|
||||
#define WX_DECLARE_EXPORTED_BASEARRAY(T, name) \
|
||||
WX_DECLARE_USER_EXPORTED_BASEARRAY(T, name, WXDLLEXPORT)
|
||||
|
||||
#define WX_DECLARE_USER_EXPORTED_BASEARRAY(T, name, expmode) \
|
||||
typedef T _wxArray##name; \
|
||||
_WX_DECLARE_BASEARRAY(_wxArray##name, name, class expmode)
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// WX_DEFINE_TYPEARRAY(T, name, base) define an array class named "name" deriving
|
||||
// from class "base" containing the elements of type T
|
||||
//
|
||||
// Note that the class defined has only inline function and doesn't take any
|
||||
// space at all so there is no size penalty for defining multiple array classes
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#define WX_DEFINE_ARRAY(T, name) \
|
||||
WX_DEFINE_USER_EXPORTED_ARRAY(T, name, wxARRAY_DEFAULT_EXPORT)
|
||||
#define WX_DEFINE_TYPEARRAY(T, name, base) \
|
||||
WX_DEFINE_USER_EXPORTED_TYPEARRAY(T, name, base, wxARRAY_DEFAULT_EXPORT)
|
||||
|
||||
#define WX_DEFINE_EXPORTED_ARRAY(T, name) \
|
||||
WX_DEFINE_USER_EXPORTED_ARRAY(T, name, WXDLLEXPORT)
|
||||
#define WX_DEFINE_EXPORTED_TYPEARRAY(T, name, base) \
|
||||
WX_DEFINE_USER_EXPORTED_TYPEARRAY(T, name, base, WXDLLEXPORT)
|
||||
|
||||
#define WX_DEFINE_USER_EXPORTED_ARRAY(T, name, expmode) \
|
||||
typedef T _wxArray##name; \
|
||||
_WX_DEFINE_ARRAY(_wxArray##name, name, class expmode)
|
||||
#define WX_DEFINE_USER_EXPORTED_TYPEARRAY(T, name, base, expmode) \
|
||||
typedef T _wxArray##name; \
|
||||
_WX_DEFINE_TYPEARRAY(_wxArray##name, name, base, class expmode)
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// WX_DEFINE_SORTED_ARRAY: this is the same as the previous macro, but it
|
||||
// WX_DEFINE_SORTED_TYPEARRAY: this is the same as the previous macro, but it
|
||||
// defines a sorted array.
|
||||
//
|
||||
// Differences:
|
||||
@@ -380,8 +353,8 @@ private: \
|
||||
//
|
||||
// Note that you have to specify the comparison function when creating the
|
||||
// objects of this array type. If, as in 99% of cases, the comparison function
|
||||
// is the same for all objects of a class, WX_DEFINE_SORTED_ARRAY_CMP below is
|
||||
// more convenient.
|
||||
// is the same for all objects of a class, WX_DEFINE_SORTED_TYPEARRAY_CMP below
|
||||
// is more convenient.
|
||||
//
|
||||
// Summary: use this class when the speed of Index() function is important, use
|
||||
// the normal arrays otherwise.
|
||||
@@ -389,38 +362,43 @@ private: \
|
||||
|
||||
#define wxARRAY_EMPTY_CMP
|
||||
|
||||
#define WX_DEFINE_SORTED_ARRAY(T, name) \
|
||||
WX_DEFINE_SORTED_USER_EXPORTED_ARRAY(T, name, wxARRAY_DEFAULT_EXPORT)
|
||||
#define WX_DEFINE_SORTED_TYPEARRAY(T, name, base) \
|
||||
WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, base, \
|
||||
wxARRAY_DEFAULT_EXPORT)
|
||||
|
||||
#define WX_DEFINE_SORTED_EXPORTED_ARRAY(T, name) \
|
||||
WX_DEFINE_SORTED_USER_EXPORTED_ARRAY(T, name, WXDLLEXPORT)
|
||||
#define WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, base) \
|
||||
WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, base, WXDLLEXPORT)
|
||||
|
||||
#define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY(T, name, expmode) \
|
||||
typedef T _wxArray##name; \
|
||||
_WX_DEFINE_SORTED_ARRAY(_wxArray##name, name, wxARRAY_EMPTY_CMP, class expmode)
|
||||
#define WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, base, expmode) \
|
||||
typedef T _wxArray##name; \
|
||||
_WX_DEFINE_SORTED_TYPEARRAY(_wxArray##name, name, base, \
|
||||
wxARRAY_EMPTY_CMP, class expmode)
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// WX_DEFINE_SORTED_ARRAY_CMP: exactly the same as above but the comparison
|
||||
// WX_DEFINE_SORTED_TYPEARRAY_CMP: exactly the same as above but the comparison
|
||||
// function is provided by this macro and the objects of this class have a
|
||||
// default constructor which just uses it.
|
||||
//
|
||||
// The arguments are: the element type, the comparison function and the array
|
||||
// name
|
||||
//
|
||||
// NB: this is, of course, how WX_DEFINE_SORTED_ARRAY() should have worked from
|
||||
// the very beginning - unfortunately I didn't think about this earlier :-(
|
||||
// NB: this is, of course, how WX_DEFINE_SORTED_TYPEARRAY() should have worked
|
||||
// from the very beginning - unfortunately I didn't think about this earlier
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#define WX_DEFINE_SORTED_ARRAY_CMP(T, cmpfunc, name) \
|
||||
WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP(T, cmpfunc, name, \
|
||||
wxARRAY_DEFAULT_EXPORT)
|
||||
#define WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, base) \
|
||||
WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base, \
|
||||
wxARRAY_DEFAULT_EXPORT)
|
||||
|
||||
#define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP(T, cmpfunc, name) \
|
||||
WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP(T, cmpfunc, name, WXDLLEXPORT)
|
||||
#define WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base) \
|
||||
WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base, \
|
||||
WXDLLEXPORT)
|
||||
|
||||
#define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP(T, cmpfunc, name, expmode) \
|
||||
#define WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, base, \
|
||||
expmode) \
|
||||
typedef T _wxArray##name; \
|
||||
_WX_DEFINE_SORTED_ARRAY(_wxArray##name, name, = cmpfunc, class expmode)
|
||||
_WX_DEFINE_SORTED_TYPEARRAY(_wxArray##name, name, base, = cmpfunc, \
|
||||
class expmode)
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// WX_DECLARE_OBJARRAY(T, name): this macro generates a new array class
|
||||
@@ -431,7 +409,6 @@ private: \
|
||||
// and T& is returned.
|
||||
//
|
||||
// Don't use this for simple types such as "int" or "long"!
|
||||
// You _may_ use it for "double" but it's awfully inefficient.
|
||||
//
|
||||
// Note on Add/Insert functions:
|
||||
// 1) function(T*) gives the object to the array, i.e. it will delete the
|
||||
@@ -450,7 +427,6 @@ private: \
|
||||
// define new class from this template even if you don't use it - which is not
|
||||
// the case for the simple (non-object) array classes
|
||||
//
|
||||
//
|
||||
// To use an objarray class you must
|
||||
// #include "dynarray.h"
|
||||
// WX_DECLARE_OBJARRAY(element_type, list_class_name)
|
||||
@@ -472,7 +448,7 @@ private: \
|
||||
|
||||
#define WX_DECLARE_USER_EXPORTED_OBJARRAY(T, name, expmode) \
|
||||
typedef T _wxObjArray##name; \
|
||||
_WX_DECLARE_OBJARRAY(_wxObjArray##name, name, class expmode)
|
||||
_WX_DECLARE_OBJARRAY(_wxObjArray##name, name, wxArrayPtrVoid, class expmode)
|
||||
|
||||
// WX_DEFINE_OBJARRAY is going to be redefined when arrimpl.cpp is included,
|
||||
// try to provoke a human-understandable error if it used incorrectly.
|
||||
@@ -483,13 +459,135 @@ private: \
|
||||
#define WX_DEFINE_EXPORTED_OBJARRAY(name) WX_DEFINE_OBJARRAY(name)
|
||||
#define WX_DEFINE_USER_EXPORTED_OBJARRAY(name) WX_DEFINE_OBJARRAY(name)
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Some commonly used predefined base arrays
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
WX_DECLARE_EXPORTED_BASEARRAY(void *, wxBaseArrayPtrVoid);
|
||||
WX_DECLARE_EXPORTED_BASEARRAY(short, wxBaseArrayShort);
|
||||
WX_DECLARE_EXPORTED_BASEARRAY(int, wxBaseArrayInt);
|
||||
WX_DECLARE_EXPORTED_BASEARRAY(long, wxBaseArrayLong);
|
||||
WX_DECLARE_EXPORTED_BASEARRAY(double, wxBaseArrayDouble);
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Convenience macros to define arrays from base arrays
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#define WX_DEFINE_ARRAY(T, name) \
|
||||
WX_DEFINE_TYPEARRAY(T, name, wxBaseArrayPtrVoid)
|
||||
#define WX_DEFINE_EXPORTED_ARRAY(T, name) \
|
||||
WX_DEFINE_EXPORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid)
|
||||
#define WX_DEFINE_USER_EXPORTED_ARRAY(T, name, expmode) \
|
||||
WX_DEFINE_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid, expmode)
|
||||
|
||||
#define WX_DEFINE_ARRAY_SHORT(T, name) \
|
||||
WX_DEFINE_TYPEARRAY(T, name, wxBaseArrayShort)
|
||||
#define WX_DEFINE_EXPORTED_ARRAY_SHORT(T, name) \
|
||||
WX_DEFINE_EXPORTED_TYPEARRAY(T, name, wxBaseArrayShort)
|
||||
#define WX_DEFINE_USER_EXPORTED_ARRAY_SHORT(T, name, expmode) \
|
||||
WX_DEFINE_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayShort, expmode)
|
||||
|
||||
#define WX_DEFINE_ARRAY_INT(T, name) \
|
||||
WX_DEFINE_TYPEARRAY(T, name, wxBaseArrayInt)
|
||||
#define WX_DEFINE_EXPORTED_ARRAY_INT(T, name) \
|
||||
WX_DEFINE_EXPORTED_TYPEARRAY(T, name, wxBaseArrayInt)
|
||||
#define WX_DEFINE_USER_EXPORTED_ARRAY_INT(T, name, expmode) \
|
||||
WX_DEFINE_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayInt, expmode)
|
||||
|
||||
#define WX_DEFINE_ARRAY_LONG(T, name) \
|
||||
WX_DEFINE_TYPEARRAY(T, name, wxBaseArrayLong)
|
||||
#define WX_DEFINE_EXPORTED_ARRAY_LONG(T, name) \
|
||||
WX_DEFINE_EXPORTED_TYPEARRAY(T, name, wxBaseArrayLong)
|
||||
#define WX_DEFINE_USER_EXPORTED_ARRAY_LONG(T, name, expmode) \
|
||||
WX_DEFINE_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayLong, expmode)
|
||||
|
||||
#define WX_DEFINE_ARRAY_DOUBLE(T, name) \
|
||||
WX_DEFINE_TYPEARRAY(T, name, wxBaseArrayDouble)
|
||||
#define WX_DEFINE_EXPORTED_ARRAY_DOUBLE(T, name) \
|
||||
WX_DEFINE_EXPORTED_TYPEARRAY(T, name, wxBaseArrayDouble)
|
||||
#define WX_DEFINE_USER_EXPORTED_ARRAY_DOUBLE(T, name, expmode) \
|
||||
WX_DEFINE_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayDouble, expmode)
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Convenience macros to define sorted arrays from base arrays
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#define WX_DEFINE_SORTED_ARRAY(T, name) \
|
||||
WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid)
|
||||
#define WX_DEFINE_SORTED_EXPORTED_ARRAY(T, name) \
|
||||
WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid)
|
||||
#define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY(T, name, expmode) \
|
||||
WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayPtrVoid, expmode)
|
||||
|
||||
#define WX_DEFINE_SORTED_ARRAY_SHORT(T, name) \
|
||||
WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArrayShort)
|
||||
#define WX_DEFINE_SORTED_EXPORTED_ARRAY_SHORT(T, name) \
|
||||
WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArrayShort)
|
||||
#define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_SHORT(T, name, expmode) \
|
||||
WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayShort, expmode)
|
||||
|
||||
#define WX_DEFINE_SORTED_ARRAY_INT(T, name) \
|
||||
WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArrayInt)
|
||||
#define WX_DEFINE_SORTED_EXPORTED_ARRAY_INT(T, name) \
|
||||
WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArrayInt)
|
||||
#define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_INT(T, name, expmode) \
|
||||
WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayInt, expmode)
|
||||
|
||||
#define WX_DEFINE_SORTED_ARRAY_LONG(T, name) \
|
||||
WX_DEFINE_SORTED_TYPEARRAY(T, name, wxBaseArrayLong)
|
||||
#define WX_DEFINE_SORTED_EXPORTED_ARRAY_LONG(T, name) \
|
||||
WX_DEFINE_SORTED_EXPORTED_TYPEARRAY(T, name, wxBaseArrayLong)
|
||||
#define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_LONG(T, name, expmode) \
|
||||
WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY(T, name, wxBaseArrayLong, expmode)
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Convenience macros to define sorted arrays from base arrays
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#define WX_DEFINE_SORTED_ARRAY_CMP(T, cmpfunc, name) \
|
||||
WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayPtrVoid)
|
||||
#define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP(T, cmpfunc, name) \
|
||||
WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayPtrVoid)
|
||||
#define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP(T, cmpfunc, \
|
||||
name, expmode) \
|
||||
WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, \
|
||||
wxBaseArrayPtrVoid, expmode)
|
||||
|
||||
#define WX_DEFINE_SORTED_ARRAY_CMP_SHORT(T, cmpfunc, name) \
|
||||
WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayShort)
|
||||
#define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP_SHORT(T, cmpfunc, name) \
|
||||
WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayShort)
|
||||
#define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP_SHORT(T, cmpfunc, \
|
||||
name, expmode) \
|
||||
WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, \
|
||||
wxBaseArrayShort, expmode)
|
||||
|
||||
#define WX_DEFINE_SORTED_ARRAY_CMP_INT(T, cmpfunc, name) \
|
||||
WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayInt)
|
||||
#define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP_INT(T, cmpfunc, name) \
|
||||
WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayInt)
|
||||
#define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP_INT(T, cmpfunc, \
|
||||
name, expmode) \
|
||||
WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, \
|
||||
wxBaseArrayInt, expmode)
|
||||
|
||||
#define WX_DEFINE_SORTED_ARRAY_CMP_LONG(T, cmpfunc, name) \
|
||||
WX_DEFINE_SORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayLong)
|
||||
#define WX_DEFINE_SORTED_EXPORTED_ARRAY_CMP_LONG(T, cmpfunc, name) \
|
||||
WX_DEFINE_SORTED_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, wxBaseArrayLong)
|
||||
#define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP_LONG(T, cmpfunc, \
|
||||
name, expmode) \
|
||||
WX_DEFINE_SORTED_USER_EXPORTED_TYPEARRAY_CMP(T, cmpfunc, name, \
|
||||
wxBaseArrayLong, expmode)
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Some commonly used predefined arrays
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
WX_DEFINE_EXPORTED_ARRAY(int, wxArrayInt);
|
||||
WX_DEFINE_EXPORTED_ARRAY(long, wxArrayLong);
|
||||
WX_DEFINE_EXPORTED_ARRAY(void *, wxArrayPtrVoid);
|
||||
WX_DEFINE_EXPORTED_ARRAY_SHORT (short, wxArrayShort);
|
||||
WX_DEFINE_EXPORTED_ARRAY_INT (int, wxArrayInt);
|
||||
WX_DEFINE_EXPORTED_ARRAY_LONG (long, wxArrayLong);
|
||||
WX_DEFINE_EXPORTED_ARRAY (void *, wxArrayPtrVoid);
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// convenience macros
|
||||
|
||||
Reference in New Issue
Block a user