Fixed bug that was giving the wrong size of wxCustomDataObjects to the receiver.

[wxWidgets.git] / include / wx / dynarray.h

diff --git a/include/wx/dynarray.h b/include/wx/dynarray.h
index a5b90b2b1605169b8ab26afc6095310bd0a68e1c..702df0bad0f1fbdc9aa4ec56ea83559dba331d1c 100644 (file)
--- a/include/wx/dynarray.h
+++ b/include/wx/dynarray.h
@@ -17,7 +17,6 @@
 #endif
 
 #include "wx/defs.h"
 #endif
 
 #include "wx/defs.h"

-#include "wx/debug.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)
 
 /** @name Dynamic arrays and object arrays (array which own their elements)
     @memo Arrays which grow on demand and do range checking (only in debug)


@@ -43,13 +42,7 @@
  callback compare function for quick sort
  must return negative value, 0 or positive value if pItem1 <, = or > pItem2
  */
  callback compare function for quick sort
  must return negative value, 0 or positive value if pItem1 <, = or > pItem2
  */

-
-#ifdef  __VISUALC__
-  #define   CMPFUNC_CONV    _cdecl
-#else   // !Visual C++
-  #define   CMPFUNC_CONV
-#endif  // compiler
-typedef int (CMPFUNC_CONV *CMPFUNC)(const void* pItem1, const void* pItem2);
+typedef int (wxCMPFUNC_CONV *CMPFUNC)(const void* pItem1, const void* pItem2);

 
 // ----------------------------------------------------------------------------
 /**
 
 // ----------------------------------------------------------------------------
 /**


@@ -138,7 +131,7 @@ protected:
     /// remove first item matching this value
   void Remove(long lItem);
     /// remove item by index
     /// remove first item matching this value
   void Remove(long lItem);
     /// remove item by index

-  void Remove(size_t uiIndex);
+  void RemoveAt(size_t uiIndex);

   //@}
 
   /// sort array elements using given compare function
   //@}
 
   /// sort array elements using given compare function


@@ -157,6 +150,11 @@ private:
 // template classes
 // ============================================================================
 
 // template classes
 // ============================================================================
 

+// resolves the name conflict between the wxT() macor and T typedef: we can't
+// use wxT() inside WX_DEFINE_ARRAY!
+#define _WX_ERROR_SIZEOF   wxT("illegal use of 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
 // types of sizeof()<=sizeof(long) or pointers if sizeof(pointer)<=sizeof(long)
 // ----------------------------------------------------------------------------
 // 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)


@@ -166,13 +164,18 @@ private:
 //    { ((wxBaseArray *)this)->operator=((const wxBaseArray&)src);
 // so using a temporary variable instead.
 // ----------------------------------------------------------------------------
 //    { ((wxBaseArray *)this)->operator=((const wxBaseArray&)src);
 // so using a temporary variable instead.
 // ----------------------------------------------------------------------------

-#define  _WX_DEFINE_ARRAY(T, name)                                  \
+#define  _WX_DEFINE_ARRAY(T, name, classexp)                        \

 typedef int (CMPFUNC_CONV *CMPFUNC##T)(T *pItem1, T *pItem2);       \
 typedef int (CMPFUNC_CONV *CMPFUNC##T)(T *pItem1, T *pItem2);       \

-class WXDLLEXPORTLOCAL name : public wxBaseArray                                     \
+classexp name : public wxBaseArray                                  \

 {                                                                   \
 public:                                                             \
   name()                                                            \
 {                                                                   \
 public:                                                             \
   name()                                                            \

-    { wxASSERT( sizeof(T) <= sizeof(long) ); }                      \
+  {                                                                 \
+    size_t type = sizeof(T);                                        \
+    size_t sizelong = sizeof(long);                                 \
+    if ( type > sizelong )                                          \
+      { wxFAIL_MSG( _WX_ERROR_SIZEOF ); }                           \
+  }                                                                 \

                                                                     \
   name& operator=(const name& src)                                  \
     { wxBaseArray* temp = (wxBaseArray*) this;                      \
                                                                     \
   name& operator=(const name& src)                                  \
     { wxBaseArray* temp = (wxBaseArray*) this;                      \


@@ -194,12 +197,13 @@ public:                                                             \
   void Insert(T Item, size_t uiIndex)                               \
     { wxBaseArray::Insert((long)Item, uiIndex) ; }                  \
                                                                     \
   void Insert(T Item, size_t uiIndex)                               \
     { wxBaseArray::Insert((long)Item, uiIndex) ; }                  \
                                                                     \

-  void Remove(size_t uiIndex) { wxBaseArray::Remove(uiIndex); }     \
+  void Remove(size_t uiIndex) { RemoveAt(uiIndex); }                \
+  void RemoveAt(size_t uiIndex) { wxBaseArray::RemoveAt(uiIndex); } \

   void Remove(T Item)                                               \
     { int iIndex = Index(Item);                                     \
   void Remove(T Item)                                               \
     { int iIndex = Index(Item);                                     \

-      wxCHECK2_MSG( iIndex != wxNOT_FOUND, return,                    \
-        "removing inexisting element in wxArray::Remove" );         \
-      wxBaseArray::Remove((size_t)iIndex); }                          \
+      wxCHECK2_MSG( iIndex != wxNOT_FOUND, return,                  \
+         _WX_ERROR_REMOVE);                                         \
+      wxBaseArray::RemoveAt((size_t)iIndex); }                      \

                                                                     \
   void Sort(CMPFUNC##T fCmp) { wxBaseArray::Sort((CMPFUNC)fCmp); }  \
 }
                                                                     \
   void Sort(CMPFUNC##T fCmp) { wxBaseArray::Sort((CMPFUNC)fCmp); }  \
 }


@@ -224,13 +228,18 @@ public:                                                             \
 //    { ((wxBaseArray *)this)->operator=((const wxBaseArray&)src);
 // so using a temporary variable instead.
 // ----------------------------------------------------------------------------
 //    { ((wxBaseArray *)this)->operator=((const wxBaseArray&)src);
 // so using a temporary variable instead.
 // ----------------------------------------------------------------------------

-#define  _WX_DEFINE_SORTED_ARRAY(T, name)                           \
+#define  _WX_DEFINE_SORTED_ARRAY(T, name, classexp)                 \

 typedef int (CMPFUNC_CONV *SCMPFUNC##T)(T pItem1, T pItem2);        \
 typedef int (CMPFUNC_CONV *SCMPFUNC##T)(T pItem1, T pItem2);        \

-class WXDLLEXPORTLOCAL  name : public wxBaseArray                                     \
+classexp name : public wxBaseArray                                  \

 {                                                                   \
 public:                                                             \
   name(SCMPFUNC##T fn)                                              \
 {                                                                   \
 public:                                                             \
   name(SCMPFUNC##T fn)                                              \

-    { wxASSERT( sizeof(T) <= sizeof(long) ); 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)                                  \
     { wxBaseArray* temp = (wxBaseArray*) this;                      \
                                                                     \
   name& operator=(const name& src)                                  \
     { wxBaseArray* temp = (wxBaseArray*) this;                      \


@@ -251,12 +260,13 @@ public:                                                             \
   void Add(T Item)                                                  \
     { wxBaseArray::Add((long)Item, (CMPFUNC)m_fnCompare); }         \
                                                                     \
   void Add(T Item)                                                  \
     { wxBaseArray::Add((long)Item, (CMPFUNC)m_fnCompare); }         \
                                                                     \

-  void Remove(size_t uiIndex) { wxBaseArray::Remove(uiIndex); }     \
+  void Remove(size_t uiIndex) { RemoveAt(uiIndex); }                \
+  void RemoveAt(size_t uiIndex) { wxBaseArray::RemoveAt(uiIndex); } \

   void Remove(T Item)                                               \
     { int iIndex = Index(Item);                                     \
   void Remove(T Item)                                               \
     { int iIndex = Index(Item);                                     \

-      wxCHECK2_MSG( iIndex != wxNOT_FOUND, return,                    \
-        "removing inexisting element in wxArray::Remove" );         \
-      wxBaseArray::Remove((size_t)iIndex); }                        \
+      wxCHECK2_MSG( iIndex != wxNOT_FOUND, return,                  \
+        _WX_ERROR_REMOVE );                                         \
+      wxBaseArray::RemoveAt((size_t)iIndex); }                      \

                                                                     \
 private:                                                            \
   SCMPFUNC##T m_fnCompare;                                          \
                                                                     \
 private:                                                            \
   SCMPFUNC##T m_fnCompare;                                          \


@@ -265,9 +275,9 @@ private:                                                            \
 // ----------------------------------------------------------------------------
 // see WX_DECLARE_OBJARRAY and WX_DEFINE_OBJARRAY
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // see WX_DECLARE_OBJARRAY and WX_DEFINE_OBJARRAY
 // ----------------------------------------------------------------------------

-#define _WX_DECLARE_OBJARRAY(T, name)                               \
+#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);     \

-class WXDLLEXPORTLOCAL name : public wxBaseArray                    \
+classexp name : public wxBaseArray                                  \

 {                                                                   \
 public:                                                             \
   name() { }                                                        \
 {                                                                   \
 public:                                                             \
   name() { }                                                        \


@@ -293,16 +303,19 @@ public:                                                             \
   void Insert(const T* pItem, size_t uiIndex)                       \
     { wxBaseArray::Insert((long)pItem, uiIndex); }                  \
                                                                     \
   void Insert(const T* pItem, size_t uiIndex)                       \
     { wxBaseArray::Insert((long)pItem, uiIndex); }                  \
                                                                     \

-  void Empty();                                                     \
+  void Empty() { DoEmpty(); wxBaseArray::Empty(); }                 \
+  void Clear() { DoEmpty(); wxBaseArray::Clear(); }                 \

                                                                     \
   T*   Detach(size_t uiIndex)                                       \
     { T* p = (T*)wxBaseArray::Item(uiIndex);                        \
                                                                     \
   T*   Detach(size_t uiIndex)                                       \
     { T* p = (T*)wxBaseArray::Item(uiIndex);                        \

-      wxBaseArray::Remove(uiIndex); return p; }                     \
-  void Remove(size_t uiIndex);                                      \
+      wxBaseArray::RemoveAt(uiIndex); return p; }                   \
+  void Remove(size_t uiIndex) { RemoveAt(uiIndex); }                \
+  void RemoveAt(size_t uiIndex);                                    \

                                                                     \
   void Sort(CMPFUNC##T fCmp) { wxBaseArray::Sort((CMPFUNC)fCmp); }  \
                                                                     \
 private:                                                            \
                                                                     \
   void Sort(CMPFUNC##T fCmp) { wxBaseArray::Sort((CMPFUNC)fCmp); }  \
                                                                     \
 private:                                                            \

+  void DoEmpty();                                                   \

   void DoCopy(const name& src);                                     \
 }
 
   void DoCopy(const name& src);                                     \
 }
 


@@ -331,15 +344,17 @@ private:                                                            \
 
    @memo declare and define array class 'name' containing elements of type 'T'
   */
 
    @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)
