added wx/defs.h include to correct compilation issues under Mac OS X

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

diff --git a/include/wx/dynarray.h b/include/wx/dynarray.h
index a3c4017ada52beba2b7d6caa86a49fa6394d8beb..7e064dfc0b725b47a427797ef6b47f3c8df9ec5f 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)


@@ -123,6 +122,8 @@ protected:
   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;
   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
     /// add new element at the end
   void Add(long lItem);
     /// add item assuming the array is sorted with fnCompare function


@@ -132,7 +133,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


@@ -165,6 +166,7 @@ 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.
 // ----------------------------------------------------------------------------

+// __MAC_X__ added min ~name() below for compiling Mac X

 #define  _WX_DEFINE_ARRAY(T, name, classexp)                        \
 typedef int (CMPFUNC_CONV *CMPFUNC##T)(T *pItem1, T *pItem2);       \
 classexp name : public wxBaseArray                                  \
 #define  _WX_DEFINE_ARRAY(T, name, classexp)                        \
 typedef int (CMPFUNC_CONV *CMPFUNC##T)(T *pItem1, T *pItem2);       \
 classexp name : public wxBaseArray                                  \


@@ -177,6 +179,7 @@ public:                                                             \
     if ( type > sizelong )                                          \
       { wxFAIL_MSG( _WX_ERROR_SIZEOF ); }                           \
   }                                                                 \
     if ( type > sizelong )                                          \
       { wxFAIL_MSG( _WX_ERROR_SIZEOF ); }                           \
   }                                                                 \

+  ~name() {}                                                        \

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


@@ -198,12 +201,12 @@ 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 RemoveAt(size_t uiIndex) { wxBaseArray::RemoveAt(uiIndex); } \

   void Remove(T Item)                                               \
     { int iIndex = Index(Item);                                     \
       wxCHECK2_MSG( iIndex != wxNOT_FOUND, return,                  \
          _WX_ERROR_REMOVE);                                         \
   void Remove(T Item)                                               \
     { int iIndex = Index(Item);                                     \
       wxCHECK2_MSG( iIndex != wxNOT_FOUND, return,                  \
          _WX_ERROR_REMOVE);                                         \

-      wxBaseArray::Remove((size_t)iIndex); }                        \
+      wxBaseArray::RemoveAt((size_t)iIndex); }                      \

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


@@ -219,6 +222,10 @@ public:                                                             \
 //  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.
 //  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.
 //
 // Summary: use this class when the speed of Index() function is important, use
 // the normal arrays otherwise.


@@ -257,15 +264,22 @@ public:                                                             \
   int Index(T Item) const                                           \
     { return wxBaseArray::Index((long)Item, (CMPFUNC)m_fnCompare); }\
                                                                     \
   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 Add(T Item)                                                  \
     { wxBaseArray::Add((long)Item, (CMPFUNC)m_fnCompare); }         \
                                                                     \

-  void Remove(size_t uiIndex) { wxBaseArray::Remove(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 );                                         \
   void Remove(T Item)                                               \
     { int iIndex = Index(Item);                                     \
       wxCHECK2_MSG( iIndex != wxNOT_FOUND, return,                  \
         _WX_ERROR_REMOVE );                                         \

-      wxBaseArray::Remove((size_t)iIndex); }                        \
+      wxBaseArray::RemoveAt((size_t)iIndex); }                      \

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


@@ -302,16 +316,18 @@ 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 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);                                     \
 }
 


@@ -442,9 +458,19 @@ WX_DEFINE_EXPORTED_ARRAY(void *, wxArrayPtrVoid);
 //@}
 
 // -----------------------------------------------------------------------------
 //@}
 
 // -----------------------------------------------------------------------------

-// convinience macros
+// convenience 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


@@ -453,13 +479,13 @@ WX_DEFINE_EXPORTED_ARRAY(void *, wxArrayPtrVoid);
 //     count on it)!
 #define WX_CLEAR_ARRAY(array)                                                 \
     {                                                                         \
 //     count on it)!
 #define WX_CLEAR_ARRAY(array)                                                 \
     {                                                                         \

-        size_t count = array.Count();                                         \
+        size_t count = (array).Count();                                       \

         for ( size_t n = 0; n < count; n++ )                                  \
         {                                                                     \
         for ( size_t n = 0; n < count; n++ )                                  \
         {                                                                     \

-            delete array[n];                                                  \
+            delete (array)[n];                                                \

         }                                                                     \
                                                                               \
         }                                                                     \
                                                                               \

-        array.Empty();                                                        \
+        (array).Empty();                                                      \

     }
 
 #endif // _DYNARRAY_H
     }
 
 #endif // _DYNARRAY_H