fix clang format

Author: nkaaf

src/AbstractList.hpp

@@ -103,18 +103,19 @@ template <typename T> class AbstractList {
 
   /*!
    * @brief Get the value at the index.
-   * @note  Be safe, that the index exists otherwise the program will crash here!
+   * @note  Be safe, that the index exists otherwise the program will crash
+   *        here!
    *
    * @param index   Index of element to get.
    * @return    Value.
    */
   T getValue(int index) {
-      T* ptr = getPointer(index);
-      T val = *ptr;
-      if (!this->isMutable()) {
-          free(ptr);
-      }
-      return val;
+    T *ptr = getPointer(index);
+    T val = *ptr;
+    if (!this->isMutable()) {
+      free(ptr);
+    }
+    return val;
   }
 
   /*!
@@ -157,9 +158,7 @@ template <typename T> class AbstractList {
    *
    * @param list    Other list to copy from.
    */
-  void addAll(AbstractList<T> &list) {
-    this->addAll(this->getSize(), list);
-  }
+  void addAll(AbstractList<T> &list) { this->addAll(this->getSize(), list); }
 
   /*!
    * @brief Add all entries from the given list to this list at the given index.
@@ -171,13 +170,13 @@ template <typename T> class AbstractList {
    */
   void addAll(int index, AbstractList<T> &list) {
     for (int i = 0; i < list.getSize(); i++) {
-        T val = list.getValue(i);
-        T *finalValue = (T *)malloc(sizeof(T));
-        memcpy(finalValue, &val, sizeof(T));
-        this->addAtIndex(index++, *finalValue);
-        if (!this->isMutable()) {
-            free(finalValue);
-        }
+      T val = list.getValue(i);
+      T *finalValue = (T *)malloc(sizeof(T));
+      memcpy(finalValue, &val, sizeof(T));
+      this->addAtIndex(index++, *finalValue);
+      if (!this->isMutable()) {
+        free(finalValue);
+      }
     }
   }
 

src/List.hpp

@@ -55,7 +55,8 @@ template <typename T> class List : public SingleLinkedList<T> {
   /*!
    * @brief Constructor of a List Object.
    *
-   * @param mutableList true if the list should be mutable; false otherwise (default).
+   * @param mutableList true if the list should be mutable; false otherwise
+   *                    (default).
    */
   explicit List<T>(bool mutableList = false)
       : SingleLinkedList<T>(mutableList) {}

src/SingleLinkedList.hpp

@@ -89,32 +89,33 @@ template <typename T> class SingleLinkedList : public AbstractList<T> {
   Entry *tail = nullptr; /// The last entry of the list.
 
 protected:
-    T *get(int index) override {
-        if (this->isIndexOutOfBounds(index)) {
-            return nullptr;
-        }
+  T *get(int index) override {
+    if (this->isIndexOutOfBounds(index)) {
+      return nullptr;
+    }
 
-        Entry *current = this->head;
-        int i = 0;
-        while (i != index) {
-            current = current->getNext();
-            i++;
-        }
+    Entry *current = this->head;
+    int i = 0;
+    while (i != index) {
+      current = current->getNext();
+      i++;
+    }
 
-        if (this->isMutable()) {
-            return (T *) current->getValue();
-        } else {
-            T *finalValue = (T *)malloc(sizeof(T));
-            memcpy(finalValue, current->getValue(), sizeof(T));
-            return finalValue;
-        }
+    if (this->isMutable()) {
+      return (T *)current->getValue();
+    } else {
+      T *finalValue = (T *)malloc(sizeof(T));
+      memcpy(finalValue, current->getValue(), sizeof(T));
+      return finalValue;
     }
+  }
 
 public:
   /*!
    * @brief Constructor of a SingleLinkedList Object.
    *
-   * @param mutableList true if the list should be mutable; false otherwise (default).
+   * @param mutableList true if the list should be mutable; false otherwise
+   *                    (default).
    */
   explicit SingleLinkedList<T>(bool mutableList = false)
       : AbstractList<T>(mutableList) {}