+#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.
    */
 
   /**
    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)
+#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
 
   /**
    This macro generates a new objarrays class which owns the objects it


@@ -376,8 +391,10 @@ private:                                                            \
 
    @memo declare objarray class 'name' containing elements of type 'T'
   */
 
    @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)
+#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>
   /**
     To use an objarray class you must
     <ll>


@@ -398,31 +415,50 @@ private:                                                            \
 #define WX_DEFINE_OBJARRAY(name)       "don't forget to include arrimpl.cpp!"
 //@}
 
 #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_DECLARE_EXPORTED_OBJARRAY(T, name)           \
+    typedef T _L##name;                                 \
+    _WX_DECLARE_OBJARRAY(_L##name, name, class WXDLLEXPORT)
+

 // ----------------------------------------------------------------------------
 /** @name Some commonly used predefined arrays */
 // ----------------------------------------------------------------------------
 /** @name Some commonly used predefined arrays */

-// # overhead if not used?

 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 

-#define WXDLLEXPORTLOCAL WXDLLEXPORT
-

 //@{
   /** @name ArrayInt */
 //@{
   /** @name ArrayInt */

-WX_DEFINE_ARRAY(int,    wxArrayInt);
+WX_DEFINE_EXPORTED_ARRAY(int, wxArrayInt);

   /** @name ArrayLong */
   /** @name ArrayLong */

