#3 allow removal from btree list to complete the interface

Author: davetcc

src/SimpleCollections.cpp

@@ -9,6 +9,7 @@
 #include <malloc.h>
 #endif
 #include "SimpleCollections.h"
+#include <IoLogging.h>
 
 using namespace ioaTreeInternal;
 
@@ -51,6 +52,31 @@ bool BtreeStorage::add(const void *newItem) {
     return true;
 }
 
+bool BtreeStorage::removeByKey(uint32_t key) {
+    for(bsize_t i = 0; i<currentSize; ++i) {
+        if(keyAccessor(memoryOf(binTree, i)) == key) {
+            removeIndex(i);
+            return true;
+        }
+    }
+    return false;
+}
+
+void BtreeStorage::removeIndex(bsize_t index) {
+    // given the insert position, work out the number of items to move
+    int amtToMove = (currentSize - index) - 1;
+
+    serdebugF4("remove ", amtToMove, index, currentCapacity);
+
+    // move the instances in reverse order using their assignment operator.
+    if(amtToMove > 0) {
+        for (bsize_t i = index; i < index + amtToMove; ++i) {
+            copier(memoryOf(binTree, i), memoryOf(binTree, i + 1));
+        }
+    }
+    currentSize--;
+}
+
 /**
  * Check the capacity of the list, increasing the size if needed. This is normally called before an add operation
  * to ensure there will be space to add another item.

src/SimpleCollections.h

@@ -64,6 +64,10 @@ namespace ioaTreeInternal {
 
         bool add(const void *newItem);
 
+        bool removeByKey(uint32_t key);
+
+        void removeIndex(bsize_t index);
+
         bsize_t nearestLocation(uint32_t key);
 
         void *getByKey(uint32_t key);
@@ -145,6 +149,19 @@ template<class K, class V> class BtreeList {
      */
     V* getByKey(K key) { return reinterpret_cast<V*>(treeStorage.getByKey(key)); };
 
+    /**
+     * Remove an item using the key it was added with
+     * @param key the key to remove
+     * @return true if successful otherwise false.
+     */
+    bool removeByKey(K key) { return treeStorage.removeByKey(key); }
+
+    /**
+     * Remove an item by index in the underlying array
+     * @param index the index in the array
+     */
+     void removeIndex(bsize_t index) { treeStorage.removeIndex(index); }
+
     /**
      * gets the nearest location to the key, this is an in-exact method in that it gives the exact match if available
      * or otherwise the nearest one that is lower.

tests/collectionTests/SimpleCollectionsTest.cpp

@@ -181,3 +181,72 @@ test(testAddingWithSortAndResizeBy5) {
     assertEqual(btreeList.getByKey(9)->getItem(), 108);
 
 }
+
+class NumericStorageItem {
+private:
+    uint32_t item;
+
+public:
+    NumericStorageItem() : item(0xffffffff) {}
+    explicit NumericStorageItem(uint32_t value) : item(value) {}
+    NumericStorageItem(const NumericStorageItem& other) = default;
+    NumericStorageItem& operator= (const NumericStorageItem& other) = default;
+    uint32_t getKey() const { return item; }
+};
+
+void printArray(const NumericStorageItem* list, int size) {
+    char sz[160];
+    strcpy(sz, "array: ");
+    for(int i=0;i<size;i++) {
+        char intBuf[10];
+        itoa((int)(list[i].getKey()), intBuf, 10);
+        strcat(sz, intBuf);
+        strcat(sz, " ");
+    }
+    serdebug(sz);
+}
+
+
+test(testAddingThenRemovingThenAddingItems) {
+    BtreeList<uint32_t, NumericStorageItem> myList;
+
+    for(int i=0;i<20;i++) {
+        myList.add(NumericStorageItem(i + 100));
+    }
+
+    // should have 20 items now
+    assertEqual(myList.count(), bsize_t(20));
+
+    // remove key 102
+    assertTrue(myList.removeByKey(102));
+    assertFalse(myList.removeByKey(10002));
+
+    printArray(myList.items(), myList.count());
+
+    // should have 19 items
+    assertEqual(myList.count(), bsize_t(19));
+
+    // ensure that only 102 was removed
+    assertTrue(myList.getByKey(102) == nullptr);
+    assertTrue(myList.getByKey(103) != nullptr);
+    assertTrue(myList.getByKey(101) != nullptr);
+
+    // put 102 back
+    myList.add(NumericStorageItem(102));
+
+    printArray(myList.items(), myList.count());
+
+    for(int i=0;i<20;i++) {
+        auto entry = myList.itemAtIndex(i);
+        assertEqual(entry->getKey(), uint32_t(i + 100));
+    }
+
+    // now test removing the edge cases, IE head and tail of list
+    myList.removeIndex(0);
+    myList.removeIndex(19);
+    printArray(myList.items(), myList.count());
+
+    assertEqual(myList.count(), bsize_t(18));
+    assertTrue(myList.getByKey(100) == nullptr);
+    assertTrue(myList.getByKey(119) == nullptr);
+}