Rework on AbstractList and Implementing AbstractEntry (#10)

* build superclass for entries in the list; reorder methods; code-style; update readme links; add platformio badge

* remove usage of size_t

* fix macro calls

* clang

Author: nkaaf

README.md

@@ -1,4 +1,6 @@
-# List ![Build Status](https://github.com/nkaaf/List/workflows/Arduino%20Library%20CI/badge.svg)
+# List
+![Build Status](https://github.com/nkaaf/List/workflows/Arduino%20Library%20CI/badge.svg)
+[![PlatformIO Registry](https://badges.registry.platformio.org/packages/nkaaf/library/List.svg)](https://registry.platformio.org/libraries/nkaaf/List)
 
 Library to extend the Arduino Ecosystem with different List Implementations.
 
@@ -8,7 +10,7 @@ https://semver.org/ compliant
 
 ## Arduino Library References
 
-* https://www.arduino.cc/en/Reference/APIStyleGuide
-* https://www.arduino.cc/en/Reference/StyleGuide
-* https://arduino.github.io/arduino-cli/0.19/library-specification/
-* https://arduino.github.io/arduino-cli/0.19/sketch-specification/
+* https://docs.arduino.cc/hacking/software/ArduinoStyleGuide
+* https://docs.arduino.cc/hacking/software/LibraryTutorial
+* https://arduino.github.io/arduino-cli/0.21/library-specification/
+* https://arduino.github.io/arduino-cli/0.21/sketch-specification/

keywords.txt

@@ -14,16 +14,16 @@ SingleLinkedList	KEYWORD1
 # Methods and Functions (KEYWORD2)
 ###########################################
 
+add	KEYWORD2
 addAtIndex	KEYWORD2
-remove	KEYWORD2
+addAll	KEYWORD2
+addFirst	KEYWORD2
+addLast	KEYWORD2
 getValue	KEYWORD2
 getPointer	KEYWORD2
-addLast	KEYWORD2
-addFirst	KEYWORD2
-add	KEYWORD2
-addAll	KEYWORD2
-toArray	KEYWORD2
+remove	KEYWORD2
 getSize	KEYWORD2
 isMutable	KEYWORD2
 isEmpty	KEYWORD2
-equals	KEYWORD2
+toArray	KEYWORD2
+equals	KEYWORD2

src/AbstractList.hpp

@@ -27,6 +27,7 @@
 #define LIST_ABSTRACT_LIST_HPP
 
 #include <stdlib.h>
+#include <string.h>
 
 /*!
  * @brief   Abstract class from which all lists can be derived.
@@ -35,10 +36,48 @@
  */
 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 = true; /// Is the list mutable or immutable.
 
 protected:
+  /// Sometimes it is allowed, that index == this->getSize() to insert it behind
+  /// the last entry
+#define extendedIsIndexOutOfBounds(index)                                      \
+  ((index) != this->getSize() && this->isIndexOutOfBounds(index))
+
+  /// Create a final Value from the given Value
+#define createFinalValue(value, finalValue, T)                                 \
+  finalValue = (T *)malloc(sizeof(T));                                         \
+  memcpy(finalValue, &(value), sizeof(T));
+
+  /**
+   * Class representing an abstract entry in the list.
+   */
+  class AbstractEntry {
+  private:
+    T *value = nullptr; /// Pointer to the value.
+
+  public:
+    /*!
+     * @brief   Constructor of an AbstractEntry Object.
+     *
+     * @param value Value of the entry.
+     */
+    explicit AbstractEntry(T *value) : value(value) {}
+
+    /*!
+     * @brief   Free the memory of the value to prevent memory leaks.
+     */
+    void freeValue() { free(value); }
+
+    /*!
+     * @brief   Get the value of the entry.
+     *
+     * @return  Pointer to the value of the entry.
+     */
+    T *getValue() { return value; };
+  };
+
   /*!
    * @brief Constructor of an AbstractList Object.
    *
@@ -50,13 +89,13 @@ template <typename T> class AbstractList {
    * @brief Increase the size of the list by one. Should only be called after an
    *        insertion!
    */
-  void increaseSize() { this->size++; }
+  void increaseSize() { size++; }
 
   /*!
    * @brief Decrease the size of the list by one. Should only be called after an
    *        deletion!
    */
-  void decreaseSize() { this->size--; }
+  void decreaseSize() { size--; }
 
   /*!
    * @brief Method to verify if the given index is out of the range of the list
@@ -66,9 +105,7 @@ template <typename T> class AbstractList {
    * @return    true if the given index is in the range of the list; false
    *            otherwise
    */
-  bool isIndexOutOfBounds(int index) {
-    return index < 0 || index >= this->getSize();
-  }
+  bool isIndexOutOfBounds(int index) { return index < 0 || index >= getSize(); }
 
   /*!
    * @brief Get a pointer to the entry at the given index. If the given index
@@ -82,6 +119,14 @@ template <typename T> class AbstractList {
   virtual T *get(int index) = 0;
 
 public:
+  /*!
+   * @brief Add a new entry at the end of the list.
+   * @see   addLast()
+   *
+   * @param value   Value to add.
+   */
+  void add(T &value) { addLast(value); }
+
   /*!
    * @brief Add the value to the list at the given index. The original entry at
    *        this index, and followings, will be placed directly after the new
@@ -95,28 +140,47 @@ template <typename T> class AbstractList {
   virtual void addAtIndex(int index, T &value) = 0;
 
   /*!
-   * @brief Remove the entry at the given index.
+   * @brief Add all entries from the given list to this list at the given index.
+   *        The original entry at this index, and followings, will be placed
+   *        directly after the entries of the given list.
    *
-   * @param index   Index of element to remove.
+   * @param index   Index, at which the list should be added.
+   * @param list    List to add.
    */
-  virtual void remove(int index) = 0;
+  void addAll(int index, AbstractList<T> &list) {
+    for (int i = 0; i < list.getSize(); i++) {
+      T val = list.getValue(i);
+      T *finalValue;
+      createFinalValue(val, finalValue, T);
+      addAtIndex(index++, *finalValue);
+      if (!this->isMutable()) {
+        free(finalValue);
+      }
+    }
+  }
 
   /*!
-   * @brief Get the value at the index.
-   * @note  Be safe, that the index exists otherwise the program will crash
-   *        here!
+   * @brief Add all entries from the given list at the end of the list.
+   * @see   addLast()
    *
-   * @param index   Index of element to get.
-   * @return    Value.
+   * @param list    Other list to copy from.
    */
-  T getValue(int index) {
-    T *ptr = getPointer(index);
-    T val = *ptr;
-    if (!this->isMutable()) {
-      free(ptr);
-    }
-    return val;
-  }
+  void addAll(AbstractList<T> &list) { addAll(getSize(), list); }
+
+  /*!
+   * @brief Add a new entry at the beginning of the list.
+   *
+   * @param value   Value to add.
+   */
+  void addFirst(T &value) { addAtIndex(0, value); }
+
+  /*!
+   * @brief Add a new entry at the end of the list.
+   * @see   add()
+   *
+   * @param value   Value to add.
+   */
+  void addLast(T &value) { addAtIndex(getSize(), value); }
 
   /*!
    * @brief Get a pointer to the entry at the given index. If the given index
@@ -130,55 +194,49 @@ template <typename T> class AbstractList {
   T *getPointer(int index) { return get(index); }
 
   /*!
-   * @brief Add a new entry at the end of the list.
-   * @see   add()
+   * @brief Get the value at the index.
+   * @note  Be safe, that the index exists otherwise the program will crash
+   *        here!
    *
-   * @param value   Value to add.
+   * @param index   Index of element to get.
+   * @return    Value.
    */
-  void addLast(T &value) { this->addAtIndex(this->getSize(), value); }
+  T getValue(int index) {
+    T *ptr = getPointer(index);
+    T val = *ptr;
+    if (!isMutable()) {
+      free(ptr);
+    }
+    return val;
+  }
 
   /*!
-   * @brief Add a new entry at the beginning of the list.
+   * @brief Remove the entry at the given index.
    *
-   * @param value   Value to add.
+   * @param index   Index of element to remove.
    */
-  void addFirst(T &value) { this->addAtIndex(0, value); }
+  virtual void remove(int index) = 0;
 
   /*!
-   * @brief Add a new entry at the end of the list.
-   * @see   addLast()
+   * @brief Get the number how many elements are saved in the list.
    *
-   * @param value   Value to add.
+   * @return    Size of the list.
    */
-  void add(T &value) { this->addLast(value); }
+  int getSize() { return size; }
 
   /*!
-   * @brief Add all entries from the given list at the end of the list.
-   * @see   addLast()
+   * @brief Check if the list is mutable.
    *
-   * @param list    Other list to copy from.
+   * @return    true if the list is mutable; false otherwise.
    */
-  void addAll(AbstractList<T> &list) { this->addAll(this->getSize(), list); }
+  bool isMutable() { return mutableList; }
 
   /*!
-   * @brief Add all entries from the given list to this list at the given index.
-   *        The original entry at this index, and followings, will be placed
-   *        directly after the entries of the given list.
+   * @brief Check if the list is empty.
    *
-   * @param index   Index, at which the list should be added.
-   * @param list    List to add.
+   * @return    true if the list is empty; false otherwise
    */
-  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);
-      }
-    }
-  }
+  bool isEmpty() { return size == 0; }
 
   /*!
    * @brief Get an array which represent the list.
@@ -188,40 +246,19 @@ template <typename T> class AbstractList {
    * @return    Array representation of the list or null if the list is empty.
    */
   T *toArray() {
-    if (this->getSize() == 0) {
+    if (getSize() == 0) {
       return nullptr;
     }
 
-    T *arr = (T *)malloc(this->getSize() * sizeof(T));
+    T *arr = (T *)malloc(getSize() * sizeof(T));
 
-    for (int i = 0; i < this->getSize(); ++i) {
-      arr[i] = this->getValue(i);
+    for (int i = 0; i < getSize(); ++i) {
+      arr[i] = getValue(i);
     }
 
     return arr;
   }
 
-  /*!
-   * @brief Get the number how many elements are saved in the list.
-   *
-   * @return    Size of the list.
-   */
-  int getSize() { return this->size; }
-
-  /*!
-   * @brief Check if the list is mutable.
-   *
-   * @return    true if the list is mutable; false otherwise.
-   */
-  bool isMutable() { return mutableList; }
-
-  /*!
-   * @brief Check if the list is empty.
-   *
-   * @return    true if the list is empty; false otherwise
-   */
-  bool isEmpty() { return this->size == 0; }
-
   /*!
    * @brief Compare two lists whether their attributes and entries are equal.
    * @note  If you use this list for non-primitive data types, check if the
@@ -231,16 +268,16 @@ template <typename T> class AbstractList {
    * @return    true if the lists are equal; false otherwise.
    */
   bool equals(AbstractList<T> &list) {
-    if (list.isMutable() != this->isMutable()) {
+    if (list.isMutable() != isMutable()) {
       return false;
     }
 
-    if (list.getSize() != this->getSize()) {
+    if (list.getSize() != getSize()) {
       return false;
     }
 
-    for (int i = 0; i < this->getSize(); i++) {
-      if (list.getValue(i) != this->getValue(i)) {
+    for (int i = 0; i < getSize(); i++) {
+      if (list.getValue(i) != getValue(i)) {
         return false;
       }
     }
@@ -272,7 +309,7 @@ template <typename T> class AbstractList {
    *
    * @param value   Value to add.
    */
-  void operator+(T &value) { this->addLast(value); }
+  void operator+(T &value) { this->add(value); }
 
   /*!
    * @brief Add all entries from the given list at the end of the list.
@@ -283,4 +320,4 @@ template <typename T> class AbstractList {
   void operator+(AbstractList<T> &list) { this->addAll(list); }
 };
 
-#endif /* LIST_ABSTRACT_LIST_HPP */
+#endif // LIST_ABSTRACT_LIST_HPP

src/List.hpp

@@ -62,4 +62,4 @@ template <typename T> class List : public SingleLinkedList<T> {
       : SingleLinkedList<T>(mutableList) {}
 };
 
-#endif /* LIST_HPP */
+#endif // LIST_HPP