X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/3093cef829d26137a14303c36d592ed817da1028..e74bfc5d1a4b64f4d4f569a8f7d9a86a35f0e06d:/include/wx/dynarray.h diff --git a/include/wx/dynarray.h b/include/wx/dynarray.h index 7174148866..67bcab55d8 100644 --- a/include/wx/dynarray.h +++ b/include/wx/dynarray.h @@ -19,7 +19,7 @@ #include "wx/defs.h" #include "wx/debug.h" -/** @name Dynamic arrays and lists +/** @name Dynamic arrays and object arrays (array which own their elements) @memo Arrays which grow on demand and do range checking (only in debug) */ //@{ @@ -29,7 +29,7 @@ // ---------------------------------------------------------------------------- /** - the initial size by which an array/list grows when an element is added + the initial size by which an array grows when an element is added default value avoids allocate one or two bytes when the array is created which is rather inefficient */ @@ -61,7 +61,7 @@ typedef int (CMPFUNC_CONV *CMPFUNC)(const void* pItem1, const void* pItem2); 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 + @memo Base class for template array classes */ // ---------------------------------------------------------------------------- class WXDLLEXPORT wxBaseArray @@ -85,9 +85,9 @@ public: /** @name memory management */ //@{ - /// empties the list, but doesn't release memory + /// empties the array, but doesn't release memory void Empty() { m_nCount = 0; } - /// empties the list and releases memory + /// empties the array and releases memory void Clear(); /// preallocates memory for given number of items void Alloc(size_t uiSize); @@ -106,7 +106,7 @@ public: protected: // these methods are protected because if they were public one could - // mistakenly call one of them instead of DEFINE_ARRAY's or LIST's + // mistakenly call one of them instead of DEFINE_ARRAY's or OBJARRAY's // type safe methods /** @name items access */ @@ -255,11 +255,11 @@ private: \ } // ---------------------------------------------------------------------------- -// see WX_DECLARE_LIST and WX_DEFINE_LIST +// see WX_DECLARE_OBJARRAY and WX_DEFINE_OBJARRAY // ---------------------------------------------------------------------------- -#define _WX_DECLARE_LIST(T, name) \ +#define _WX_DECLARE_OBJARRAY(T, name) \ typedef int (CMPFUNC_CONV *CMPFUNC##T)(T** pItem1, T** pItem2); \ -class WXDLLEXPORTLOCAL name : public wxBaseArray \ +class WXDLLEXPORTLOCAL name : public wxBaseArray \ { \ public: \ name() { } \ @@ -299,17 +299,17 @@ private: \ } // ---------------------------------------------------------------------------- -/** @name Macros for definition of dynamic arrays and lists +/** @name Macros for definition of dynamic arrays and objarrays 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 never shrink, they - only grow, so loading 10 millions in an array only to delete them 2 lines - below is not recommended. However, it does free memory when it's - destroyed, so if you destroy array also, it's ok. + Range checking is performed in debug build for both arrays and objarrays. + Type checking is done at compile-time. Warning: arrays never shrink, + they only grow, so loading 10 millions in an array only to delete them 2 + lines below is not recommended. However, it does free memory when + it's destroyed, so if you destroy array also, it's ok. */ // ---------------------------------------------------------------------------- @@ -334,60 +334,60 @@ private: \ _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*, - but arguments of type T& are taken (see below!) and T& is returned. -
+ 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.
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 list, i.e. it will delete the - object when it's removed or in the list's dtor + 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 list + 1) Remove() will delete the object after removing it from the array
- 2) Detach() just removes the object from the list (returning pointer to it) + 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 list to it's base type: as dtor is not virtual + NB2: Never ever cast a array to it's base type: as dtor is not virtual it will provoke memory leaks

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' + @memo declare objarray class 'name' containing elements of type 'T' */ -#define WX_DECLARE_LIST(T, name) typedef T _L##name; \ - _WX_DECLARE_LIST(_L##name, name) +#define WX_DECLARE_OBJARRAY(T, name) typedef T _L##name; \ + _WX_DECLARE_LIST(_L##name, name) /** - To use a list class you must + To use an objarray class you must
  • #include "dynarray.h" -
  • DECLARE_LIST(element_type, list_class_name) -
  • #include "listimpl.cpp" -
  • DEFINE_LIST(list_class_name) // same as above! +
  • WX_DECLARE_OBJARRAY(element_type, list_class_name) +
  • #include "arrimpl.cpp" +
  • WX_DEFINE_OBJARRAY(list_class_name) // same as above!

    - 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 - type. + 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 listimpl.cpp!) list class 'name' + @memo define (must include arrimpl.cpp!) objarray class 'name' */ -#define WX_DEFINE_LIST(name) "don't forget to include listimpl.cpp!" +#define WX_DEFINE_OBJARRAY(name) "don't forget to include arrimpl.cpp!" //@} // ----------------------------------------------------------------------------