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

cleaned up the arrays declaration macros and added a new SORTED_ARRAY_CMP family; added tests for them to the console sample

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@14036 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
2002-02-06 20:12:24 +00:00
parent cfb20656e1
commit 1a931653f8
3 changed files with 315 additions and 263 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
include/wx/arrimpl.cpp
View File

@@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
// Name: listimpl.cpp // Name: wx/arrimpl.cpp
// Purpose: helper file for implementation of dynamic lists // Purpose: helper file for implementation of dynamic lists
// Author: Vadim Zeitlin // Author: Vadim Zeitlin
// Modified by: // Modified by:
@@ -112,4 +112,4 @@ int name::Index(const T& Item, bool bFromEnd) const \
// redefine the macro so that now it will generate the class implementation // redefine the macro so that now it will generate the class implementation
// old value would provoke a compile-time error if this file is not included // old value would provoke a compile-time error if this file is not included
#undef WX_DEFINE_OBJARRAY #undef WX_DEFINE_OBJARRAY
#define WX_DEFINE_OBJARRAY(name) _DEFINE_OBJARRAY(_L##name, name) #define WX_DEFINE_OBJARRAY(name) _DEFINE_OBJARRAY(_wxObjArray##name, name)

430
include/wx/dynarray.h
View File

@@ -18,29 +18,48 @@
#include "wx/defs.h" #include "wx/defs.h"
/** @name Dynamic arrays and object arrays (array which own their elements) /*
@memo Arrays which grow on demand and do range checking (only in debug) This header defines the dynamic arrays and object arrays (i.e. arrays which
*/ own their elements). Dynamic means that the arrays grow automatically as
//@{ needed.
These macros are ugly (especially if you look in the sources ;-), but they
allow us to define "template" classes without actually using templates and so
this works with all compilers (and may be also much faster to compile even
with a compiler which does support templates). The arrays defined with these
macros are type-safe.
Range checking is performed in debug build for both arrays and objarrays but
not in release build - so using an invalid index will just lead to a crash
then.
Note about memory usage: arrays never shrink automatically (although you may
use Shrink() function explicitly), they only grow, so loading 10 millions in
an array only to delete them 2 lines below might be a bad idea if the array
object is not going to be destroyed soon. However, as it does free memory
when destroyed, it is ok if the array is a local variable.
*/
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// constants // constants
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
/** /*
the initial size by which an array grows when an element is added The initial size by which an array grows when an element is added default
default value avoids allocate one or two bytes when the array is created value avoids allocate one or two bytes when the array is created which is
which is rather inefficient rather inefficient
*/ */
#define WX_ARRAY_DEFAULT_INITIAL_SIZE (16) #define WX_ARRAY_DEFAULT_INITIAL_SIZE (16)
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// types // types
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
/** /*
callback compare function for quick sort Callback compare function for quick sort.
must return negative value, 0 or positive value if pItem1 <, = or > pItem2
It must return negative value, 0 or positive value if the first item is
less than, equal to or greater than the second one.
*/ */
extern "C" extern "C"
{ {
@@ -48,18 +67,15 @@ typedef int (wxCMPFUNC_CONV *CMPFUNC)(const void* pItem1, const void* pItem2);
} }
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
/** // Base class managing data having size of type 'long' (not used directly)
base class managing data having size of type 'long' (not used directly) //
// NB: for efficiency this often used class has no virtual functions (hence no
NB: for efficiency this often used class has no virtual functions (hence no // virtual table), even dtor is *not* virtual. If used as expected it
VTBL), even dtor is <B>not</B> virtual. If used as expected it won't // won't create any problems because ARRAYs from DEFINE_ARRAY have no dtor
create any problems because ARRAYs from DEFINE_ARRAY have no dtor at all, // at all, so it's not too important if it's not called (this happens when
so it's not too important if it's not called (this happens when you cast // you cast "SomeArray *" as "BaseArray *" and then delete it)
"SomeArray *" as "BaseArray *" and then delete it)
@memo Base class for template array classes
*/
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLEXPORT wxBaseArray class WXDLLEXPORT wxBaseArray
{ {
public: public:
@@ -90,10 +106,11 @@ public:
/** @name simple accessors */ /** @name simple accessors */
//@{ //@{
/// number of elements in the array /// number of elements in the array
size_t Count() const { return m_nCount; } size_t GetCount() const { return m_nCount; }
size_t GetCount() const { return m_nCount; }
/// is it empty? /// is it empty?
bool IsEmpty() const { return m_nCount == 0; } bool IsEmpty() const { return m_nCount == 0; }
/// this version is obsolete, use GetCount()
size_t Count() const { return m_nCount; }
//@} //@}
protected: protected:
@@ -148,37 +165,35 @@ private:
}; };
// ============================================================================ // ============================================================================
// template classes // The private helper macros containing the core of the array classes
// ============================================================================ // ============================================================================
// resolves the name conflict between the wxT() macor and T typedef: we can't // Implementation notes:
// use wxT() inside WX_DEFINE_ARRAY! //
#define _WX_ERROR_SIZEOF wxT("illegal use of DEFINE_ARRAY") // JACS: Salford C++ doesn't like 'var->operator=' syntax, as in:
#define _WX_ERROR_REMOVE wxT("removing inexisting element in wxArray::Remove") // { ((wxBaseArray *)this)->operator=((const wxBaseArray&)src);
// so using a temporary variable instead.
//
// 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!
#define _WX_ERROR_REMOVE wxT("removing inexisting element in wxArray::Remove")
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// This macro generates a new array class. It is intended for storage of simple // _WX_DEFINE_ARRAY: array for simple types
// types of sizeof()<=sizeof(long) or pointers if sizeof(pointer)<=sizeof(long)
//
// NB: it has only inline functions => takes no space at all
// Mod by JACS: Salford C++ doesn't like 'var->operator=' syntax, as in:
// { ((wxBaseArray *)this)->operator=((const wxBaseArray&)src);
// so using a temporary variable instead.
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// __MAC_X__ added min ~name() below for compiling Mac X
#define _WX_DEFINE_ARRAY(T, name, classexp) \ #define _WX_DEFINE_ARRAY(T, name, classexp) \
wxCOMPILE_TIME_ASSERT(sizeof(T) <= sizeof(long), \
TypeIsTooBigToBeStoredInWxArray); \
typedef int (CMPFUNC_CONV *CMPFUNC##T)(T *pItem1, T *pItem2); \ typedef int (CMPFUNC_CONV *CMPFUNC##T)(T *pItem1, T *pItem2); \
classexp name : public wxBaseArray \ classexp name : public wxBaseArray \
{ \ { \
public: \ public: \
name() \ name() { } \
{ \ ~name() { } \
size_t type = sizeof(T); \
size_t sizelong = sizeof(long); \
if ( type > sizelong ) \
{ wxFAIL_MSG( _WX_ERROR_SIZEOF ); } \
} \
~name() {} \
\ \
name& operator=(const name& src) \ name& operator=(const name& src) \
{ wxBaseArray* temp = (wxBaseArray*) this; \ { wxBaseArray* temp = (wxBaseArray*) this; \
@@ -211,41 +226,17 @@ public: \
} }
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// This is the same as the previous macro, but it defines a sorted array. // _WX_DEFINE_SORTED_ARRAY: sorted array for simple data types
// Differences:
// 1) it must be given a COMPARE function in ctor which takes 2 items of type
// T* and should return -1, 0 or +1 if the first one is less/greater
// than/equal to the second one.
// 2) the Add() method inserts the item in such was that the array is always
// sorted (it uses the COMPARE function)
// 3) it has no Sort() method because it's always sorted
// 4) Index() method is much faster (the sorted arrays use binary search
// instead of linear one), but Add() is slower.
// 5) there is no Insert() method because you can't insert an item into the
// given position in a sorted array but there is IndexForInsert()/AddAt()
// pair which may be used to optimize a common operation of "insert only if
// not found"
//
// Summary: use this class when the speed of Index() function is important, use
// the normal arrays otherwise.
//
// NB: it has only inline functions => takes no space at all
// Mod by JACS: Salford C++ doesn't like 'var->operator=' syntax, as in:
// { ((wxBaseArray *)this)->operator=((const wxBaseArray&)src);
// so using a temporary variable instead.
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
#define _WX_DEFINE_SORTED_ARRAY(T, name, classexp) \
#define _WX_DEFINE_SORTED_ARRAY(T, name, defcomp, classexp) \
wxCOMPILE_TIME_ASSERT(sizeof(T) <= sizeof(long), \
TypeIsTooBigToBeStoredInWxArray); \
typedef int (CMPFUNC_CONV *SCMPFUNC##T)(T pItem1, T pItem2); \ typedef int (CMPFUNC_CONV *SCMPFUNC##T)(T pItem1, T pItem2); \
classexp name : public wxBaseArray \ classexp name : public wxBaseArray \
{ \ { \
public: \ public: \
name(SCMPFUNC##T fn) \ name(SCMPFUNC##T fn defcomp) { m_fnCompare = fn; } \
{ size_t type = sizeof(T); \
size_t sizelong = sizeof(long); \
if ( type > sizelong ) \
{ wxFAIL_MSG( _WX_ERROR_SIZEOF ); } \
m_fnCompare = fn; \
} \
\ \
name& operator=(const name& src) \ name& operator=(const name& src) \
{ wxBaseArray* temp = (wxBaseArray*) this; \ { wxBaseArray* temp = (wxBaseArray*) this; \
@@ -285,8 +276,9 @@ private: \
} }
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// see WX_DECLARE_OBJARRAY and WX_DEFINE_OBJARRAY // _WX_DECLARE_OBJARRAY: an array for pointers to type T with owning semantics
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
#define _WX_DECLARE_OBJARRAY(T, name, classexp) \ #define _WX_DECLARE_OBJARRAY(T, name, classexp) \
typedef int (CMPFUNC_CONV *CMPFUNC##T)(T** pItem1, T** pItem2); \ typedef int (CMPFUNC_CONV *CMPFUNC##T)(T** pItem1, T** pItem2); \
classexp name : public wxBaseArray \ classexp name : public wxBaseArray \
@@ -318,7 +310,7 @@ public: \
void Empty() { DoEmpty(); wxBaseArray::Empty(); } \ void Empty() { DoEmpty(); wxBaseArray::Empty(); } \
void Clear() { DoEmpty(); wxBaseArray::Clear(); } \ void Clear() { DoEmpty(); wxBaseArray::Clear(); } \
\ \
T* Detach(size_t uiIndex) \ T* Detach(size_t uiIndex) \
{ T* p = (T*)wxBaseArray::Item(uiIndex); \ { T* p = (T*)wxBaseArray::Item(uiIndex); \
wxBaseArray::RemoveAt(uiIndex); return p; } \ wxBaseArray::RemoveAt(uiIndex); return p; } \
void RemoveAt(size_t uiIndex); \ void RemoveAt(size_t uiIndex); \
@@ -330,148 +322,170 @@ private: \
void DoCopy(const name& src); \ void DoCopy(const name& src); \
} }
// ---------------------------------------------------------------------------- // ============================================================================
/** @name Macros for definition of dynamic arrays and objarrays // The public macros for declaration and definition of the dynamic arrays
// ============================================================================
These macros are ugly (especially if you look in the sources ;-), but they // Please note that for each macro WX_FOO_ARRAY we also have
allow us to define 'template' classes without actually using templates. // WX_FOO_EXPORTED_ARRAY and WX_FOO_USER_EXPORTED_ARRAY which are exactly the
<BR> // same except that they use an additional __declspec(dllexport) or equivalent
<BR> // under Windows if needed.
Range checking is performed in debug build for both arrays and objarrays. //
Type checking is done at compile-time. Warning: arrays <I>never</I> shrink, // The first (just EXPORTED) macros do it if wxWindows was compiled as a DLL
they only grow, so loading 10 millions in an array only to delete them 2 // and so must be used used inside the library. The second kind (USER_EXPORTED)
lines below is <I>not</I> recommended. However, it does free memory when // allow the user code to do it when it wants. This is needed if you have a dll
it's destroyed, so if you destroy array also, it's ok.
*/
// ----------------------------------------------------------------------------
//@{
/**
This macro generates a new array class. It is intended for storage of simple
types of sizeof()<=sizeof(long) or pointers if sizeof(pointer)<=sizeof(long)
<BR>
NB: it has only inline functions => takes no space at all
<BR>
@memo declare and define array class 'name' containing elements of type 'T'
*/
#define WX_DEFINE_ARRAY(T, name) \
typedef T _A##name; \
_WX_DEFINE_ARRAY(_A##name, name, class)
/**
This macro does the same as WX_DEFINE_ARRAY except that the array will be
sorted with the specified compare function.
*/
#define WX_DEFINE_SORTED_ARRAY(T, name) \
typedef T _A##name; \
_WX_DEFINE_SORTED_ARRAY(_A##name, name, class)
/**
This macro generates a new objarrays class which owns the objects it
contains, i.e. it will delete them when it is destroyed. An element is of
type T*, but arguments of type T& are taken (see below!) and T& is
returned. <BR>
Don't use this for simple types such as "int" or "long"!
You _may_ use it for "double" but it's awfully inefficient.
<BR>
<BR>
Note on Add/Insert functions:
<BR>
1) function(T*) gives the object to the array, i.e. it will delete the
object when it's removed or in the array's dtor
<BR>
2) function(T&) will create a copy of the object and work with it
<BR>
<BR>
Also:
<BR>
1) Remove() will delete the object after removing it from the array
<BR>
2) Detach() just removes the object from the array (returning pointer to it)
<BR>
<BR>
NB1: Base type T should have an accessible copy ctor if Add(T&) is used,
<BR>
NB2: Never ever cast a array to it's base type: as dtor is <B>not</B> virtual
it will provoke memory leaks
<BR>
<BR>
some functions of this class are not inline, so it takes some space to
define new class from this template.
@memo declare objarray class 'name' containing elements of type 'T'
*/
#define WX_DECLARE_OBJARRAY(T, name) \
typedef T _L##name; \
_WX_DECLARE_OBJARRAY(_L##name, name, class)
/**
To use an objarray class you must
<ll>
<li>#include "dynarray.h"
<li>WX_DECLARE_OBJARRAY(element_type, list_class_name)
<li>#include "arrimpl.cpp"
<li>WX_DEFINE_OBJARRAY(list_class_name) // same as above!
</ll>
<BR><BR>
This is necessary because at the moment of DEFINE_OBJARRAY class
element_type must be fully defined (i.e. forward declaration is not
enough), while WX_DECLARE_OBJARRAY may be done anywhere. The separation of
two allows to break cicrcular dependencies with classes which have member
variables of objarray type.
@memo define (must include arrimpl.cpp!) objarray class 'name'
*/
#define WX_DEFINE_OBJARRAY(name) "don't forget to include arrimpl.cpp!"
//@}
// these macros do the same thing as the WX_XXX ones above, but should be used
// inside the library for user visible classes because otherwise they wouldn't
// be visible from outside (when using wxWindows as DLL under Windows)
#define WX_DEFINE_EXPORTED_ARRAY(T, name) \
typedef T _A##name; \
_WX_DEFINE_ARRAY(_A##name, name, class WXDLLEXPORT)
#define WX_DEFINE_SORTED_EXPORTED_ARRAY(T, name) \
typedef T _A##name; \
_WX_DEFINE_SORTED_ARRAY(_A##name, name, class WXDLLEXPORT)
#define WX_DEFINE_EXPORTED_OBJARRAY(name) WX_DEFINE_OBJARRAY(name)
#define WX_DECLARE_EXPORTED_OBJARRAY(T, name) \
typedef T _L##name; \
_WX_DECLARE_OBJARRAY(_L##name, name, class WXDLLEXPORT)
// ..and likewise these macros do very same thing as the ones above them too,
// but allow the user to specify the export spec. Needed if you have a dll
// that wants to export a wxArray daubed with your own import/export goo. // that wants to export a wxArray daubed with your own import/export goo.
#define WX_DEFINE_USER_EXPORTED_ARRAY(T, name, usergoo) \ //
typedef T _A##name; \ // Finally, you can define the macro below as something special to modify the
_WX_DEFINE_ARRAY(_A##name, name, class usergoo) // arrays defined by a simple WX_FOO_ARRAY as well. By default is is empty.
#define wxARRAY_DEFAULT_EXPORT
#define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY(T, name, usergoo) \ // ----------------------------------------------------------------------------
typedef T _A##name; \ // WX_DEFINE_ARRAY(T, name) define an array class named "name" containing the
_WX_DEFINE_SORTED_ARRAY(_A##name, name, class usergoo) // elements of simple type T such that sizeof(T) <= sizeof(long)
//
// 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_EXPORTED_ARRAY(T, name) \
WX_DEFINE_USER_EXPORTED_ARRAY(T, name, WXDLLEXPORT)
#define WX_DEFINE_USER_EXPORTED_ARRAY(T, name, expmode) \
typedef T _wxArray##name; \
_WX_DEFINE_ARRAY(_wxArray##name, name, class expmode)
// ----------------------------------------------------------------------------
// WX_DEFINE_SORTED_ARRAY: this is the same as the previous macro, but it
// defines a sorted array.
//
// Differences:
// 1) it must be given a COMPARE function in ctor which takes 2 items of type
// T* and should return -1, 0 or +1 if the first one is less/greater
// than/equal to the second one.
// 2) the Add() method inserts the item in such was that the array is always
// sorted (it uses the COMPARE function)
// 3) it has no Sort() method because it's always sorted
// 4) Index() method is much faster (the sorted arrays use binary search
// instead of linear one), but Add() is slower.
// 5) there is no Insert() method because you can't insert an item into the
// given position in a sorted array but there is IndexForInsert()/AddAt()
// pair which may be used to optimize a common operation of "insert only if
// not found"
//
// 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.
//
// Summary: use this class when the speed of Index() function is important, use
// the normal arrays otherwise.
// ----------------------------------------------------------------------------
#define WX_DEFINE_SORTED_ARRAY(T, name) \
WX_DEFINE_SORTED_USER_EXPORTED_ARRAY(T, name, wxARRAY_DEFAULT_EXPORT)
#define WX_DEFINE_SORTED_EXPORTED_ARRAY(T, name) \
WX_DEFINE_SORTED_USER_EXPORTED_ARRAY(T, name, WXDLLEXPORT)
#define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY(T, name, expmode) \
typedef T _wxArray##name; \
_WX_DEFINE_SORTED_ARRAY(_wxArray##name, name, /* */, class expmode)
// ----------------------------------------------------------------------------
// WX_DEFINE_SORTED_ARRAY_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 :-(
// ----------------------------------------------------------------------------
#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_EXPORTED_ARRAY_CMP(T, cmpfunc, name) \
WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP(T, cmpfunc, name, WXDLLEXPORT)
#define WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_CMP(T, cmpfunc, name, expmode) \
typedef T _wxArray##name; \
_WX_DEFINE_SORTED_ARRAY(_wxArray##name, name, = cmpfunc, class expmode)
// ----------------------------------------------------------------------------
// WX_DECLARE_OBJARRAY(T, name): this macro generates a new array class
// named "name" which owns the objects of type T it contains, i.e. it will
// delete them when it is destroyed.
//
// An element is of type T*, but arguments of type T& are taken (see below!)
// 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
// object when it's removed or in the array's dtor
// 2) function(T&) will create a copy of the object and work with it
//
// Also:
// 1) Remove() will delete the object after removing it from the array
// 2) Detach() just removes the object from the array (returning pointer to it)
//
// NB1: Base type T should have an accessible copy ctor if Add(T&) is used
// NB2: Never ever cast a array to it's base type: as dtor is not virtual
// and so you risk having at least the memory leaks and probably worse
//
// Some functions of this class are not inline, so it takes some space to
// 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)
// #include "arrimpl.cpp"
// WX_DEFINE_OBJARRAY(list_class_name) // name must be the same as above!
//
// This is necessary because at the moment of DEFINE_OBJARRAY class parsing the
// element_type must be fully defined (i.e. forward declaration is not
// enough), while WX_DECLARE_OBJARRAY may be done anywhere. The separation of
// two allows to break cicrcular dependencies with classes which have member
// variables of objarray type.
// ----------------------------------------------------------------------------
#define WX_DECLARE_OBJARRAY(T, name) \
WX_DECLARE_USER_EXPORTED_OBJARRAY(T, name, wxARRAY_DEFAULT_EXPORT)
#define WX_DECLARE_EXPORTED_OBJARRAY(T, name) \
WX_DECLARE_USER_EXPORTED_OBJARRAY(T, name, WXDLLEXPORT)
#define WX_DECLARE_USER_EXPORTED_OBJARRAY(T, name, expmode) \
typedef T _wxObjArray##name; \
_WX_DECLARE_OBJARRAY(_wxObjArray##name, name, 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.
//
// there is no real need for 3 different macros in the DEFINE case but do it
// anyhow for consistency
#define WX_DEFINE_OBJARRAY(name) DidYouIncludeArrimplCpp
#define WX_DEFINE_EXPORTED_OBJARRAY(name) WX_DEFINE_OBJARRAY(name)
#define WX_DEFINE_USER_EXPORTED_OBJARRAY(name) WX_DEFINE_OBJARRAY(name) #define WX_DEFINE_USER_EXPORTED_OBJARRAY(name) WX_DEFINE_OBJARRAY(name)
#define WX_DECLARE_USER_EXPORTED_OBJARRAY(T, name, usergoo) \
typedef T _L##name; \
_WX_DECLARE_OBJARRAY(_L##name, name, class usergoo)
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
/** @name Some commonly used predefined arrays */ // Some commonly used predefined arrays
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
//@{
/** @name ArrayInt */
WX_DEFINE_EXPORTED_ARRAY(int, wxArrayInt); WX_DEFINE_EXPORTED_ARRAY(int, wxArrayInt);
/** @name ArrayLong */
WX_DEFINE_EXPORTED_ARRAY(long, wxArrayLong); WX_DEFINE_EXPORTED_ARRAY(long, wxArrayLong);
/** @name ArrayPtrVoid */
WX_DEFINE_EXPORTED_ARRAY(void *, wxArrayPtrVoid); WX_DEFINE_EXPORTED_ARRAY(void *, wxArrayPtrVoid);
//@}
//@}
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
// convenience macros // convenience macros

144
samples/console/console.cpp
View File

@@ -90,7 +90,7 @@
#undef TEST_ALL #undef TEST_ALL
static const bool TEST_ALL = TRUE; static const bool TEST_ALL = TRUE;
#else #else
#define TEST_THREADS #define TEST_ARRAYS
static const bool TEST_ALL = FALSE; static const bool TEST_ALL = FALSE;
#endif #endif
@@ -4852,6 +4852,38 @@ static void TestThreadConditions()
#ifdef TEST_ARRAYS #ifdef TEST_ARRAYS
#include "wx/dynarray.h"
#define DefineCompare(name, T) \
\
int wxCMPFUNC_CONV name ## CompareValues(T first, T second) \
{ \
return first - second; \
} \
\
int wxCMPFUNC_CONV name ## Compare(T* first, T* second) \
{ \
return *first - *second; \
} \
\
int wxCMPFUNC_CONV name ## RevCompare(T* first, T* second) \
{ \
return *second - *first; \
} \
DefineCompare(Short, short);
DefineCompare(Int, int);
// test compilation of all macros
WX_DEFINE_ARRAY(short, wxArrayShort);
WX_DEFINE_SORTED_ARRAY(short, wxSortedArrayShortNoCmp);
WX_DEFINE_SORTED_ARRAY_CMP(short, ShortCompareValues, wxSortedArrayShort);
WX_DEFINE_SORTED_ARRAY_CMP(int, IntCompareValues, wxSortedArrayInt);
WX_DECLARE_OBJARRAY(Bar, ArrayBars);
#include "wx/arrimpl.cpp"
WX_DEFINE_OBJARRAY(ArrayBars);
static void PrintArray(const char* name, const wxArrayString& array) static void PrintArray(const char* name, const wxArrayString& array)
{ {
printf("Dump of the array '%s'\n", name); printf("Dump of the array '%s'\n", name);
@@ -4863,62 +4895,69 @@ static void PrintArray(const char* name, const wxArrayString& array)
} }
} }
static void PrintArray(const char* name, const wxArrayInt& array)
{
printf("Dump of the array '%s'\n", name);
size_t nCount = array.GetCount();
for ( size_t n = 0; n < nCount; n++ )
{
printf("\t%s[%u] = %d\n", name, n, array[n]);
}
}
int wxCMPFUNC_CONV StringLenCompare(const wxString& first, int wxCMPFUNC_CONV StringLenCompare(const wxString& first,
const wxString& second) const wxString& second)
{ {
return first.length() - second.length(); return first.length() - second.length();
} }
int wxCMPFUNC_CONV IntCompare(int *first, #define TestArrayOf(name) \
int *second) \
{ static void PrintArray(const char* name, const wxSortedArray##name & array) \
return *first - *second; { \
printf("Dump of the array '%s'\n", name); \
\
size_t nCount = array.GetCount(); \
for ( size_t n = 0; n < nCount; n++ ) \
{ \
printf("\t%s[%u] = %d\n", name, n, array[n]); \
} \
} \
\
static void PrintArray(const char* name, const wxArray##name & array) \
{ \
printf("Dump of the array '%s'\n", name); \
\
size_t nCount = array.GetCount(); \
for ( size_t n = 0; n < nCount; n++ ) \
{ \
printf("\t%s[%u] = %d\n", name, n, array[n]); \
} \
} \
\
static void TestArrayOf ## name ## s() \
{ \
printf("*** Testing wxArray%s ***\n", #name); \
\
wxArray##name a; \
a.Add(1); \
a.Add(17); \
a.Add(5); \
a.Add(3); \
\
puts("Initially:"); \
PrintArray("a", a); \
\
puts("After sort:"); \
a.Sort(name ## Compare); \
PrintArray("a", a); \
\
puts("After reverse sort:"); \
a.Sort(name ## RevCompare); \
PrintArray("a", a); \
\
wxSortedArray##name b; \
b.Add(1); \
b.Add(17); \
b.Add(5); \
b.Add(3); \
\
puts("Sorted array initially:"); \
PrintArray("b", b); \
} }
int wxCMPFUNC_CONV IntRevCompare(int *first, TestArrayOf(Short);
int *second) TestArrayOf(Int);
{
return *second - *first;
}
static void TestArrayOfInts()
{
puts("*** Testing wxArrayInt ***\n");
wxArrayInt a;
a.Add(1);
a.Add(17);
a.Add(5);
a.Add(3);
puts("Initially:");
PrintArray("a", a);
puts("After sort:");
a.Sort(IntCompare);
PrintArray("a", a);
puts("After reverse sort:");
a.Sort(IntRevCompare);
PrintArray("a", a);
}
#include "wx/dynarray.h"
WX_DECLARE_OBJARRAY(Bar, ArrayBars);
#include "wx/arrimpl.cpp"
WX_DEFINE_OBJARRAY(ArrayBars);
static void TestArrayOfObjects() static void TestArrayOfObjects()
{ {
@@ -5493,11 +5532,10 @@ int main(int argc, char **argv)
PrintArray("a1", a1); PrintArray("a1", a1);
TestArrayOfObjects(); TestArrayOfObjects();
TestArrayOfShorts();
} }
else
{ TestArrayOfInts();
TestArrayOfInts();
}
#endif // TEST_ARRAYS #endif // TEST_ARRAYS
#ifdef TEST_DIR #ifdef TEST_DIR