added support for add/insert/deleting many items at once in wxArray (patch 548050)

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@15274 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

diff --git a/include/wx/arrimpl.cpp b/include/wx/arrimpl.cpp
index 8c975cdbb9e7458d14b609a7fbb4a4eab7fb236e..844eb4b75143dbc38eb91dda7fc4dd6458d8a716 100644 (file)
--- a/include/wx/arrimpl.cpp
+++ b/include/wx/arrimpl.cpp
@@ -63,27 +63,33 @@ void name::DoEmpty()                                                          \
     delete (T*)wxBaseArrayPtrVoid::Item(ui);                                  \
 }                                                                             \
                                                                               \
-void name::RemoveAt(size_t uiIndex)                                           \
+void name::RemoveAt(size_t uiIndex, size_t nRemove)                           \
 {                                                                             \
   wxCHECK_RET( uiIndex < Count(), _WX_ERROR_REMOVE2(name) );                  \
                                                                               \
-  delete (T*)wxBaseArrayPtrVoid::Item(uiIndex);                               \
+  for (size_t i = 0; i < nRemove; i++ )                                       \
+    delete (T*)wxBaseArrayPtrVoid::Item(uiIndex + i);                         \
                                                                               \
-  wxBaseArrayPtrVoid::RemoveAt(uiIndex);                                      \
+  wxBaseArrayPtrVoid::RemoveAt(uiIndex, nRemove);                             \
 }                                                                             \
                                                                               \
-void name::Add(const T& item)                                                 \
+void name::Add(const T& item, size_t nInsert)                                 \
 {                                                                             \
   T* pItem = new T(item);                                                     \
+  size_t nOldSize = GetCount();                                               \
   if ( pItem != NULL )                                                        \
-    Add(pItem);                                                               \
+    wxBaseArrayPtrVoid::Add(pItem, nInsert);                                  \
+  for (size_t i = 1; i < nInsert; i++)                                        \
+    wxBaseArrayPtrVoid::Item(nOldSize + i) = new T(item);                     \
 }                                                                             \
                                                                               \
-void name::Insert(const T& item, size_t uiIndex)                              \
+void name::Insert(const T& item, size_t uiIndex, size_t nInsert)              \
 {                                                                             \
   T* pItem = new T(item);                                                     \
   if ( pItem != NULL )                                                        \
-    Insert(pItem, uiIndex);                                                   \
+    wxBaseArrayPtrVoid::Insert(pItem, uiIndex, nInsert);                      \
+  for (size_t i = 1; i < nInsert; i++)                                        \
+    wxBaseArrayPtrVoid::Item(uiIndex + i) = new T(item);                      \
 }                                                                             \
                                                                               \
 int name::Index(const T& Item, bool bFromEnd) const                           \

diff --git a/include/wx/dynarray.h b/include/wx/dynarray.h
index 1a7bf28d2f5a0b00ca51595c21f978e81d869aeb..f0e511682056f97afb3f76dea30559e5f9314713 100644 (file)
--- a/include/wx/dynarray.h
+++ b/include/wx/dynarray.h
@@ -57,7 +57,7 @@
 
 /*
     Callback compare function for quick sort.
-    
+
     It must return negative value, 0 or positive value if the first item is
     less than, equal to or greater than the second one.
  */
@@ -103,17 +103,17 @@ protected:                                                          \
   int Index(T lItem, bool bFromEnd = FALSE) const;                  \
   int Index(T lItem, CMPFUNC fnCompare) const;                      \
   size_t IndexForInsert(T lItem, CMPFUNC fnCompare) const;          \
-  void Add(T lItem);                                                \
+  void Add(T lItem, size_t nInsert = 1);                            \
   void Add(T lItem, CMPFUNC fnCompare);                             \
-  void Insert(T lItem, size_t uiIndex);                             \
+  void Insert(T lItem, size_t uiIndex, size_t nInsert = 1);         \
   void Remove(T lItem);                                             \
-  void RemoveAt(size_t uiIndex);                                    \
+  void RemoveAt(size_t uiIndex, size_t nRemove = 1);                \
                                                                     \
   void Sort(CMPFUNC fnCompare);                                     \
                                                                     \
 private:                                                            \
                                                                     \
