implement clear() (alias: removeAll()) (#13); make AbstractList per default immutable

Author: nkaaf

src/AbstractList.hpp

@@ -36,8 +36,8 @@
  */
 template <typename T> class AbstractList {
 private:
-  int size = 0;            /// Size of the list.
-  bool mutableList = true; /// Is the list mutable or immutable.
+  int size = 0;             /// Size of the list.
+  bool mutableList = false; /// Is the list mutable or immutable.
 
 protected:
   /// Sometimes it is allowed, that index == this->getSize() to insert it behind
@@ -97,6 +97,11 @@ template <typename T> class AbstractList {
    */
   void decreaseSize() { size--; }
 
+  /*!
+   * @brief Reset the size to zero.
+   */
+  void resetSize() { size = 0; }
+
   /*!
    * @brief Method to verify if the given index is out of the range of the list
    *        size.
@@ -210,13 +215,24 @@ template <typename T> class AbstractList {
     return val;
   }
 
+  /*!
+   * @brief Remove all elements from the List.
+   */
+  virtual void clear() = 0;
+
   /*!
    * @brief Remove the entry at the given index.
    *
    * @param index   Index of element to remove.
    */
   virtual void remove(int index) = 0;
 
+  /*!
+   * @brief Remove all elements from the List.
+   * @note Alias of clear().
+   */
+  void removeAll() { clear(); }
+
   /*!
    * @brief Get the number how many elements are saved in the list.
    *

src/DoubleLinkedList.hpp

@@ -126,22 +126,7 @@ template <typename T> class DoubleLinkedList : public AbstractList<T> {
   /*!
    * @brief Destructor of a DoubleLinkedList Object.
    */
-  ~DoubleLinkedList() {
-    if (head != nullptr) {
-      Entry *current = head;
-      Entry *next;
-      for (int i = 0; i < this->getSize(); ++i) {
-        next = current->getNext();
-
-        if (!this->isMutable()) {
-          current->freeValue();
-        }
-
-        delete current;
-        current = next;
-      }
-    }
-  }
+  ~DoubleLinkedList() { this->clear(); }
 
   void addAtIndex(int index, T &value) override {
     // it is allowed, that index == this->getSize() to insert it behind the last
@@ -203,6 +188,27 @@ template <typename T> class DoubleLinkedList : public AbstractList<T> {
     this->increaseSize();
   };
 
+  void clear() override {
+    if (this->getSize() > 0) {
+      Entry *current = head;
+      Entry *next;
+      for (int i = 0; i < this->getSize(); ++i) {
+        next = current->getNext();
+
+        if (!this->isMutable()) {
+          current->freeValue();
+        }
+
+        delete current;
+        current = next;
+      }
+    }
+
+    this->resetSize();
+    head = nullptr;
+    tail = nullptr;
+  }
+
   void remove(int index) override {
     if (this->isIndexOutOfBounds(index)) {
       return;

src/SingleLinkedList.hpp

@@ -104,22 +104,7 @@ template <typename T> class SingleLinkedList : public AbstractList<T> {
   /*!
    * @brief Destructor of a SingleLinkedList Object.
    */
-  ~SingleLinkedList() {
-    if (head != nullptr) {
-      Entry *current = head;
-      Entry *next;
-      for (int i = 0; i < this->getSize(); i++) {
-        next = current->getNext();
-
-        if (!this->isMutable()) {
-          current->freeValue();
-        }
-
-        delete current;
-        current = next;
-      }
-    }
-  }
+  ~SingleLinkedList() { this->clear(); }
 
   void addAtIndex(int index, T &value) override {
     // it is allowed, that index == this->getSize() to insert it behind the last
@@ -164,6 +149,27 @@ template <typename T> class SingleLinkedList : public AbstractList<T> {
     this->increaseSize();
   };
 
+  void clear() override {
+    if (this->getSize() > 0) {
+      Entry *current = head;
+      Entry *next;
+      for (int i = 0; i < this->getSize(); ++i) {
+        next = current->getNext();
+
+        if (!this->isMutable()) {
+          current->freeValue();
+        }
+
+        delete current;
+        current = next;
+      }
+
+      this->resetSize();
+      head = nullptr;
+      tail = nullptr;
+    }
+  }
+
   void remove(int index) override {
     if (this->isIndexOutOfBounds(index)) {
       return;