// Name: dynarray.h
// Purpose: auto-resizable (i.e. dynamic) array support
// Author: Vadim Zeitlin
-// Modified by:
+// Modified by:
// Created: 12.09.97
// RCS-ID: $Id$
// Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
#endif
#include "wx/defs.h"
-#include "wx/utils.h"
+#include "wx/debug.h"
-/** @name Dynamic arrays and lists
+/** @name Dynamic arrays and lists
@memo Arrays which grow on demand and do range checking (only in debug)
*/
//@{
/**
the initial size by which an array/list grows when an element is added
- default value avoids allocate one or two bytes when the array is created
+ default value avoids allocate one or two bytes when the array is created
which is rather inefficient
*/
#define WX_ARRAY_DEFAULT_INITIAL_SIZE (16)
/**
callback compare function for quick sort
- must return -1, 0 or +1 if pItem1 <, = or > pItem2
+ must return negative value, 0 or positive value if pItem1 <, = or > pItem2
*/
#ifdef __VISUALC__
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
- VTBL), even dtor is <B>not</B> virtual. If used as expected it won't
- create any problems because ARRAYs from DEFINE_ARRAY have no dtor at all,
- so it's not too important if it's not called (this happens when you cast
+ VTBL), even dtor is <B>not</B> virtual. If used as expected it won't
+ create any problems because ARRAYs from DEFINE_ARRAY have no dtor at all,
+ so it's not too important if it's not called (this happens when you cast
"SomeArray *" as "BaseArray *" and then delete it)
@memo Base class for template array and list classes
//@}
protected:
- // these methods are protected because if they were public one could
+ // these methods are protected because if they were public one could
// mistakenly call one of them instead of DEFINE_ARRAY's or LIST's
// type safe methods
@return index of the first item matched or NOT_FOUND
@see NOT_FOUND
*/
- int Index (long lItem, bool bFromEnd = FALSE) const;
+ 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;
/// add new element at the end
- void Add (long lItem);
- /// add new element at given position
+ 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, uint uiIndex);
/// remove first item matching this value
void Remove(long lItem);
//@}
/// sort array elements using given compare function
- void Sort(CMPFUNC fCmp);
+ void Sort(CMPFUNC fnCompare);
private:
void Grow(); // makes array bigger if needed
// ----------------------------------------------------------------------------
// 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)
-//
+//
// NB: it has only inline functions => takes no space at all
// ----------------------------------------------------------------------------
#define _WX_DEFINE_ARRAY(T, name) \
{ return (T&)(wxBaseArray::Item(uiIndex)); } \
T& Item(uint 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 Remove(uint uiIndex) { wxBaseArray::Remove(uiIndex); } \
void Remove(T Item) \
{ int iIndex = Index(Item); \
- wxCHECK( iIndex != NOT_FOUND ); \
+ wxCHECK2_MSG( iIndex != NOT_FOUND, return, \
+ "removing inexisting element in wxArray::Remove" ); \
wxBaseArray::Remove((uint)iIndex); } \
\
void Sort(CMPFUNC##T fCmp) { wxBaseArray::Sort((CMPFUNC)fCmp); } \
}
+// ----------------------------------------------------------------------------
+// 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.
+//
+// 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
+// ----------------------------------------------------------------------------
+#define _WX_DEFINE_SORTED_ARRAY(T, name) \
+typedef int (CMPFUNC_CONV *SCMPFUNC##T)(T pItem1, T pItem2); \
+class name : public wxBaseArray \
+{ \
+public: \
+ name(SCMPFUNC##T fn) \
+ { wxASSERT( sizeof(T) <= sizeof(long) ); m_fnCompare = fn; } \
+ \
+ name& operator=(const name& src) \
+ { ((wxBaseArray *)this)->operator=((const wxBaseArray&)src); \
+ m_fnCompare = src.m_fnCompare; \
+ return *this; } \
+ \
+ T& operator[](uint uiIndex) const \
+ { return (T&)(wxBaseArray::Item(uiIndex)); } \
+ T& Item(uint 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); }\
+ \
+ void Add(T Item) \
+ { wxBaseArray::Add((long)Item, (CMPFUNC)m_fnCompare); } \
+ \
+ void Remove(uint uiIndex) { wxBaseArray::Remove(uiIndex); } \
+ void Remove(T Item) \
+ { int iIndex = Index(Item); \
+ wxCHECK2_MSG( iIndex != NOT_FOUND, return, \
+ "removing inexisting element in wxArray::Remove" ); \
+ wxBaseArray::Remove((uint)iIndex); } \
+ \
+private: \
+ SCMPFUNC##T m_fnCompare; \
+}
+
// ----------------------------------------------------------------------------
// see WX_DECLARE_LIST and WX_DEFINE_LIST
// ----------------------------------------------------------------------------
{ return *(T*)wxBaseArray::Item(uiIndex); } \
T& Item(uint 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; \
\
}
// ----------------------------------------------------------------------------
-/** @name Macros for definition of dynamic arrays and lists
+/** @name Macros for definition of dynamic arrays and lists
These macros are ugly (especially if you look in the sources ;-), but they
allow us to define 'template' classes without actually using templates.
Range checking is performed in debug build for both arrays and lists. Type
checking is done at compile-time. Warning: arrays <I>never</I> shrink, they
only grow, so loading 10 millions in an array only to delete them 2 lines
- below is <I>not</I> recommended. However, it does free memory when it's
+ below is <I>not</I> recommended. However, it does free memory when it's
destroyed, so if you destroy array also, it's ok.
*/
// ----------------------------------------------------------------------------
*/
#define WX_DEFINE_ARRAY(T, name) typedef T _A##name; \
_WX_DEFINE_ARRAY(_A##name, name)
+
+ /**
+ 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)
+
/**
This macro generates a new list class which owns the objects it contains,
i.e. it will delete them when it is destroyed. An element is of type T*,
<BR>
NB1: Base type T should have an accessible copy ctor if Add(T&) is used,
<BR>
- NB2: Never ever cast a list to it's base type: as dtor is <B>not</B> virtual
+ NB2: Never ever cast a list 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
+ some functions of this class are not inline, so it takes some space to
define new class from this template.
@memo declare list class 'name' containing elements of type 'T'
This is necessary because at the moment of DEFINE_LIST class element_type
must be fully defined (i.e. forward declaration is not enough), while
DECLARE_LIST may be done anywhere. The separation of two allows to break
- cicrcular dependencies with classes which have member variables of list
+ cicrcular dependencies with classes which have member variables of list
type.
@memo define (must include listimpl.cpp!) list class 'name'
projects / wxWidgets.git / blobdiff