-  void    Grow();                                                   \
+  void    Grow(size_t nIncrement = 0);                              \
                                                                     \
   size_t  m_nSize,                                                  \
           m_nCount;                                                 \
@@ -168,12 +168,13 @@ public:                                                               \
   int Index(T Item, bool bFromEnd = FALSE) const                      \
     { return base::Index(Item, bFromEnd); }                           \
                                                                       \
-  void Add(T Item)                                                    \
-    { base::Add(Item); }                                              \
-  void Insert(T Item, size_t uiIndex)                                 \
-    { base::Insert(Item, uiIndex) ; }                                 \
+  void Add(T Item, size_t nInsert = 1)                                \
+    { base::Add(Item, nInsert); }                                     \
+  void Insert(T Item, size_t uiIndex, size_t nInsert = 1)             \
+    { base::Insert(Item, uiIndex, nInsert) ; }                        \
                                                                       \
-  void RemoveAt(size_t uiIndex) { base::RemoveAt(uiIndex); }          \
+  void RemoveAt(size_t uiIndex, size_t nRemove = 1)                   \
+    { base::RemoveAt(uiIndex, nRemove); }                             \
   void Remove(T Item)                                                 \
     { int iIndex = Index(Item);                                       \
       wxCHECK2_MSG( iIndex != wxNOT_FOUND, return,                    \
@@ -223,7 +224,8 @@ public:                                                               \
   void Add(T Item)                                                    \
     { base::Add(Item, (CMPFUNC)m_fnCompare); }                        \
                                                                       \
-  void RemoveAt(size_t uiIndex) { base::RemoveAt(uiIndex); }          \
+  void RemoveAt(size_t uiIndex, size_t nRemove = 1)                   \
+    { base::RemoveAt(uiIndex, nRemove); }                             \
   void Remove(T Item)                                                 \
     { int iIndex = Index(Item);                                       \
       wxCHECK2_MSG( iIndex != wxNOT_FOUND, return,                    \
@@ -259,11 +261,11 @@ public:                                                                  \
                                                                          \
   int Index(const T& Item, bool bFromEnd = FALSE) const;                 \
                                                                          \
-  void Add(const T& Item);                                               \
+  void Add(const T& Item, size_t nInsert = 1);                           \
   void Add(const T* pItem)                                               \
     { base::Add((T*)pItem); }                                            \
                                                                          \
-  void Insert(const T& Item,  size_t uiIndex);                           \
+  void Insert(const T& Item,  size_t uiIndex, size_t nInsert = 1);       \
   void Insert(const T* pItem, size_t uiIndex)                            \
     { base::Insert((T*)pItem, uiIndex); }                                \
                                                                          \
@@ -273,7 +275,7 @@ public:                                                                  \
   T* Detach(size_t uiIndex)                                              \
     { T* p = (T*)base::Item(uiIndex);                                    \
       base::RemoveAt(uiIndex); return p; }                               \
-  void RemoveAt(size_t uiIndex);                                         \
+  void RemoveAt(size_t uiIndex, size_t nRemove = 1);                     \
                                                                          \
   void Sort(CMPFUNC##T fCmp) { base::Sort((CMPFUNC##base)fCmp); }        \
                                                                          \

diff --git a/src/common/dynarray.cpp b/src/common/dynarray.cpp
index 07ddf168df9536bc2da9617d69338551b0f620a0..61400eddf849f373de5ffbd1410a25ea125c7e08 100644 (file)
--- a/src/common/dynarray.cpp
+++ b/src/common/dynarray.cpp
@@ -102,7 +102,7 @@ name& name::operator=(const name& src)                                      \
 }                                                                           \
                                                                             \
 /* grow the array */                                                        \
-void name::Grow()                                                           \
+void name::Grow(size_t nIncrement)                                          \
 {                                                                           \
   /* only do it if no more place */                                         \
   if( m_nCount == m_nSize ) {                                               \
@@ -116,11 +116,13 @@ void name::Grow()                                                           \
     }                                                                       \
     else                                                                    \
     {                                                                       \
-      /* add 50% but not too much */                                        \
-      size_t nIncrement = m_nSize < WX_ARRAY_DEFAULT_INITIAL_SIZE           \
-                         ? WX_ARRAY_DEFAULT_INITIAL_SIZE : m_nSize >> 1;    \
-      if ( nIncrement > ARRAY_MAXSIZE_INCREMENT )                           \
-        nIncrement = ARRAY_MAXSIZE_INCREMENT;                               \
+      /* add at least 50% but not too much */                               \
+      size_t ndefIncrement = m_nSize < WX_ARRAY_DEFAULT_INITIAL_SIZE        \
+                            ? WX_ARRAY_DEFAULT_INITIAL_SIZE : m_nSize >> 1; \
+      if ( ndefIncrement > ARRAY_MAXSIZE_INCREMENT )                        \
+        ndefIncrement = ARRAY_MAXSIZE_INCREMENT;                            \
+      if ( nIncrement < ndefIncrement )                                     \
+        nIncrement = ndefIncrement;                                         \
       T *pNew = new T[m_nSize + nIncrement];                                \
       /* only grow if allocation succeeded */                               \
       if ( pNew ) {                                                         \
@@ -240,10 +242,11 @@ int name::Index(T lItem, CMPFUNC fnCompare) const                           \
 }                                                                           \
                                                                             \
 /* add item at the end */                                                   \
-void name::Add(T lItem)                                                     \
+void name::Add(T lItem, size_t nInsert)                                     \
 {                                                                           \
-  Grow();                                                                   \
-  m_pItems[m_nCount++] = lItem;                                             \
+  Grow(nInsert);                                                            \
+  for (size_t i = 0; i < nInsert; i++)                                      \
+      m_pItems[m_nCount++] = lItem;                                         \
 }                                                                           \
                                                                             \
 /* add item assuming the array is sorted with fnCompare function */         \
@@ -253,26 +256,31 @@ void name::Add(T lItem, CMPFUNC fnCompare)                                  \
 }                                                                           \
                                                                             \
 /* add item at the given position */                                        \
-void name::Insert(T lItem, size_t nIndex)                                   \
+void name::Insert(T lItem, size_t nIndex, size_t nInsert)                   \
 {                                                                           \
   wxCHECK_RET( nIndex <= m_nCount, wxT("bad index in wxArray::Insert") );   \
+  wxCHECK_RET( m_nCount <= m_nCount + nInsert,                              \
+               wxT("array size overflow in wxArray::Insert") );             \
                                                                             \
-  Grow();                                                                   \
+  Grow(nInsert);                                                            \
                                                                             \
-  memmove(&m_pItems[nIndex + 1], &m_pItems[nIndex],                         \
+  memmove(&m_pItems[nIndex + nInsert], &m_pItems[nIndex],                   \
           (m_nCount - nIndex)*sizeof(T));                                   \
-  m_pItems[nIndex] = lItem;                                                 \
-  m_nCount++;                                                               \
+  for (size_t i = 0; i < nInsert; i++)                                      \
+      m_pItems[nIndex + i] = lItem;                                         \
+  m_nCount += nInsert;                                                      \
 }                                                                           \
                                                                             \
 /* removes item from array (by index) */                                    \
-void name::RemoveAt(size_t nIndex)                                          \
+void name::RemoveAt(size_t nIndex, size_t nRemove)                          \
 {                                                                           \
-  wxCHECK_RET( nIndex <= m_nCount, wxT("bad index in wxArray::RemoveAt") ); \
+  wxCHECK_RET( nIndex < m_nCount, wxT("bad index in wxArray::RemoveAt") );  \
+  wxCHECK_RET( nIndex + nRemove <= m_nCount,                                \
+               wxT("removing too many elements in wxArray::RemoveAt") );    \
                                                                             \
-  memmove(&m_pItems[nIndex], &m_pItems[nIndex + 1],                         \
-          (m_nCount - nIndex - 1)*sizeof(T));                               \
-  m_nCount--;                                                               \
+  memmove(&m_pItems[nIndex], &m_pItems[nIndex + nRemove],                   \
+          (m_nCount - nIndex - nRemove)*sizeof(T));                         \
+  m_nCount -= nRemove;                                                      \
 }                                                                           \
                                                                             \
 /* removes item from array (by value) */                                    \