-WX_DEFINE_ARRAY(long,   wxArrayLong);
+WX_DEFINE_EXPORTED_ARRAY(long, wxArrayLong);

   /** @name ArrayPtrVoid */
   /** @name ArrayPtrVoid */

-WX_DEFINE_ARRAY(void *, wxArrayPtrVoid);
+WX_DEFINE_EXPORTED_ARRAY(void *, wxArrayPtrVoid);

 //@}
 
 //@}
 
 //@}
 
 //@}
 

-#undef  WXDLLEXPORTLOCAL
-#define WXDLLEXPORTLOCAL
-

 // -----------------------------------------------------------------------------
 // convinience macros
 // -----------------------------------------------------------------------------
 
 // -----------------------------------------------------------------------------
 // convinience macros
 // -----------------------------------------------------------------------------
 

+// append all element of one array to another one
+#define WX_APPEND_ARRAY(array, other)                                         \
+    {                                                                         \
+        size_t count = other.Count();                                         \
+        for ( size_t n = 0; n < count; n++ )                                  \
+        {                                                                     \
+            array.Add(other[n]);                                              \
+        }                                                                     \
+    }
+

 // delete all array elements
 //
 // NB: the class declaration of the array elements must be visible from the
 // delete all array elements
 //
 // NB: the class declaration of the array elements must be visible from the


@@ -439,5 +475,6 @@ WX_DEFINE_ARRAY(void *, wxArrayPtrVoid);
                                                                               \
         array.Empty();                                                        \
     }
                                                                               \
         array.Empty();                                                        \
     }

+

 #endif // _DYNARRAY_H
 
 #endif // _DYNARRAY_H