From 98f89302c43c990b3eeb3df21cd15029de8a697b Mon Sep 17 00:00:00 2001
From: Robin Mueller <robin.mueller.m@gmail.com>
Date: Thu, 28 Jan 2021 11:44:49 +0100
Subject: [PATCH] tabs replaced by spaces

---
 container/ArrayList.h              |  398 +++++-----
 container/BinaryTree.h             |  234 +++---
 container/DynamicFIFO.h            |   64 +-
 container/FIFO.h                   |   48 +-
 container/FIFOBase.h               |  112 +--
 container/FIFOBase.tpp             |   82 +-
 container/FixedArrayList.h         |   38 +-
 container/FixedMap.h               |  354 ++++-----
 container/FixedOrderedMultimap.h   |  282 +++----
 container/FixedOrderedMultimap.tpp |  136 ++--
 container/HybridIterator.h         |  124 +--
 container/IndexedRingMemoryArray.h | 1178 ++++++++++++++--------------
 container/PlacementFactory.h       |   84 +-
 container/RingBufferBase.h         |  166 ++--
 container/SharedRingBuffer.cpp     |   40 +-
 container/SharedRingBuffer.h       |  122 +--
 container/SimpleRingBuffer.cpp     |  152 ++--
 container/SimpleRingBuffer.h       |  178 ++---
 container/SinglyLinkedList.h       |  176 ++---
 19 files changed, 1984 insertions(+), 1984 deletions(-)

diff --git a/container/ArrayList.h b/container/ArrayList.h
index 6bd5c1d5..25e281a2 100644
--- a/container/ArrayList.h
+++ b/container/ArrayList.h
@@ -6,7 +6,7 @@
 #include "../serialize/SerializeIF.h"
 
 /**
- * @brief 	A List that stores its values in an array.
+ * @brief     A List that stores its values in an array.
  * @details
  * The underlying storage is an array that can be allocated by the class
  * itself or supplied via ctor.
@@ -15,237 +15,237 @@
  */
 template<typename T, typename count_t = uint8_t>
 class ArrayList {
-	template<typename U, typename count> friend class SerialArrayListAdapter;
+    template<typename U, typename count> friend class SerialArrayListAdapter;
 public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::ARRAY_LIST;
-	static const ReturnValue_t FULL = MAKE_RETURN_CODE(0x01);
+    static const uint8_t INTERFACE_ID = CLASS_ID::ARRAY_LIST;
+    static const ReturnValue_t FULL = MAKE_RETURN_CODE(0x01);
 
-	/**
-	 * This is the allocating constructor.
-	 * It allocates an array of the specified size.
-	 * @param maxSize
-	 */
-	ArrayList(count_t maxSize) :
-		size(0), maxSize_(maxSize), allocated(true) {
-		entries = new T[maxSize];
-	}
+    /**
+     * This is the allocating constructor.
+     * It allocates an array of the specified size.
+     * @param maxSize
+     */
+    ArrayList(count_t maxSize) :
+        size(0), maxSize_(maxSize), allocated(true) {
+        entries = new T[maxSize];
+    }
 
-	/**
-	 * This is the non-allocating constructor
-	 *
-	 * It expects a pointer to an array of a certain size and initializes
-	 * itself to it.
-	 *
-	 * @param storage the array to use as backend
-	 * @param maxSize size of storage
-	 * @param size size of data already present in storage
-	 */
-	ArrayList(T *storage, count_t maxSize, count_t size = 0) :
-		size(size), entries(storage), maxSize_(maxSize), allocated(false) {
-	}
+    /**
+     * This is the non-allocating constructor
+     *
+     * It expects a pointer to an array of a certain size and initializes
+     * itself to it.
+     *
+     * @param storage the array to use as backend
+     * @param maxSize size of storage
+     * @param size size of data already present in storage
+     */
+    ArrayList(T *storage, count_t maxSize, count_t size = 0) :
+        size(size), entries(storage), maxSize_(maxSize), allocated(false) {
+    }
 
-	/**
-	 * Copying is forbiden by declaring copy ctor and copy assignment deleted
-	 * It is too ambigous in this case.
-	 * (Allocate a new backend? Use the same? What to do in an modifying call?)
-	 */
-	ArrayList(const ArrayList& other) = delete;
-	const ArrayList& operator=(const ArrayList& other) = delete;
+    /**
+     * Copying is forbiden by declaring copy ctor and copy assignment deleted
+     * It is too ambigous in this case.
+     * (Allocate a new backend? Use the same? What to do in an modifying call?)
+     */
+    ArrayList(const ArrayList& other) = delete;
+    const ArrayList& operator=(const ArrayList& other) = delete;
 
-	/**
-	 * Number of Elements stored in this List
-	 */
-	count_t size;
+    /**
+     * Number of Elements stored in this List
+     */
+    count_t size;
 
 
-	/**
-	 * Destructor, if the allocating constructor was used, it deletes the array.
-	 */
-	virtual ~ArrayList() {
-		if (allocated) {
-			delete[] entries;
-		}
-	}
+    /**
+     * Destructor, if the allocating constructor was used, it deletes the array.
+     */
+    virtual ~ArrayList() {
+        if (allocated) {
+            delete[] entries;
+        }
+    }
 
-	/**
-	 * An Iterator to go trough an ArrayList
-	 *
-	 * It stores a pointer to an element and increments the
-	 * pointer when incremented itself.
-	 */
-	class Iterator {
-	public:
-		/**
-		 * Empty ctor, points to NULL
-		 */
-		Iterator(): value(0) {}
+    /**
+     * An Iterator to go trough an ArrayList
+     *
+     * It stores a pointer to an element and increments the
+     * pointer when incremented itself.
+     */
+    class Iterator {
+    public:
+        /**
+         * Empty ctor, points to NULL
+         */
+        Iterator(): value(0) {}
 
-		/**
-		 * Initializes the Iterator to point to an element
-		 *
-		 * @param initialize
-		 */
-		Iterator(T *initialize) {
-			value = initialize;
-		}
+        /**
+         * Initializes the Iterator to point to an element
+         *
+         * @param initialize
+         */
+        Iterator(T *initialize) {
+            value = initialize;
+        }
 
-		/**
-		 * The current element the iterator points to
-		 */
-		T *value;
+        /**
+         * The current element the iterator points to
+         */
+        T *value;
 
-		Iterator& operator++() {
-			value++;
-			return *this;
-		}
+        Iterator& operator++() {
+            value++;
+            return *this;
+        }
 
-		Iterator operator++(int) {
-			Iterator tmp(*this);
-			operator++();
-			return tmp;
-		}
+        Iterator operator++(int) {
+            Iterator tmp(*this);
+            operator++();
+            return tmp;
+        }
 
-		Iterator& operator--() {
-			value--;
-			return *this;
-		}
+        Iterator& operator--() {
+            value--;
+            return *this;
+        }
 
-		Iterator operator--(int) {
-			Iterator tmp(*this);
-			operator--();
-			return tmp;
-		}
+        Iterator operator--(int) {
+            Iterator tmp(*this);
+            operator--();
+            return tmp;
+        }
 
-		T& operator*() {
-			return *value;
-		}
+        T& operator*() {
+            return *value;
+        }
 
-		const T& operator*() const {
-			return *value;
-		}
+        const T& operator*() const {
+            return *value;
+        }
 
-		T *operator->() {
-			return value;
-		}
+        T *operator->() {
+            return value;
+        }
 
-		const T *operator->() const {
-			return value;
-		}
-	};
+        const T *operator->() const {
+            return value;
+        }
+    };
 
-	friend bool operator==(const ArrayList::Iterator& lhs,
-			const ArrayList::Iterator& rhs) {
-		return (lhs.value == rhs.value);
-	}
+    friend bool operator==(const ArrayList::Iterator& lhs,
+            const ArrayList::Iterator& rhs) {
+        return (lhs.value == rhs.value);
+    }
 
-	friend bool operator!=(const ArrayList::Iterator& lhs,
-			const ArrayList::Iterator& rhs) {
-		return not (lhs.value == rhs.value);
-	}
+    friend bool operator!=(const ArrayList::Iterator& lhs,
+            const ArrayList::Iterator& rhs) {
+        return not (lhs.value == rhs.value);
+    }
 
-	/**
-	 * Iterator pointing to the first stored elmement
-	 *
-	 * @return Iterator to the first element
-	 */
-	Iterator begin() const {
-		return Iterator(&entries[0]);
-	}
+    /**
+     * Iterator pointing to the first stored elmement
+     *
+     * @return Iterator to the first element
+     */
+    Iterator begin() const {
+        return Iterator(&entries[0]);
+    }
 
-	/**
-	 * returns an Iterator pointing to the element after the last stored entry
-	 *
-	 * @return Iterator to the element after the last entry
-	 */
-	Iterator end() const {
-		return Iterator(&entries[size]);
-	}
+    /**
+     * returns an Iterator pointing to the element after the last stored entry
+     *
+     * @return Iterator to the element after the last entry
+     */
+    Iterator end() const {
+        return Iterator(&entries[size]);
+    }
 
-	T & operator[](count_t i) const {
-		return entries[i];
-	}
+    T & operator[](count_t i) const {
+        return entries[i];
+    }
 
-	/**
-	 * The first element
-	 *
-	 * @return pointer to the first stored element
-	 */
-	T *front() {
-		return entries;
-	}
+    /**
+     * The first element
+     *
+     * @return pointer to the first stored element
+     */
+    T *front() {
+        return entries;
+    }
 
-	/**
-	 * The last element
-	 *
-	 * does not return a valid pointer if called on an empty list.
-	 *
-	 * @return pointer to the last stored element
-	 */
-	T *back() {
-		return &entries[size - 1];
-		//Alternative solution
-		//return const_cast<T*>(static_cast<const T*>(*this).back());
-	}
+    /**
+     * The last element
+     *
+     * does not return a valid pointer if called on an empty list.
+     *
+     * @return pointer to the last stored element
+     */
+    T *back() {
+        return &entries[size - 1];
+        //Alternative solution
+        //return const_cast<T*>(static_cast<const T*>(*this).back());
+    }
 
-	const T* back() const{
-		return &entries[size-1];
-	}
+    const T* back() const{
+        return &entries[size-1];
+    }
 
-	/**
-	 * The maximum number of elements this List can contain
-	 *
-	 * @return maximum number of elements
-	 */
-	size_t maxSize() const {
-		return this->maxSize_;
-	}
+    /**
+     * The maximum number of elements this List can contain
+     *
+     * @return maximum number of elements
+     */
+    size_t maxSize() const {
+        return this->maxSize_;
+    }
 
-	/**
-	 * Insert a new element into the list.
-	 *
-	 * The new element is inserted after the last stored element.
-	 *
-	 * @param entry
-	 * @return
-	 *          -@c FULL if the List is full
-	 *          -@c RETURN_OK else
-	 */
-	ReturnValue_t insert(T entry) {
-		if (size >= maxSize_) {
-			return FULL;
-		}
-		entries[size] = entry;
-		++size;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+    /**
+     * Insert a new element into the list.
+     *
+     * The new element is inserted after the last stored element.
+     *
+     * @param entry
+     * @return
+     *          -@c FULL if the List is full
+     *          -@c RETURN_OK else
+     */
+    ReturnValue_t insert(T entry) {
+        if (size >= maxSize_) {
+            return FULL;
+        }
+        entries[size] = entry;
+        ++size;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 
-	/**
-	 * clear the List
-	 *
-	 * This does not actually clear all entries, it only sets the size to 0.
-	 */
-	void clear() {
-		size = 0;
-	}
+    /**
+     * clear the List
+     *
+     * This does not actually clear all entries, it only sets the size to 0.
+     */
+    void clear() {
+        size = 0;
+    }
 
-	count_t remaining() {
-		return (maxSize_ - size);
-	}
+    count_t remaining() {
+        return (maxSize_ - size);
+    }
 
 protected:
-	/**
-	 * pointer to the array in which the entries are stored
-	 */
-	T *entries;
-	/**
-	 * remembering the maximum size
-	 */
-	size_t maxSize_;
+    /**
+     * pointer to the array in which the entries are stored
+     */
+    T *entries;
+    /**
+     * remembering the maximum size
+     */
+    size_t maxSize_;
 
-	/**
-	 * true if the array was allocated and needs to be deleted in the destructor.
-	 */
-	bool allocated;
+    /**
+     * true if the array was allocated and needs to be deleted in the destructor.
+     */
+    bool allocated;
 };
 
 
diff --git a/container/BinaryTree.h b/container/BinaryTree.h
index 73073dea..6200cbb1 100644
--- a/container/BinaryTree.h
+++ b/container/BinaryTree.h
@@ -7,65 +7,65 @@
 template<typename Tp>
 class BinaryNode {
 public:
-	BinaryNode(Tp* setValue) :
-			value(setValue), left(NULL), right(NULL), parent(NULL) {
-	}
-	Tp *value;
-	BinaryNode* left;
-	BinaryNode* right;
-	BinaryNode* parent;
+    BinaryNode(Tp* setValue) :
+            value(setValue), left(NULL), right(NULL), parent(NULL) {
+    }
+    Tp *value;
+    BinaryNode* left;
+    BinaryNode* right;
+    BinaryNode* parent;
 };
 
 template<typename Tp>
 class ExplicitNodeIterator {
 public:
-	typedef ExplicitNodeIterator<Tp> _Self;
-	typedef BinaryNode<Tp> _Node;
-	typedef Tp value_type;
-	typedef Tp* pointer;
-	typedef Tp& reference;
-	ExplicitNodeIterator() :
-			element(NULL) {
-	}
-	ExplicitNodeIterator(_Node* node) :
-			element(node) {
-	}
-	BinaryNode<Tp>* element;
-	_Self up() {
-		return _Self(element->parent);
-	}
-	_Self left() {
-		if (element != NULL) {
-			return _Self(element->left);
-		} else {
-			return _Self(NULL);
-		}
+    typedef ExplicitNodeIterator<Tp> _Self;
+    typedef BinaryNode<Tp> _Node;
+    typedef Tp value_type;
+    typedef Tp* pointer;
+    typedef Tp& reference;
+    ExplicitNodeIterator() :
+            element(NULL) {
+    }
+    ExplicitNodeIterator(_Node* node) :
+            element(node) {
+    }
+    BinaryNode<Tp>* element;
+    _Self up() {
+        return _Self(element->parent);
+    }
+    _Self left() {
+        if (element != NULL) {
+            return _Self(element->left);
+        } else {
+            return _Self(NULL);
+        }
 
-	}
-	_Self right() {
-		if (element != NULL) {
-			return _Self(element->right);
-		} else {
-			return _Self(NULL);
-		}
+    }
+    _Self right() {
+        if (element != NULL) {
+            return _Self(element->right);
+        } else {
+            return _Self(NULL);
+        }
 
-	}
-	bool operator==(const _Self& __x) const {
-		return element == __x.element;
-	}
-	bool operator!=(const _Self& __x) const {
-		return element != __x.element;
-	}
+    }
+    bool operator==(const _Self& __x) const {
+        return element == __x.element;
+    }
+    bool operator!=(const _Self& __x) const {
+        return element != __x.element;
+    }
     pointer
     operator->() const {
-    	if (element != NULL) {
-    		return element->value;
-    	} else {
-    		return NULL;
-    	}
+        if (element != NULL) {
+            return element->value;
+        } else {
+            return NULL;
+        }
     }
     pointer operator*() const {
-    	return this->operator->();
+        return this->operator->();
     }
 };
 
@@ -75,77 +75,77 @@ public:
 template<typename Tp>
 class BinaryTree {
 public:
-	typedef ExplicitNodeIterator<Tp> iterator;
-	typedef BinaryNode<Tp> Node;
-	typedef std::pair<iterator, iterator> children;
-	BinaryTree() :
-			rootNode(NULL) {
-	}
-	BinaryTree(Node* rootNode) :
-			rootNode(rootNode) {
-	}
-	iterator begin() const {
-		return iterator(rootNode);
-	}
-	static iterator end() {
-		return iterator(NULL);
-	}
-	iterator insert(bool insertLeft, iterator parentNode, Node* newNode ) {
-		newNode->parent = parentNode.element;
-		if (parentNode.element != NULL) {
-			if (insertLeft) {
-				parentNode.element->left = newNode;
-			} else {
-				parentNode.element->right = newNode;
-			}
-		} else {
-			//Insert first element.
-			rootNode = newNode;
-		}
-		return iterator(newNode);
-	}
-	//No recursion to children. Needs to be done externally.
-	children erase(iterator node) {
-		if (node.element == rootNode) {
-			//We're root node
-			rootNode = NULL;
-		} else {
-			//Delete parent's reference
-			if (node.up().left() == node) {
-				node.up().element->left = NULL;
-			} else {
-				node.up().element->right = NULL;
-			}
-		}
-		return children(node.element->left, node.element->right);
-	}
-	static uint32_t countLeft(iterator start) {
-		if (start == end()) {
-			return 0;
-		}
-		//We also count the start node itself.
-		uint32_t count = 1;
-		while (start.left() != end()) {
-			count++;
-			start = start.left();
-		}
-		return count;
-	}
-	static uint32_t countRight(iterator start) {
-		if (start == end()) {
-			return 0;
-		}
-		//We also count the start node itself.
-		uint32_t count = 1;
-		while (start.right() != end()) {
-			count++;
-			start = start.right();
-		}
-		return count;
-	}
+    typedef ExplicitNodeIterator<Tp> iterator;
+    typedef BinaryNode<Tp> Node;
+    typedef std::pair<iterator, iterator> children;
+    BinaryTree() :
+            rootNode(NULL) {
+    }
+    BinaryTree(Node* rootNode) :
+            rootNode(rootNode) {
+    }
+    iterator begin() const {
+        return iterator(rootNode);
+    }
+    static iterator end() {
+        return iterator(NULL);
+    }
+    iterator insert(bool insertLeft, iterator parentNode, Node* newNode ) {
+        newNode->parent = parentNode.element;
+        if (parentNode.element != NULL) {
+            if (insertLeft) {
+                parentNode.element->left = newNode;
+            } else {
+                parentNode.element->right = newNode;
+            }
+        } else {
+            //Insert first element.
+            rootNode = newNode;
+        }
+        return iterator(newNode);
+    }
+    //No recursion to children. Needs to be done externally.
+    children erase(iterator node) {
+        if (node.element == rootNode) {
+            //We're root node
+            rootNode = NULL;
+        } else {
+            //Delete parent's reference
+            if (node.up().left() == node) {
+                node.up().element->left = NULL;
+            } else {
+                node.up().element->right = NULL;
+            }
+        }
+        return children(node.element->left, node.element->right);
+    }
+    static uint32_t countLeft(iterator start) {
+        if (start == end()) {
+            return 0;
+        }
+        //We also count the start node itself.
+        uint32_t count = 1;
+        while (start.left() != end()) {
+            count++;
+            start = start.left();
+        }
+        return count;
+    }
+    static uint32_t countRight(iterator start) {
+        if (start == end()) {
+            return 0;
+        }
+        //We also count the start node itself.
+        uint32_t count = 1;
+        while (start.right() != end()) {
+            count++;
+            start = start.right();
+        }
+        return count;
+    }
 
 protected:
-	Node* rootNode;
+    Node* rootNode;
 };
 
 
diff --git a/container/DynamicFIFO.h b/container/DynamicFIFO.h
index 86d43f7d..e1bc3ef2 100644
--- a/container/DynamicFIFO.h
+++ b/container/DynamicFIFO.h
@@ -5,8 +5,8 @@
 #include <vector>
 
 /**
- * @brief 	Simple First-In-First-Out data structure. The maximum size
- * 			can be set in the constructor.
+ * @brief     Simple First-In-First-Out data structure. The maximum size
+ *             can be set in the constructor.
  * @details
  * The maximum capacity can be determined at run-time, so this container
  * performs dynamic memory allocation!
@@ -17,39 +17,39 @@
 template<typename T>
 class DynamicFIFO: public FIFOBase<T> {
 public:
-	DynamicFIFO(size_t maxCapacity): FIFOBase<T>(nullptr, maxCapacity),
-			fifoVector(maxCapacity)  {
-		// trying to pass the pointer of the uninitialized vector
-		// to the FIFOBase constructor directly lead to a super evil bug.
-		// So we do it like this now.
-		this->setContainer(fifoVector.data());
-	};
+    DynamicFIFO(size_t maxCapacity): FIFOBase<T>(nullptr, maxCapacity),
+            fifoVector(maxCapacity)  {
+        // trying to pass the pointer of the uninitialized vector
+        // to the FIFOBase constructor directly lead to a super evil bug.
+        // So we do it like this now.
+        this->setContainer(fifoVector.data());
+    };
 
-	/**
-	 * @brief	Custom copy constructor which prevents setting the
-	 * 	        underlying pointer wrong. This function allocates memory!
-	 * @details This is a very heavy operation so try to avoid this!
-	 *
-	 */
-	DynamicFIFO(const DynamicFIFO& other): FIFOBase<T>(other),
-			fifoVector(other.maxCapacity) {
-		this->fifoVector = other.fifoVector;
-		this->setContainer(fifoVector.data());
-	}
+    /**
+     * @brief    Custom copy constructor which prevents setting the
+     *             underlying pointer wrong. This function allocates memory!
+     * @details This is a very heavy operation so try to avoid this!
+     *
+     */
+    DynamicFIFO(const DynamicFIFO& other): FIFOBase<T>(other),
+            fifoVector(other.maxCapacity) {
+        this->fifoVector = other.fifoVector;
+        this->setContainer(fifoVector.data());
+    }
 
-	/**
-	 * @brief Custom assignment operator
-	 * @details This is a very heavy operation so try to avoid this!
-	 * @param other DyamicFIFO to copy from
-	 */
-	DynamicFIFO& operator=(const DynamicFIFO& other){
-		FIFOBase<T>::operator=(other);
-		this->fifoVector = other.fifoVector;
-		this->setContainer(fifoVector.data());
-		return *this;
-	}
+    /**
+     * @brief Custom assignment operator
+     * @details This is a very heavy operation so try to avoid this!
+     * @param other DyamicFIFO to copy from
+     */
+    DynamicFIFO& operator=(const DynamicFIFO& other){
+        FIFOBase<T>::operator=(other);
+        this->fifoVector = other.fifoVector;
+        this->setContainer(fifoVector.data());
+        return *this;
+    }
 private:
-	std::vector<T> fifoVector;
+    std::vector<T> fifoVector;
 };
 
 #endif /* FSFW_CONTAINER_DYNAMICFIFO_H_ */
diff --git a/container/FIFO.h b/container/FIFO.h
index 70113852..79ead313 100644
--- a/container/FIFO.h
+++ b/container/FIFO.h
@@ -5,8 +5,8 @@
 #include <array>
 
 /**
- * @brief 	Simple First-In-First-Out data structure with size fixed at
- * 			compile time
+ * @brief     Simple First-In-First-Out data structure with size fixed at
+ *             compile time
  * @details
  * Performs no dynamic memory allocation.
  * The public interface of FIFOBase exposes the user interface for the FIFO.
@@ -16,32 +16,32 @@
 template<typename T, size_t capacity>
 class FIFO: public FIFOBase<T> {
 public:
-	FIFO(): FIFOBase<T>(nullptr, capacity) {
-		this->setContainer(fifoArray.data());
-	};
+    FIFO(): FIFOBase<T>(nullptr, capacity) {
+        this->setContainer(fifoArray.data());
+    };
 
-	/**
-	 * @brief 	Custom copy constructor to set pointer correctly.
-	 * @param other
-	 */
-	FIFO(const FIFO& other): FIFOBase<T>(other) {
-		this->fifoArray = other.fifoArray;
-		this->setContainer(fifoArray.data());
-	}
+    /**
+     * @brief     Custom copy constructor to set pointer correctly.
+     * @param other
+     */
+    FIFO(const FIFO& other): FIFOBase<T>(other) {
+        this->fifoArray = other.fifoArray;
+        this->setContainer(fifoArray.data());
+    }
 
-	/**
-	 * @brief Custom assignment operator
-	 * @param other
-	 */
-	FIFO& operator=(const FIFO& other){
-		FIFOBase<T>::operator=(other);
-		this->fifoArray = other.fifoArray;
-		this->setContainer(fifoArray.data());
-		return *this;
-	}
+    /**
+     * @brief Custom assignment operator
+     * @param other
+     */
+    FIFO& operator=(const FIFO& other){
+        FIFOBase<T>::operator=(other);
+        this->fifoArray = other.fifoArray;
+        this->setContainer(fifoArray.data());
+        return *this;
+    }
 
 private:
-	std::array<T, capacity> fifoArray;
+    std::array<T, capacity> fifoArray;
 };
 
 #endif /* FSFW_CONTAINER_FIFO_H_ */
diff --git a/container/FIFOBase.h b/container/FIFOBase.h
index edd66d37..eaa80346 100644
--- a/container/FIFOBase.h
+++ b/container/FIFOBase.h
@@ -8,70 +8,70 @@
 template <typename T>
 class FIFOBase {
 public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::FIFO_CLASS;
-	static const ReturnValue_t FULL = MAKE_RETURN_CODE(1);
-	static const ReturnValue_t EMPTY = MAKE_RETURN_CODE(2);
+    static const uint8_t INTERFACE_ID = CLASS_ID::FIFO_CLASS;
+    static const ReturnValue_t FULL = MAKE_RETURN_CODE(1);
+    static const ReturnValue_t EMPTY = MAKE_RETURN_CODE(2);
 
-	/** Default ctor, takes pointer to first entry of underlying container
-	 *  and maximum capacity */
-	FIFOBase(T* values, const size_t maxCapacity);
+    /** Default ctor, takes pointer to first entry of underlying container
+     *  and maximum capacity */
+    FIFOBase(T* values, const size_t maxCapacity);
 
-	/**
-	 * Insert value into FIFO
-	 * @param value
-	 * @return RETURN_OK on success, FULL if full
-	 */
-	ReturnValue_t insert(T value);
-	/**
-	 * Retrieve item from FIFO. This removes the item from the FIFO.
-	 * @param value Must point to a valid T
-	 * @return RETURN_OK on success, EMPTY if empty and FAILED if nullptr check failed
-	 */
-	ReturnValue_t retrieve(T *value);
-	/**
-	 * Retrieve item from FIFO without removing it from FIFO.
-	 * @param value Must point to a valid T
-	 * @return RETURN_OK on success, EMPTY if empty and FAILED if nullptr check failed
-	 */
-	ReturnValue_t peek(T * value);
-	/**
-	 * Remove item from FIFO.
-	 * @return RETURN_OK on success, EMPTY if empty
-	 */
-	ReturnValue_t pop();
+    /**
+     * Insert value into FIFO
+     * @param value
+     * @return RETURN_OK on success, FULL if full
+     */
+    ReturnValue_t insert(T value);
+    /**
+     * Retrieve item from FIFO. This removes the item from the FIFO.
+     * @param value Must point to a valid T
+     * @return RETURN_OK on success, EMPTY if empty and FAILED if nullptr check failed
+     */
+    ReturnValue_t retrieve(T *value);
+    /**
+     * Retrieve item from FIFO without removing it from FIFO.
+     * @param value Must point to a valid T
+     * @return RETURN_OK on success, EMPTY if empty and FAILED if nullptr check failed
+     */
+    ReturnValue_t peek(T * value);
+    /**
+     * Remove item from FIFO.
+     * @return RETURN_OK on success, EMPTY if empty
+     */
+    ReturnValue_t pop();
 
-	/***
-	 * Check if FIFO is empty
-	 * @return True if empty, False if not
-	 */
-	bool empty();
-	/***
-	 * Check if FIFO is Full
-	 * @return True if full, False if not
-	 */
-	bool full();
-	/***
-	 *  Current used size (elements) used
-	 * @return size_t in elements
-	 */
-	size_t size();
-	/***
-	 * Get maximal capacity of fifo
-	 * @return size_t with max capacity of this fifo
-	 */
-	size_t getMaxCapacity() const;
+    /***
+     * Check if FIFO is empty
+     * @return True if empty, False if not
+     */
+    bool empty();
+    /***
+     * Check if FIFO is Full
+     * @return True if full, False if not
+     */
+    bool full();
+    /***
+     *  Current used size (elements) used
+     * @return size_t in elements
+     */
+    size_t size();
+    /***
+     * Get maximal capacity of fifo
+     * @return size_t with max capacity of this fifo
+     */
+    size_t getMaxCapacity() const;
 
 protected:
-	void setContainer(T* data);
-	size_t maxCapacity = 0;
+    void setContainer(T* data);
+    size_t maxCapacity = 0;
 
-	T* values;
+    T* values;
 
-	size_t readIndex = 0;
-	size_t writeIndex = 0;
-	size_t currentSize = 0;
+    size_t readIndex = 0;
+    size_t writeIndex = 0;
+    size_t currentSize = 0;
 
-	size_t next(size_t current);
+    size_t next(size_t current);
 };
 
 #include "FIFOBase.tpp"
diff --git a/container/FIFOBase.tpp b/container/FIFOBase.tpp
index 763004b6..2e6a3829 100644
--- a/container/FIFOBase.tpp
+++ b/container/FIFOBase.tpp
@@ -7,87 +7,87 @@
 
 template<typename T>
 inline FIFOBase<T>::FIFOBase(T* values, const size_t maxCapacity):
-		maxCapacity(maxCapacity), values(values){};
+        maxCapacity(maxCapacity), values(values){};
 
 template<typename T>
 inline ReturnValue_t FIFOBase<T>::insert(T value) {
-	if (full()) {
-		return FULL;
-	} else {
-		values[writeIndex] = value;
-		writeIndex = next(writeIndex);
-		++currentSize;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+    if (full()) {
+        return FULL;
+    } else {
+        values[writeIndex] = value;
+        writeIndex = next(writeIndex);
+        ++currentSize;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 };
 
 template<typename T>
 inline ReturnValue_t FIFOBase<T>::retrieve(T* value) {
-	if (empty()) {
-		return EMPTY;
-	} else {
-		if (value == nullptr){
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		*value = values[readIndex];
-		readIndex = next(readIndex);
-		--currentSize;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+    if (empty()) {
+        return EMPTY;
+    } else {
+        if (value == nullptr){
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        *value = values[readIndex];
+        readIndex = next(readIndex);
+        --currentSize;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 };
 
 template<typename T>
 inline ReturnValue_t FIFOBase<T>::peek(T* value) {
-	if(empty()) {
-		return EMPTY;
-	} else {
-		if (value == nullptr){
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		*value = values[readIndex];
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+    if(empty()) {
+        return EMPTY;
+    } else {
+        if (value == nullptr){
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        *value = values[readIndex];
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 };
 
 template<typename T>
 inline ReturnValue_t FIFOBase<T>::pop() {
-	T value;
-	return this->retrieve(&value);
+    T value;
+    return this->retrieve(&value);
 };
 
 template<typename T>
 inline bool FIFOBase<T>::empty() {
-	return (currentSize == 0);
+    return (currentSize == 0);
 };
 
 template<typename T>
 inline bool FIFOBase<T>::full() {
-	return (currentSize == maxCapacity);
+    return (currentSize == maxCapacity);
 }
 
 template<typename T>
 inline size_t FIFOBase<T>::size() {
-	return currentSize;
+    return currentSize;
 }
 
 template<typename T>
 inline size_t FIFOBase<T>::next(size_t current) {
-	++current;
-	if (current == maxCapacity) {
-		current = 0;
-	}
-	return current;
+    ++current;
+    if (current == maxCapacity) {
+        current = 0;
+    }
+    return current;
 }
 
 template<typename T>
 inline size_t FIFOBase<T>::getMaxCapacity() const {
-	return maxCapacity;
+    return maxCapacity;
 }
 
 
 template<typename T>
 inline void FIFOBase<T>::setContainer(T *data) {
-	this->values = data;
+    this->values = data;
 }
 
 #endif
diff --git a/container/FixedArrayList.h b/container/FixedArrayList.h
index e9e127cf..89b76388 100644
--- a/container/FixedArrayList.h
+++ b/container/FixedArrayList.h
@@ -8,30 +8,30 @@
  */
 template<typename T, size_t MAX_SIZE, typename count_t = uint8_t>
 class FixedArrayList: public ArrayList<T, count_t> {
-	static_assert(MAX_SIZE <= (pow(2,sizeof(count_t)*8)-1), "count_t is not large enough to hold MAX_SIZE");
+    static_assert(MAX_SIZE <= (pow(2,sizeof(count_t)*8)-1), "count_t is not large enough to hold MAX_SIZE");
 private:
-	T data[MAX_SIZE];
+    T data[MAX_SIZE];
 public:
-	FixedArrayList() :
-			ArrayList<T, count_t>(data, MAX_SIZE) {
-	}
+    FixedArrayList() :
+            ArrayList<T, count_t>(data, MAX_SIZE) {
+    }
 
-	FixedArrayList(const FixedArrayList& other) :
-			ArrayList<T, count_t>(data, MAX_SIZE) {
-		memcpy(this->data, other.data, sizeof(this->data));
-		this->entries = data;
-		this->size = other.size;
-	}
+    FixedArrayList(const FixedArrayList& other) :
+            ArrayList<T, count_t>(data, MAX_SIZE) {
+        memcpy(this->data, other.data, sizeof(this->data));
+        this->entries = data;
+        this->size = other.size;
+    }
 
-	FixedArrayList& operator=(FixedArrayList other) {
-		memcpy(this->data, other.data, sizeof(this->data));
-		this->entries = data;
-		this->size = other.size;
-		return *this;
-	}
+    FixedArrayList& operator=(FixedArrayList other) {
+        memcpy(this->data, other.data, sizeof(this->data));
+        this->entries = data;
+        this->size = other.size;
+        return *this;
+    }
 
-	virtual ~FixedArrayList() {
-	}
+    virtual ~FixedArrayList() {
+    }
 
 };
 
diff --git a/container/FixedMap.h b/container/FixedMap.h
index 7a5220fa..bd8e0f83 100644
--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@@ -18,212 +18,212 @@
  */
 template<typename key_t, typename T>
 class FixedMap: public SerializeIF {
-	static_assert (std::is_trivially_copyable<T>::value or
-	        std::is_base_of<SerializeIF, T>::value,
-			"Types used in FixedMap must either be trivial copy-able or a "
-			"derived class from SerializeIF to be serialize-able");
+    static_assert (std::is_trivially_copyable<T>::value or
+            std::is_base_of<SerializeIF, T>::value,
+            "Types used in FixedMap must either be trivial copy-able or a "
+            "derived class from SerializeIF to be serialize-able");
 public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MAP;
-	static const ReturnValue_t KEY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x02);
-	static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
+    static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MAP;
+    static const ReturnValue_t KEY_ALREADY_EXISTS = MAKE_RETURN_CODE(0x01);
+    static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x02);
+    static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x03);
 
 private:
-	static const key_t EMPTY_SLOT = -1;
-	ArrayList<std::pair<key_t, T>, uint32_t> theMap;
-	uint32_t _size;
+    static const key_t EMPTY_SLOT = -1;
+    ArrayList<std::pair<key_t, T>, uint32_t> theMap;
+    uint32_t _size;
 
-	uint32_t findIndex(key_t key) const {
-		if (_size == 0) {
-			return 1;
-		}
-		uint32_t i = 0;
-		for (i = 0; i < _size; ++i) {
-			if (theMap[i].first == key) {
-				return i;
-			}
-		}
-		return i;
-	}
+    uint32_t findIndex(key_t key) const {
+        if (_size == 0) {
+            return 1;
+        }
+        uint32_t i = 0;
+        for (i = 0; i < _size; ++i) {
+            if (theMap[i].first == key) {
+                return i;
+            }
+        }
+        return i;
+    }
 public:
-	FixedMap(uint32_t maxSize) :
-			theMap(maxSize), _size(0) {
-	}
+    FixedMap(uint32_t maxSize) :
+            theMap(maxSize), _size(0) {
+    }
 
-	class Iterator: public ArrayList<std::pair<key_t, T>, uint32_t>::Iterator {
-	public:
-		Iterator() :
-				ArrayList<std::pair<key_t, T>, uint32_t>::Iterator() {
-		}
+    class Iterator: public ArrayList<std::pair<key_t, T>, uint32_t>::Iterator {
+    public:
+        Iterator() :
+                ArrayList<std::pair<key_t, T>, uint32_t>::Iterator() {
+        }
 
-		Iterator(std::pair<key_t, T> *pair) :
-				ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(pair) {
-		}
-	};
+        Iterator(std::pair<key_t, T> *pair) :
+                ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(pair) {
+        }
+    };
 
-	friend bool operator==(const typename FixedMap::Iterator& lhs,
-			const typename FixedMap::Iterator& rhs) {
-		return (lhs.value == rhs.value);
-	}
+    friend bool operator==(const typename FixedMap::Iterator& lhs,
+            const typename FixedMap::Iterator& rhs) {
+        return (lhs.value == rhs.value);
+    }
 
-	friend bool operator!=(const typename FixedMap::Iterator& lhs,
-			const typename FixedMap::Iterator& rhs) {
-		return not (lhs.value == rhs.value);
-	}
+    friend bool operator!=(const typename FixedMap::Iterator& lhs,
+            const typename FixedMap::Iterator& rhs) {
+        return not (lhs.value == rhs.value);
+    }
 
-	Iterator begin() const {
-		return Iterator(&theMap[0]);
-	}
+    Iterator begin() const {
+        return Iterator(&theMap[0]);
+    }
 
-	Iterator end() const {
-		return Iterator(&theMap[_size]);
-	}
+    Iterator end() const {
+        return Iterator(&theMap[_size]);
+    }
 
-	uint32_t size() const {
-		return _size;
-	}
+    uint32_t size() const {
+        return _size;
+    }
 
-	ReturnValue_t insert(key_t key, T value, Iterator *storedValue = nullptr) {
-		if (exists(key) == HasReturnvaluesIF::RETURN_OK) {
-			return KEY_ALREADY_EXISTS;
-		}
-		if (_size == theMap.maxSize()) {
-			return MAP_FULL;
-		}
-		theMap[_size].first = key;
-		theMap[_size].second = value;
-		if (storedValue != nullptr) {
-			*storedValue = Iterator(&theMap[_size]);
-		}
-		++_size;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+    ReturnValue_t insert(key_t key, T value, Iterator *storedValue = nullptr) {
+        if (exists(key) == HasReturnvaluesIF::RETURN_OK) {
+            return KEY_ALREADY_EXISTS;
+        }
+        if (_size == theMap.maxSize()) {
+            return MAP_FULL;
+        }
+        theMap[_size].first = key;
+        theMap[_size].second = value;
+        if (storedValue != nullptr) {
+            *storedValue = Iterator(&theMap[_size]);
+        }
+        ++_size;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 
-	ReturnValue_t insert(std::pair<key_t, T> pair) {
-		return insert(pair.first, pair.second);
-	}
+    ReturnValue_t insert(std::pair<key_t, T> pair) {
+        return insert(pair.first, pair.second);
+    }
 
-	ReturnValue_t exists(key_t key) const {
-		ReturnValue_t result = KEY_DOES_NOT_EXIST;
-		if (findIndex(key) < _size) {
-			result = HasReturnvaluesIF::RETURN_OK;
-		}
-		return result;
-	}
+    ReturnValue_t exists(key_t key) const {
+        ReturnValue_t result = KEY_DOES_NOT_EXIST;
+        if (findIndex(key) < _size) {
+            result = HasReturnvaluesIF::RETURN_OK;
+        }
+        return result;
+    }
 
-	ReturnValue_t erase(Iterator *iter) {
-		uint32_t i;
-		if ((i = findIndex((*iter).value->first)) >= _size) {
-			return KEY_DOES_NOT_EXIST;
-		}
-		theMap[i] = theMap[_size - 1];
-		--_size;
-		--((*iter).value);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+    ReturnValue_t erase(Iterator *iter) {
+        uint32_t i;
+        if ((i = findIndex((*iter).value->first)) >= _size) {
+            return KEY_DOES_NOT_EXIST;
+        }
+        theMap[i] = theMap[_size - 1];
+        --_size;
+        --((*iter).value);
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 
-	ReturnValue_t erase(key_t key) {
-		uint32_t i;
-		if ((i = findIndex(key)) >= _size) {
-			return KEY_DOES_NOT_EXIST;
-		}
-		theMap[i] = theMap[_size - 1];
-		--_size;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+    ReturnValue_t erase(key_t key) {
+        uint32_t i;
+        if ((i = findIndex(key)) >= _size) {
+            return KEY_DOES_NOT_EXIST;
+        }
+        theMap[i] = theMap[_size - 1];
+        --_size;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 
-	T *findValue(key_t key) const {
-		return &theMap[findIndex(key)].second;
-	}
+    T *findValue(key_t key) const {
+        return &theMap[findIndex(key)].second;
+    }
 
-	Iterator find(key_t key) const {
-		ReturnValue_t result = exists(key);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return end();
-		}
-		return Iterator(&theMap[findIndex(key)]);
-	}
+    Iterator find(key_t key) const {
+        ReturnValue_t result = exists(key);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return end();
+        }
+        return Iterator(&theMap[findIndex(key)]);
+    }
 
-	ReturnValue_t find(key_t key, T **value) const {
-		ReturnValue_t result = exists(key);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		*value = &theMap[findIndex(key)].second;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+    ReturnValue_t find(key_t key, T **value) const {
+        ReturnValue_t result = exists(key);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return result;
+        }
+        *value = &theMap[findIndex(key)].second;
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 
-	bool empty() {
-	    if(_size == 0) {
-	        return true;
-	    }
-	    else {
-	        return false;
-	    }
-	}
+    bool empty() {
+        if(_size == 0) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
 
-	bool full() {
-	    if(_size >= theMap.maxSize()) {
-	        return true;
-	    }
-	    else {
-	        return false;
-	    }
-	}
+    bool full() {
+        if(_size >= theMap.maxSize()) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
 
-	void clear() {
-		_size = 0;
-	}
+    void clear() {
+        _size = 0;
+    }
 
-	uint32_t maxSize() const {
-		return theMap.maxSize();
-	}
+    uint32_t maxSize() const {
+        return theMap.maxSize();
+    }
 
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, Endianness streamEndianness) const {
-		ReturnValue_t result = SerializeAdapter::serialize(&this->_size,
-				buffer, size, maxSize, streamEndianness);
-		uint32_t i = 0;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
-			result = SerializeAdapter::serialize(&theMap[i].first, buffer,
-					size, maxSize, streamEndianness);
-			result = SerializeAdapter::serialize(&theMap[i].second, buffer, size,
-					maxSize, streamEndianness);
-			++i;
-		}
-		return result;
-	}
+    virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+            size_t maxSize, Endianness streamEndianness) const {
+        ReturnValue_t result = SerializeAdapter::serialize(&this->_size,
+                buffer, size, maxSize, streamEndianness);
+        uint32_t i = 0;
+        while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
+            result = SerializeAdapter::serialize(&theMap[i].first, buffer,
+                    size, maxSize, streamEndianness);
+            result = SerializeAdapter::serialize(&theMap[i].second, buffer, size,
+                    maxSize, streamEndianness);
+            ++i;
+        }
+        return result;
+    }
 
-	virtual size_t getSerializedSize() const {
-		uint32_t printSize = sizeof(_size);
-		uint32_t i = 0;
+    virtual size_t getSerializedSize() const {
+        uint32_t printSize = sizeof(_size);
+        uint32_t i = 0;
 
-		for (i = 0; i < _size; ++i) {
-			printSize += SerializeAdapter::getSerializedSize(
-					&theMap[i].first);
-			printSize += SerializeAdapter::getSerializedSize(&theMap[i].second);
-		}
+        for (i = 0; i < _size; ++i) {
+            printSize += SerializeAdapter::getSerializedSize(
+                    &theMap[i].first);
+            printSize += SerializeAdapter::getSerializedSize(&theMap[i].second);
+        }
 
-		return printSize;
-	}
+        return printSize;
+    }
 
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-			Endianness streamEndianness) {
-		ReturnValue_t result = SerializeAdapter::deSerialize(&this->_size,
-				buffer, size, streamEndianness);
-		if (this->_size > theMap.maxSize()) {
-			return SerializeIF::TOO_MANY_ELEMENTS;
-		}
-		uint32_t i = 0;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
-			result = SerializeAdapter::deSerialize(&theMap[i].first, buffer,
-					size, streamEndianness);
-			result = SerializeAdapter::deSerialize(&theMap[i].second, buffer, size,
-					streamEndianness);
-			++i;
-		}
-		return result;
-	}
+    virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+            Endianness streamEndianness) {
+        ReturnValue_t result = SerializeAdapter::deSerialize(&this->_size,
+                buffer, size, streamEndianness);
+        if (this->_size > theMap.maxSize()) {
+            return SerializeIF::TOO_MANY_ELEMENTS;
+        }
+        uint32_t i = 0;
+        while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->_size)) {
+            result = SerializeAdapter::deSerialize(&theMap[i].first, buffer,
+                    size, streamEndianness);
+            result = SerializeAdapter::deSerialize(&theMap[i].second, buffer, size,
+                    streamEndianness);
+            ++i;
+        }
+        return result;
+    }
 
 };
 
diff --git a/container/FixedOrderedMultimap.h b/container/FixedOrderedMultimap.h
index acf2368a..cb8abdca 100644
--- a/container/FixedOrderedMultimap.h
+++ b/container/FixedOrderedMultimap.h
@@ -34,172 +34,172 @@
 template<typename key_t, typename T, typename KEY_COMPARE = std::less<key_t>>
 class FixedOrderedMultimap {
 public:
-	static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MULTIMAP;
-	static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x01);
-	static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x02);
+    static const uint8_t INTERFACE_ID = CLASS_ID::FIXED_MULTIMAP;
+    static const ReturnValue_t MAP_FULL = MAKE_RETURN_CODE(0x01);
+    static const ReturnValue_t KEY_DOES_NOT_EXIST = MAKE_RETURN_CODE(0x02);
 
-	/***
-	 * Constructor which needs a size_t for the maximum allowed size
-	 *
-	 * Can not be resized during runtime
-	 *
-	 * Allocates memory at construction
-	 * @param maxSize size_t of Maximum allowed size
-	 */
+    /***
+     * Constructor which needs a size_t for the maximum allowed size
+     *
+     * Can not be resized during runtime
+     *
+     * Allocates memory at construction
+     * @param maxSize size_t of Maximum allowed size
+     */
     FixedOrderedMultimap(size_t maxSize):theMap(maxSize), _size(0){
     }
 
-	/***
-	 * Virtual destructor frees Memory by deleting its member
-	 */
-	virtual ~FixedOrderedMultimap() {
-	}
+    /***
+     * Virtual destructor frees Memory by deleting its member
+     */
+    virtual ~FixedOrderedMultimap() {
+    }
 
-	/***
-	 * Special iterator for FixedOrderedMultimap
-	 */
-	class Iterator: public ArrayList<std::pair<key_t, T>, size_t>::Iterator {
-	public:
-		Iterator() :
-			ArrayList<std::pair<key_t, T>, size_t>::Iterator() {
-		}
+    /***
+     * Special iterator for FixedOrderedMultimap
+     */
+    class Iterator: public ArrayList<std::pair<key_t, T>, size_t>::Iterator {
+    public:
+        Iterator() :
+            ArrayList<std::pair<key_t, T>, size_t>::Iterator() {
+        }
 
-		Iterator(std::pair<key_t, T> *pair) :
-			ArrayList<std::pair<key_t, T>, size_t>::Iterator(pair) {
-		}
-	};
+        Iterator(std::pair<key_t, T> *pair) :
+            ArrayList<std::pair<key_t, T>, size_t>::Iterator(pair) {
+        }
+    };
 
-	/***
-	 * Returns an iterator pointing to the first element
-	 * @return Iterator pointing to first element
-	 */
-	Iterator begin() const {
-		return Iterator(&theMap[0]);
-	}
+    /***
+     * Returns an iterator pointing to the first element
+     * @return Iterator pointing to first element
+     */
+    Iterator begin() const {
+        return Iterator(&theMap[0]);
+    }
 
-	/**
-	 * Returns an iterator pointing to one element past the end
-	 * @return Iterator pointing to one element past the end
-	 */
-	Iterator end() const {
-		return Iterator(&theMap[_size]);
-	}
+    /**
+     * Returns an iterator pointing to one element past the end
+     * @return Iterator pointing to one element past the end
+     */
+    Iterator end() const {
+        return Iterator(&theMap[_size]);
+    }
 
-	/***
-	 * Returns the current size of the map (not maximum size!)
-	 * @return Current size
-	 */
-	size_t size() const{
-		return _size;
-	}
+    /***
+     * Returns the current size of the map (not maximum size!)
+     * @return Current size
+     */
+    size_t size() const{
+        return _size;
+    }
 
-	/**
-	 * Clears the map, does not deallocate any memory
-	 */
-	void clear(){
-		_size = 0;
-	}
+    /**
+     * Clears the map, does not deallocate any memory
+     */
+    void clear(){
+        _size = 0;
+    }
 
-	/**
-	 * Returns the maximum size of the map
-	 * @return Maximum size of the map
-	 */
-	size_t maxSize() const{
-		return theMap.maxSize();
-	}
+    /**
+     * Returns the maximum size of the map
+     * @return Maximum size of the map
+     */
+    size_t maxSize() const{
+        return theMap.maxSize();
+    }
 
-	/***
-	 * Used to insert a key and value separately.
-	 *
-	 * @param[in] key Key of the new element
-	 * @param[in] value Value of the new element
-	 * @param[in/out] (optional) storedValue On success this points to the new value, otherwise a nullptr
-	 * @return RETURN_OK if insert was successful, MAP_FULL if no space is available
-	 */
-	ReturnValue_t insert(key_t key, T value, Iterator *storedValue = nullptr);
+    /***
+     * Used to insert a key and value separately.
+     *
+     * @param[in] key Key of the new element
+     * @param[in] value Value of the new element
+     * @param[in/out] (optional) storedValue On success this points to the new value, otherwise a nullptr
+     * @return RETURN_OK if insert was successful, MAP_FULL if no space is available
+     */
+    ReturnValue_t insert(key_t key, T value, Iterator *storedValue = nullptr);
 
-	/***
-	 * Used to insert new pair instead of single values
-	 *
-	 * @param pair Pair to be inserted
-	 * @return RETURN_OK if insert was successful, MAP_FULL if no space is available
-	 */
-	ReturnValue_t insert(std::pair<key_t, T> pair);
+    /***
+     * Used to insert new pair instead of single values
+     *
+     * @param pair Pair to be inserted
+     * @return RETURN_OK if insert was successful, MAP_FULL if no space is available
+     */
+    ReturnValue_t insert(std::pair<key_t, T> pair);
 
-	/***
-	 * Can be used to check if a certain key is in the map
-	 * @param key Key to be checked
-	 * @return RETURN_OK if the key exists KEY_DOES_NOT_EXIST otherwise
-	 */
-	ReturnValue_t exists(key_t key) const;
+    /***
+     * Can be used to check if a certain key is in the map
+     * @param key Key to be checked
+     * @return RETURN_OK if the key exists KEY_DOES_NOT_EXIST otherwise
+     */
+    ReturnValue_t exists(key_t key) const;
 
-	/***
-	 * Used to delete the element in the iterator
-	 *
-	 * The iterator will point to the element before or begin(),
-	 *  but never to one element in front of the map.
-	 *
-	 * @warning The iterator needs to be valid and dereferenceable
-	 * @param[in/out] iter Pointer to iterator to the element that needs to be ereased
-	 * @return RETURN_OK if erased, KEY_DOES_NOT_EXIST if the there is no element like this
-	 */
-	ReturnValue_t erase(Iterator *iter);
+    /***
+     * Used to delete the element in the iterator
+     *
+     * The iterator will point to the element before or begin(),
+     *  but never to one element in front of the map.
+     *
+     * @warning The iterator needs to be valid and dereferenceable
+     * @param[in/out] iter Pointer to iterator to the element that needs to be ereased
+     * @return RETURN_OK if erased, KEY_DOES_NOT_EXIST if the there is no element like this
+     */
+    ReturnValue_t erase(Iterator *iter);
 
-	/***
-	 * Used to erase by key
-	 * @param key Key to be erased
-	 * @return RETURN_OK if erased, KEY_DOES_NOT_EXIST if the there is no element like this
-	 */
-	ReturnValue_t erase(key_t key);
+    /***
+     * Used to erase by key
+     * @param key Key to be erased
+     * @return RETURN_OK if erased, KEY_DOES_NOT_EXIST if the there is no element like this
+     */
+    ReturnValue_t erase(key_t key);
 
-	/***
-	 * Find returns the first appearance of the key
-	 *
-	 * If the key does not exist, it points to end()
-	 *
-	 * @param key Key to search for
-	 * @return Iterator pointing to the first entry of key
-	 */
-	Iterator find(key_t key) const{
-		ReturnValue_t result = exists(key);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return end();
-		}
-		return Iterator(&theMap[findFirstIndex(key)]);
-	};
+    /***
+     * Find returns the first appearance of the key
+     *
+     * If the key does not exist, it points to end()
+     *
+     * @param key Key to search for
+     * @return Iterator pointing to the first entry of key
+     */
+    Iterator find(key_t key) const{
+        ReturnValue_t result = exists(key);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return end();
+        }
+        return Iterator(&theMap[findFirstIndex(key)]);
+    };
 
-	/***
-	 * Finds first entry of the given key and returns a
-	 * pointer to the value
-	 *
-	 * @param key Key to search for
-	 * @param value Found value
-	 * @return RETURN_OK if it points to the value,
-	 * KEY_DOES_NOT_EXIST if the key is not in the map
-	 */
-	ReturnValue_t find(key_t key, T **value) const;
+    /***
+     * Finds first entry of the given key and returns a
+     * pointer to the value
+     *
+     * @param key Key to search for
+     * @param value Found value
+     * @return RETURN_OK if it points to the value,
+     * KEY_DOES_NOT_EXIST if the key is not in the map
+     */
+    ReturnValue_t find(key_t key, T **value) const;
 
-	friend bool operator==(const typename FixedOrderedMultimap::Iterator& lhs,
-			const typename FixedOrderedMultimap::Iterator& rhs) {
-		return (lhs.value == rhs.value);
-	}
+    friend bool operator==(const typename FixedOrderedMultimap::Iterator& lhs,
+            const typename FixedOrderedMultimap::Iterator& rhs) {
+        return (lhs.value == rhs.value);
+    }
 
-	friend bool operator!=(const typename FixedOrderedMultimap::Iterator& lhs,
-			const typename FixedOrderedMultimap::Iterator& rhs) {
-		return not (lhs.value == rhs.value);
-	}
+    friend bool operator!=(const typename FixedOrderedMultimap::Iterator& lhs,
+            const typename FixedOrderedMultimap::Iterator& rhs) {
+        return not (lhs.value == rhs.value);
+    }
 
 private:
-	typedef KEY_COMPARE compare;
-	compare myComp;
-	ArrayList<std::pair<key_t, T>, size_t> theMap;
-	size_t _size;
+    typedef KEY_COMPARE compare;
+    compare myComp;
+    ArrayList<std::pair<key_t, T>, size_t> theMap;
+    size_t _size;
 
-	size_t findFirstIndex(key_t key, size_t startAt = 0) const;
+    size_t findFirstIndex(key_t key, size_t startAt = 0) const;
 
-	size_t findNicePlace(key_t key) const;
+    size_t findNicePlace(key_t key) const;
 
-	void removeFromPosition(size_t position);
+    void removeFromPosition(size_t position);
 };
 
 #include "FixedOrderedMultimap.tpp"
diff --git a/container/FixedOrderedMultimap.tpp b/container/FixedOrderedMultimap.tpp
index 4aa85e97..294a161f 100644
--- a/container/FixedOrderedMultimap.tpp
+++ b/container/FixedOrderedMultimap.tpp
@@ -4,105 +4,105 @@
 
 template<typename key_t, typename T, typename KEY_COMPARE>
 inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(key_t key, T value, Iterator *storedValue) {
-	if (_size == theMap.maxSize()) {
-		return MAP_FULL;
-	}
-	size_t position = findNicePlace(key);
-	memmove(static_cast<void*>(&theMap[position + 1]),static_cast<void*>(&theMap[position]),
-			(_size - position) * sizeof(std::pair<key_t,T>));
-	theMap[position].first = key;
-	theMap[position].second = value;
-	++_size;
-	if (storedValue != nullptr) {
-		*storedValue = Iterator(&theMap[position]);
-	}
-	return HasReturnvaluesIF::RETURN_OK;
+    if (_size == theMap.maxSize()) {
+        return MAP_FULL;
+    }
+    size_t position = findNicePlace(key);
+    memmove(static_cast<void*>(&theMap[position + 1]),static_cast<void*>(&theMap[position]),
+            (_size - position) * sizeof(std::pair<key_t,T>));
+    theMap[position].first = key;
+    theMap[position].second = value;
+    ++_size;
+    if (storedValue != nullptr) {
+        *storedValue = Iterator(&theMap[position]);
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
 template<typename key_t, typename T, typename KEY_COMPARE>
 inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::insert(std::pair<key_t, T> pair) {
-	return insert(pair.first, pair.second);
+    return insert(pair.first, pair.second);
 }
 
 template<typename key_t, typename T, typename KEY_COMPARE>
 inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::exists(key_t key) const {
-	ReturnValue_t result = KEY_DOES_NOT_EXIST;
-	if (findFirstIndex(key) < _size) {
-		result = HasReturnvaluesIF::RETURN_OK;
-	}
-	return result;
+    ReturnValue_t result = KEY_DOES_NOT_EXIST;
+    if (findFirstIndex(key) < _size) {
+        result = HasReturnvaluesIF::RETURN_OK;
+    }
+    return result;
 }
 
 template<typename key_t, typename T, typename KEY_COMPARE>
 inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(Iterator *iter) {
-	size_t i;
-	if ((i = findFirstIndex((*iter).value->first)) >= _size) {
-		return KEY_DOES_NOT_EXIST;
-	}
-	removeFromPosition(i);
-	if (*iter != begin()) {
-		(*iter)--;
-	} else {
-		*iter = begin();
-	}
-	return HasReturnvaluesIF::RETURN_OK;
+    size_t i;
+    if ((i = findFirstIndex((*iter).value->first)) >= _size) {
+        return KEY_DOES_NOT_EXIST;
+    }
+    removeFromPosition(i);
+    if (*iter != begin()) {
+        (*iter)--;
+    } else {
+        *iter = begin();
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 template<typename key_t, typename T, typename KEY_COMPARE>
 inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::erase(key_t key) {
-	size_t i;
-	if ((i = findFirstIndex(key)) >= _size) {
-		return KEY_DOES_NOT_EXIST;
-	}
-	do {
-		removeFromPosition(i);
-		i = findFirstIndex(key, i);
-	} while (i < _size);
-	return HasReturnvaluesIF::RETURN_OK;
+    size_t i;
+    if ((i = findFirstIndex(key)) >= _size) {
+        return KEY_DOES_NOT_EXIST;
+    }
+    do {
+        removeFromPosition(i);
+        i = findFirstIndex(key, i);
+    } while (i < _size);
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 template<typename key_t, typename T, typename KEY_COMPARE>
 inline ReturnValue_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::find(key_t key, T **value) const {
-	ReturnValue_t result = exists(key);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
-	}
-	*value = &theMap[findFirstIndex(key)].second;
-	return HasReturnvaluesIF::RETURN_OK;
+    ReturnValue_t result = exists(key);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+    }
+    *value = &theMap[findFirstIndex(key)].second;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 template<typename key_t, typename T, typename KEY_COMPARE>
 inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findFirstIndex(key_t key, size_t startAt) const {
-	if (startAt >= _size) {
-		return startAt + 1;
-	}
-	size_t i = startAt;
-	for (i = startAt; i < _size; ++i) {
-		if (theMap[i].first == key) {
-			return i;
-		}
-	}
-	return i;
+    if (startAt >= _size) {
+        return startAt + 1;
+    }
+    size_t i = startAt;
+    for (i = startAt; i < _size; ++i) {
+        if (theMap[i].first == key) {
+            return i;
+        }
+    }
+    return i;
 }
 
 template<typename key_t, typename T, typename KEY_COMPARE>
 inline size_t FixedOrderedMultimap<key_t, T, KEY_COMPARE>::findNicePlace(key_t key) const {
-	size_t i = 0;
-	for (i = 0; i < _size; ++i) {
-		if (myComp(key, theMap[i].first)) {
-			return i;
-		}
-	}
-	return i;
+    size_t i = 0;
+    for (i = 0; i < _size; ++i) {
+        if (myComp(key, theMap[i].first)) {
+            return i;
+        }
+    }
+    return i;
 }
 
 template<typename key_t, typename T, typename KEY_COMPARE>
 inline void FixedOrderedMultimap<key_t, T, KEY_COMPARE>::removeFromPosition(size_t position) {
-	if (_size <= position) {
-		return;
-	}
-	memmove(static_cast<void*>(&theMap[position]), static_cast<void*>(&theMap[position + 1]),
-			(_size - position - 1) * sizeof(std::pair<key_t,T>));
-	--_size;
+    if (_size <= position) {
+        return;
+    }
+    memmove(static_cast<void*>(&theMap[position]), static_cast<void*>(&theMap[position + 1]),
+            (_size - position - 1) * sizeof(std::pair<key_t,T>));
+    --_size;
 }
 
 
diff --git a/container/HybridIterator.h b/container/HybridIterator.h
index 8d020cb9..6e33e461 100644
--- a/container/HybridIterator.h
+++ b/container/HybridIterator.h
@@ -6,85 +6,85 @@
 
 template<typename T, typename count_t = uint8_t>
 class HybridIterator: public LinkedElement<T>::Iterator,
-		public ArrayList<T, count_t>::Iterator {
+        public ArrayList<T, count_t>::Iterator {
 public:
-	HybridIterator() {}
+    HybridIterator() {}
 
-	HybridIterator(typename LinkedElement<T>::Iterator *iter) :
-		LinkedElement<T>::Iterator(*iter), value(iter->value),
-		linked(true) {
+    HybridIterator(typename LinkedElement<T>::Iterator *iter) :
+        LinkedElement<T>::Iterator(*iter), value(iter->value),
+        linked(true) {
 
-	}
+    }
 
-	HybridIterator(LinkedElement<T> *start) :
-		LinkedElement<T>::Iterator(start), value(start->value),
-		linked(true) {
+    HybridIterator(LinkedElement<T> *start) :
+        LinkedElement<T>::Iterator(start), value(start->value),
+        linked(true) {
 
-	}
+    }
 
-	HybridIterator(typename ArrayList<T, count_t>::Iterator start,
-			typename ArrayList<T, count_t>::Iterator end) :
-			ArrayList<T, count_t>::Iterator(start), value(start.value),
-			linked(false), end(end.value) {
-		if (value == this->end) {
-			value = NULL;
-		}
-	}
+    HybridIterator(typename ArrayList<T, count_t>::Iterator start,
+            typename ArrayList<T, count_t>::Iterator end) :
+            ArrayList<T, count_t>::Iterator(start), value(start.value),
+            linked(false), end(end.value) {
+        if (value == this->end) {
+            value = NULL;
+        }
+    }
 
-	HybridIterator(T *firstElement, T *lastElement) :
-			ArrayList<T, count_t>::Iterator(firstElement), value(firstElement),
-			linked(false), end(++lastElement) {
-		if (value == end) {
-			value = NULL;
-		}
-	}
+    HybridIterator(T *firstElement, T *lastElement) :
+            ArrayList<T, count_t>::Iterator(firstElement), value(firstElement),
+            linked(false), end(++lastElement) {
+        if (value == end) {
+            value = NULL;
+        }
+    }
 
-	HybridIterator& operator++() {
-		if (linked) {
-			LinkedElement<T>::Iterator::operator++();
-			if (LinkedElement<T>::Iterator::value != nullptr) {
-				value = LinkedElement<T>::Iterator::value->value;
-			} else {
-				value = nullptr;
-			}
-		} else {
-			ArrayList<T, count_t>::Iterator::operator++();
-			value = ArrayList<T, count_t>::Iterator::value;
+    HybridIterator& operator++() {
+        if (linked) {
+            LinkedElement<T>::Iterator::operator++();
+            if (LinkedElement<T>::Iterator::value != nullptr) {
+                value = LinkedElement<T>::Iterator::value->value;
+            } else {
+                value = nullptr;
+            }
+        } else {
+            ArrayList<T, count_t>::Iterator::operator++();
+            value = ArrayList<T, count_t>::Iterator::value;
 
-			if (value == end) {
-				value = nullptr;
-			}
-		}
-		return *this;
-	}
+            if (value == end) {
+                value = nullptr;
+            }
+        }
+        return *this;
+    }
 
-	HybridIterator operator++(int) {
-		HybridIterator tmp(*this);
-		operator++();
-		return tmp;
-	}
+    HybridIterator operator++(int) {
+        HybridIterator tmp(*this);
+        operator++();
+        return tmp;
+    }
 
-	bool operator==(const HybridIterator& other) const {
-		return value == other.value;
-	}
+    bool operator==(const HybridIterator& other) const {
+        return value == other.value;
+    }
 
-	bool operator!=(const HybridIterator& other) const {
-		return !(*this == other);
-	}
+    bool operator!=(const HybridIterator& other) const {
+        return !(*this == other);
+    }
 
-	T operator*() {
-		return *value;
-	}
+    T operator*() {
+        return *value;
+    }
 
-	T *operator->() {
-		return value;
-	}
+    T *operator->() {
+        return value;
+    }
 
-	T* value = nullptr;
+    T* value = nullptr;
 
 private:
-	bool linked = false;
-	T *end = nullptr;
+    bool linked = false;
+    T *end = nullptr;
 };
 
 #endif /* FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_ */
diff --git a/container/IndexedRingMemoryArray.h b/container/IndexedRingMemoryArray.h
index 0d85b49b..df8980f7 100644
--- a/container/IndexedRingMemoryArray.h
+++ b/container/IndexedRingMemoryArray.h
@@ -10,687 +10,687 @@
 
 template<typename T>
 class Index: public SerializeIF{
-	/**
-	 * Index is the Type used for the list of indices. The template parameter is the type which describes the index, it needs to be a child of SerializeIF to be able to make it persistent
-	 */
-	static_assert(std::is_base_of<SerializeIF,T>::value,"Wrong Type for Index, Type must implement SerializeIF");
+    /**
+     * Index is the Type used for the list of indices. The template parameter is the type which describes the index, it needs to be a child of SerializeIF to be able to make it persistent
+     */
+    static_assert(std::is_base_of<SerializeIF,T>::value,"Wrong Type for Index, Type must implement SerializeIF");
 public:
-	Index():blockStartAddress(0),size(0),storedPackets(0){}
+    Index():blockStartAddress(0),size(0),storedPackets(0){}
 
-	Index(uint32_t startAddress):blockStartAddress(startAddress),size(0),storedPackets(0){
+    Index(uint32_t startAddress):blockStartAddress(startAddress),size(0),storedPackets(0){
 
-	}
+    }
 
-	void setBlockStartAddress(uint32_t newAddress){
-		this->blockStartAddress = newAddress;
-	}
+    void setBlockStartAddress(uint32_t newAddress){
+        this->blockStartAddress = newAddress;
+    }
 
-	uint32_t getBlockStartAddress() const {
-		return blockStartAddress;
-	}
+    uint32_t getBlockStartAddress() const {
+        return blockStartAddress;
+    }
 
-	const T* getIndexType() const {
-		return &indexType;
-	}
+    const T* getIndexType() const {
+        return &indexType;
+    }
 
-	T* modifyIndexType(){
-		return &indexType;
-	}
-	/**
-	 * Updates the index Type. Uses = operator
-	 * @param indexType Type to copy from
-	 */
-	void setIndexType(T* indexType) {
-		this->indexType = *indexType;
-	}
+    T* modifyIndexType(){
+        return &indexType;
+    }
+    /**
+     * Updates the index Type. Uses = operator
+     * @param indexType Type to copy from
+     */
+    void setIndexType(T* indexType) {
+        this->indexType = *indexType;
+    }
 
-	uint32_t getSize() const {
-		return size;
-	}
+    uint32_t getSize() const {
+        return size;
+    }
 
-	void setSize(uint32_t size) {
-		this->size = size;
-	}
+    void setSize(uint32_t size) {
+        this->size = size;
+    }
 
-	void addSize(uint32_t size){
-		this->size += size;
-	}
+    void addSize(uint32_t size){
+        this->size += size;
+    }
 
-	void setStoredPackets(uint32_t newStoredPackets){
-		this->storedPackets = newStoredPackets;
-	}
+    void setStoredPackets(uint32_t newStoredPackets){
+        this->storedPackets = newStoredPackets;
+    }
 
-	void addStoredPackets(uint32_t packets){
-		this->storedPackets += packets;
-	}
+    void addStoredPackets(uint32_t packets){
+        this->storedPackets += packets;
+    }
 
-	uint32_t getStoredPackets() const{
-		return this->storedPackets;
-	}
+    uint32_t getStoredPackets() const{
+        return this->storedPackets;
+    }
 
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-				size_t maxSize, Endianness streamEndianness) const {
-		ReturnValue_t result = SerializeAdapter::serialize(&blockStartAddress,buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = indexType.serialize(buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::serialize(&this->storedPackets,buffer,size,maxSize,streamEndianness);
-		return result;
-	}
+    ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+                size_t maxSize, Endianness streamEndianness) const {
+        ReturnValue_t result = SerializeAdapter::serialize(&blockStartAddress,buffer,size,maxSize,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+            return result;
+        }
+        result = indexType.serialize(buffer,size,maxSize,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+            return result;
+        }
+        result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+            return result;
+        }
+        result = SerializeAdapter::serialize(&this->storedPackets,buffer,size,maxSize,streamEndianness);
+        return result;
+    }
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-				Endianness streamEndianness){
-		ReturnValue_t result = SerializeAdapter::deSerialize(&blockStartAddress,buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = indexType.deSerialize(buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&this->size,buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		result = SerializeAdapter::deSerialize(&this->storedPackets,buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		return result;
-	}
+    ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+                Endianness streamEndianness){
+        ReturnValue_t result = SerializeAdapter::deSerialize(&blockStartAddress,buffer,size,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+            return result;
+        }
+        result = indexType.deSerialize(buffer,size,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+            return result;
+        }
+        result = SerializeAdapter::deSerialize(&this->size,buffer,size,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+            return result;
+        }
+        result = SerializeAdapter::deSerialize(&this->storedPackets,buffer,size,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+            return result;
+        }
+        return result;
+    }
 
-	size_t getSerializedSize() const {
-		uint32_t size = SerializeAdapter::getSerializedSize(&blockStartAddress);
-		size += indexType.getSerializedSize();
-		size += SerializeAdapter::getSerializedSize(&this->size);
-		size += SerializeAdapter::getSerializedSize(&this->storedPackets);
-		return size;
-	}
+    size_t getSerializedSize() const {
+        uint32_t size = SerializeAdapter::getSerializedSize(&blockStartAddress);
+        size += indexType.getSerializedSize();
+        size += SerializeAdapter::getSerializedSize(&this->size);
+        size += SerializeAdapter::getSerializedSize(&this->storedPackets);
+        return size;
+    }
 
 
-	bool operator==(const Index<T>& other){
-		return ((blockStartAddress == other.getBlockStartAddress()) && (size==other.getSize())) && (indexType == *(other.getIndexType()));
-	}
+    bool operator==(const Index<T>& other){
+        return ((blockStartAddress == other.getBlockStartAddress()) && (size==other.getSize())) && (indexType == *(other.getIndexType()));
+    }
 
 private:
-	uint32_t blockStartAddress;
-	uint32_t size;
-	uint32_t storedPackets;
-	T indexType;
+    uint32_t blockStartAddress;
+    uint32_t size;
+    uint32_t storedPackets;
+    T indexType;
 };
 
 
 
 template<typename T>
 class IndexedRingMemoryArray: public SerializeIF, public ArrayList<Index<T>, uint32_t>{
-	/**
-	 * Indexed Ring Memory Array is a class for a ring memory with indices. It assumes that the newest data comes in last
-	 * It uses the currentWriteBlock as pointer to the current writing position
-	 * The currentReadBlock must be set manually
-	 */
+    /**
+     * Indexed Ring Memory Array is a class for a ring memory with indices. It assumes that the newest data comes in last
+     * It uses the currentWriteBlock as pointer to the current writing position
+     * The currentReadBlock must be set manually
+     */
 public:
-	IndexedRingMemoryArray(uint32_t startAddress, uint32_t size, uint32_t bytesPerBlock, SerializeIF* additionalInfo,
-			bool overwriteOld) :ArrayList<Index<T>,uint32_t>(NULL,(uint32_t)10,(uint32_t)0),totalSize(size),indexAddress(startAddress),currentReadSize(0),currentReadBlockSizeCached(0),lastBlockToReadSize(0), additionalInfo(additionalInfo),overwriteOld(overwriteOld){
+    IndexedRingMemoryArray(uint32_t startAddress, uint32_t size, uint32_t bytesPerBlock, SerializeIF* additionalInfo,
+            bool overwriteOld) :ArrayList<Index<T>,uint32_t>(NULL,(uint32_t)10,(uint32_t)0),totalSize(size),indexAddress(startAddress),currentReadSize(0),currentReadBlockSizeCached(0),lastBlockToReadSize(0), additionalInfo(additionalInfo),overwriteOld(overwriteOld){
 
-		//Calculate the maximum number of indices needed for this blocksize
-		uint32_t maxNrOfIndices = floor(static_cast<double>(size)/static_cast<double>(bytesPerBlock));
+        //Calculate the maximum number of indices needed for this blocksize
+        uint32_t maxNrOfIndices = floor(static_cast<double>(size)/static_cast<double>(bytesPerBlock));
 
-		//Calculate the Size needeed for the index itself
-		uint32_t serializedSize = 0;
-		if(additionalInfo!=NULL){
-			serializedSize += additionalInfo->getSerializedSize();
-		}
-		//Size of current iterator type
-		Index<T> tempIndex;
-		serializedSize += tempIndex.getSerializedSize();
+        //Calculate the Size needeed for the index itself
+        uint32_t serializedSize = 0;
+        if(additionalInfo!=NULL){
+            serializedSize += additionalInfo->getSerializedSize();
+        }
+        //Size of current iterator type
+        Index<T> tempIndex;
+        serializedSize += tempIndex.getSerializedSize();
 
-		//Add Size of Array
-		serializedSize += sizeof(uint32_t); //size of array
-		serializedSize += (tempIndex.getSerializedSize() * maxNrOfIndices); //size of elements
-		serializedSize += sizeof(uint16_t); //size of crc
+        //Add Size of Array
+        serializedSize += sizeof(uint32_t); //size of array
+        serializedSize += (tempIndex.getSerializedSize() * maxNrOfIndices); //size of elements
+        serializedSize += sizeof(uint16_t); //size of crc
 
-		//Calculate new size after index
-		if(serializedSize > totalSize){
-			error << "IndexedRingMemory: Store is too small for index" << std::endl;
-		}
-		uint32_t useableSize = totalSize - serializedSize;
-		//Update the totalSize for calculations
-		totalSize = useableSize;
+        //Calculate new size after index
+        if(serializedSize > totalSize){
+            error << "IndexedRingMemory: Store is too small for index" << std::endl;
+        }
+        uint32_t useableSize = totalSize - serializedSize;
+        //Update the totalSize for calculations
+        totalSize = useableSize;
 
-		//True StartAddress
-		uint32_t trueStartAddress = indexAddress + serializedSize;
+        //True StartAddress
+        uint32_t trueStartAddress = indexAddress + serializedSize;
 
-		//Calculate True number of Blocks and reset size of true Number of Blocks
-		uint32_t trueNumberOfBlocks = floor(static_cast<double>(totalSize) / static_cast<double>(bytesPerBlock));
+        //Calculate True number of Blocks and reset size of true Number of Blocks
+        uint32_t trueNumberOfBlocks = floor(static_cast<double>(totalSize) / static_cast<double>(bytesPerBlock));
 
-		//allocate memory now
-		this->entries = new Index<T>[trueNumberOfBlocks];
-		this->size = trueNumberOfBlocks;
-		this->maxSize_ = trueNumberOfBlocks;
-		this->allocated = true;
+        //allocate memory now
+        this->entries = new Index<T>[trueNumberOfBlocks];
+        this->size = trueNumberOfBlocks;
+        this->maxSize_ = trueNumberOfBlocks;
+        this->allocated = true;
 
-		//Check trueNumberOfBlocks
-		if(trueNumberOfBlocks<1){
-			error << "IndexedRingMemory: Invalid Number of Blocks: " << trueNumberOfBlocks;
-		}
+        //Check trueNumberOfBlocks
+        if(trueNumberOfBlocks<1){
+            error << "IndexedRingMemory: Invalid Number of Blocks: " << trueNumberOfBlocks;
+        }
 
 
 
-		//Fill address into index
-		uint32_t address = trueStartAddress;
-		for (typename IndexedRingMemoryArray<T>::Iterator it = this->begin();it!=this->end();++it) {
-			it->setBlockStartAddress(address);
-			it->setSize(0);
-			it->setStoredPackets(0);
-			address += bytesPerBlock;
-		}
+        //Fill address into index
+        uint32_t address = trueStartAddress;
+        for (typename IndexedRingMemoryArray<T>::Iterator it = this->begin();it!=this->end();++it) {
+            it->setBlockStartAddress(address);
+            it->setSize(0);
+            it->setStoredPackets(0);
+            address += bytesPerBlock;
+        }
 
 
-		//Initialize iterators
-		currentWriteBlock = this->begin();
-		currentReadBlock = this->begin();
-		lastBlockToRead = this->begin();
+        //Initialize iterators
+        currentWriteBlock = this->begin();
+        currentReadBlock = this->begin();
+        lastBlockToRead = this->begin();
 
-		//Check last blockSize
-		uint32_t lastBlockSize = (trueStartAddress + useableSize) -  (this->back()->getBlockStartAddress());
-		if((lastBlockSize<bytesPerBlock) && (this->size > 1)){
-			//remove the last Block so the second last block has more size
-			this->size -= 1;
-			debug << "IndexedRingMemory: Last Block is smaller than bytesPerBlock, removed last block" << std::endl;
-		}
-	}
+        //Check last blockSize
+        uint32_t lastBlockSize = (trueStartAddress + useableSize) -  (this->back()->getBlockStartAddress());
+        if((lastBlockSize<bytesPerBlock) && (this->size > 1)){
+            //remove the last Block so the second last block has more size
+            this->size -= 1;
+            debug << "IndexedRingMemory: Last Block is smaller than bytesPerBlock, removed last block" << std::endl;
+        }
+    }
 
-	/**
-	 * Resets the whole index, the iterators and executes the given reset function on every index type
-	 * @param typeResetFnc static reset function which accepts a pointer to the index Type
-	 */
-	void reset(void (*typeResetFnc)(T*)){
-		currentReadBlock = this->begin();
-		currentWriteBlock = this->begin();
-		lastBlockToRead = this->begin();
-		currentReadSize = 0;
-		currentReadBlockSizeCached = 0;
-		lastBlockToReadSize = 0;
-		for(typename IndexedRingMemoryArray<T>::Iterator it = this->begin();it!=this->end();++it){
-			it->setSize(0);
-			it->setStoredPackets(0);
-			(*typeResetFnc)(it->modifyIndexType());
-		}
-	}
+    /**
+     * Resets the whole index, the iterators and executes the given reset function on every index type
+     * @param typeResetFnc static reset function which accepts a pointer to the index Type
+     */
+    void reset(void (*typeResetFnc)(T*)){
+        currentReadBlock = this->begin();
+        currentWriteBlock = this->begin();
+        lastBlockToRead = this->begin();
+        currentReadSize = 0;
+        currentReadBlockSizeCached = 0;
+        lastBlockToReadSize = 0;
+        for(typename IndexedRingMemoryArray<T>::Iterator it = this->begin();it!=this->end();++it){
+            it->setSize(0);
+            it->setStoredPackets(0);
+            (*typeResetFnc)(it->modifyIndexType());
+        }
+    }
 
-	void resetBlock(typename IndexedRingMemoryArray<T>::Iterator it,void (*typeResetFnc)(T*)){
-		it->setSize(0);
-		it->setStoredPackets(0);
-		(*typeResetFnc)(it->modifyIndexType());
-	}
+    void resetBlock(typename IndexedRingMemoryArray<T>::Iterator it,void (*typeResetFnc)(T*)){
+        it->setSize(0);
+        it->setStoredPackets(0);
+        (*typeResetFnc)(it->modifyIndexType());
+    }
 
-	/*
-	 * Reading
-	 */
+    /*
+     * Reading
+     */
 
-	void setCurrentReadBlock(typename IndexedRingMemoryArray<T>::Iterator it){
-		currentReadBlock = it;
-		currentReadBlockSizeCached = it->getSize();
-	}
+    void setCurrentReadBlock(typename IndexedRingMemoryArray<T>::Iterator it){
+        currentReadBlock = it;
+        currentReadBlockSizeCached = it->getSize();
+    }
 
-	void resetRead(){
-		currentReadBlock = this->begin();
-		currentReadSize = 0;
-		currentReadBlockSizeCached = this->begin()->getSize();
-		lastBlockToRead = currentWriteBlock;
-		lastBlockToReadSize = currentWriteBlock->getSize();
-	}
-	/**
-	 * Sets the last block to read to this iterator.
-	 * Can be used to dump until block x
-	 * @param it The iterator for the last read block
-	 */
-	void setLastBlockToRead(typename IndexedRingMemoryArray<T>::Iterator it){
-		lastBlockToRead = it;
-		lastBlockToReadSize = it->getSize();
-	}
+    void resetRead(){
+        currentReadBlock = this->begin();
+        currentReadSize = 0;
+        currentReadBlockSizeCached = this->begin()->getSize();
+        lastBlockToRead = currentWriteBlock;
+        lastBlockToReadSize = currentWriteBlock->getSize();
+    }
+    /**
+     * Sets the last block to read to this iterator.
+     * Can be used to dump until block x
+     * @param it The iterator for the last read block
+     */
+    void setLastBlockToRead(typename IndexedRingMemoryArray<T>::Iterator it){
+        lastBlockToRead = it;
+        lastBlockToReadSize = it->getSize();
+    }
 
-	/**
-	 * Set the read pointer to the first written Block, which is the first non empty block in front of the write block
-	 * Can be the currentWriteBlock as well
-	 */
-	void readOldest(){
-		resetRead();
-		currentReadBlock = getNextNonEmptyBlock();
-		currentReadBlockSizeCached = currentReadBlock->getSize();
+    /**
+     * Set the read pointer to the first written Block, which is the first non empty block in front of the write block
+     * Can be the currentWriteBlock as well
+     */
+    void readOldest(){
+        resetRead();
+        currentReadBlock = getNextNonEmptyBlock();
+        currentReadBlockSizeCached = currentReadBlock->getSize();
 
-	}
+    }
 
-	/**
-	 * Sets the current read iterator to the next Block and resets the current read size
-	 * The current size of the block will be cached to avoid race condition between write and read
-	 * If the end of the ring is reached the read pointer will be set to the begin
-	 */
-	void readNext(){
-		currentReadSize = 0;
-		if((this->size != 0) && (currentReadBlock.value ==this->back())){
-			currentReadBlock = this->begin();
-		}else{
-			currentReadBlock++;
-		}
+    /**
+     * Sets the current read iterator to the next Block and resets the current read size
+     * The current size of the block will be cached to avoid race condition between write and read
+     * If the end of the ring is reached the read pointer will be set to the begin
+     */
+    void readNext(){
+        currentReadSize = 0;
+        if((this->size != 0) && (currentReadBlock.value ==this->back())){
+            currentReadBlock = this->begin();
+        }else{
+            currentReadBlock++;
+        }
 
-		currentReadBlockSizeCached = currentReadBlock->getSize();
-	}
+        currentReadBlockSizeCached = currentReadBlock->getSize();
+    }
 
-	/**
-	 * Returns the address which is currently read from
-	 * @return Address to read from
-	 */
-	uint32_t getCurrentReadAddress() const {
-		return getAddressOfCurrentReadBlock() + currentReadSize;
-	}
-	/**
-	 * Adds readSize to the current size and checks if the read has no more data left and advances the read block
-	 * @param readSize The size that was read
-	 * @return Returns true if the read can go on
-	 */
-	bool addReadSize(uint32_t readSize) {
-		if(currentReadBlock == lastBlockToRead){
-			//The current read block is the last to read
-			if((currentReadSize+readSize)<lastBlockToReadSize){
-				//the block has more data -> return true
-				currentReadSize += readSize;
-				return true;
-			}else{
-				//Reached end of read -> return false
-				currentReadSize = lastBlockToReadSize;
-				return false;
-			}
-		}else{
-			//We are not in the last Block
-			if((currentReadSize + readSize)<currentReadBlockSizeCached){
-				//The current Block has more data
-				currentReadSize += readSize;
-				return true;
-			}else{
-				//The current block is written completely
-				readNext();
-				if(currentReadBlockSizeCached==0){
-					//Next block is empty
-					typename IndexedRingMemoryArray<T>::Iterator it(currentReadBlock);
-					//Search if any block between this and the last block is not empty
-					for(;it!=lastBlockToRead;++it){
-						if(it == this->end()){
-							//This is the end, next block is the begin
-							it = this->begin();
-							if(it == lastBlockToRead){
-								//Break if the begin is the lastBlockToRead
-								break;
-							}
-						}
-						if(it->getSize()!=0){
-							//This is a non empty block. Go on reading with this block
-							currentReadBlock = it;
-							currentReadBlockSizeCached = it->getSize();
-							return true;
-						}
-					}
-					//reached lastBlockToRead and every block was empty, check if the last block is also empty
-					if(lastBlockToReadSize!=0){
-						//go on with last Block
-						currentReadBlock = lastBlockToRead;
-						currentReadBlockSizeCached = lastBlockToReadSize;
-						return true;
-					}
-					//There is no non empty block left
-					return false;
-				}
-				//Size is larger than 0
-				return true;
-			}
-		}
-	}
-	uint32_t getRemainigSizeOfCurrentReadBlock() const{
-		if(currentReadBlock == lastBlockToRead){
-			return (lastBlockToReadSize - currentReadSize);
-		}else{
-			return (currentReadBlockSizeCached - currentReadSize);
-		}
-	}
+    /**
+     * Returns the address which is currently read from
+     * @return Address to read from
+     */
+    uint32_t getCurrentReadAddress() const {
+        return getAddressOfCurrentReadBlock() + currentReadSize;
+    }
+    /**
+     * Adds readSize to the current size and checks if the read has no more data left and advances the read block
+     * @param readSize The size that was read
+     * @return Returns true if the read can go on
+     */
+    bool addReadSize(uint32_t readSize) {
+        if(currentReadBlock == lastBlockToRead){
+            //The current read block is the last to read
+            if((currentReadSize+readSize)<lastBlockToReadSize){
+                //the block has more data -> return true
+                currentReadSize += readSize;
+                return true;
+            }else{
+                //Reached end of read -> return false
+                currentReadSize = lastBlockToReadSize;
+                return false;
+            }
+        }else{
+            //We are not in the last Block
+            if((currentReadSize + readSize)<currentReadBlockSizeCached){
+                //The current Block has more data
+                currentReadSize += readSize;
+                return true;
+            }else{
+                //The current block is written completely
+                readNext();
+                if(currentReadBlockSizeCached==0){
+                    //Next block is empty
+                    typename IndexedRingMemoryArray<T>::Iterator it(currentReadBlock);
+                    //Search if any block between this and the last block is not empty
+                    for(;it!=lastBlockToRead;++it){
+                        if(it == this->end()){
+                            //This is the end, next block is the begin
+                            it = this->begin();
+                            if(it == lastBlockToRead){
+                                //Break if the begin is the lastBlockToRead
+                                break;
+                            }
+                        }
+                        if(it->getSize()!=0){
+                            //This is a non empty block. Go on reading with this block
+                            currentReadBlock = it;
+                            currentReadBlockSizeCached = it->getSize();
+                            return true;
+                        }
+                    }
+                    //reached lastBlockToRead and every block was empty, check if the last block is also empty
+                    if(lastBlockToReadSize!=0){
+                        //go on with last Block
+                        currentReadBlock = lastBlockToRead;
+                        currentReadBlockSizeCached = lastBlockToReadSize;
+                        return true;
+                    }
+                    //There is no non empty block left
+                    return false;
+                }
+                //Size is larger than 0
+                return true;
+            }
+        }
+    }
+    uint32_t getRemainigSizeOfCurrentReadBlock() const{
+        if(currentReadBlock == lastBlockToRead){
+            return (lastBlockToReadSize - currentReadSize);
+        }else{
+            return (currentReadBlockSizeCached - currentReadSize);
+        }
+    }
 
-	uint32_t getAddressOfCurrentReadBlock() const {
-		return currentReadBlock->getBlockStartAddress();
-	}
+    uint32_t getAddressOfCurrentReadBlock() const {
+        return currentReadBlock->getBlockStartAddress();
+    }
 
-	/**
-	 * Gets the next non empty Block after the current write block,
-	 * @return Returns the iterator to the block. If there is non, the current write block is returned
-	 */
-	typename IndexedRingMemoryArray<T>::Iterator getNextNonEmptyBlock() const {
-		for(typename IndexedRingMemoryArray<T>::Iterator it = getNextWrite();it!=currentWriteBlock;++it){
-				if(it == this->end()){
-					it = this->begin();
-					if(it == currentWriteBlock){
-						break;
-					}
-				}
-				if(it->getSize()!=0){
-					return it;
-				}
-		}
-		return currentWriteBlock;
-	}
+    /**
+     * Gets the next non empty Block after the current write block,
+     * @return Returns the iterator to the block. If there is non, the current write block is returned
+     */
+    typename IndexedRingMemoryArray<T>::Iterator getNextNonEmptyBlock() const {
+        for(typename IndexedRingMemoryArray<T>::Iterator it = getNextWrite();it!=currentWriteBlock;++it){
+                if(it == this->end()){
+                    it = this->begin();
+                    if(it == currentWriteBlock){
+                        break;
+                    }
+                }
+                if(it->getSize()!=0){
+                    return it;
+                }
+        }
+        return currentWriteBlock;
+    }
 
-	/**
-	 * Returns a copy of the oldest Index type
-	 * @return Type of Index
-	 */
-	T* getOldest(){
-		return (getNextNonEmptyBlock()->modifyIndexType());
-	}
+    /**
+     * Returns a copy of the oldest Index type
+     * @return Type of Index
+     */
+    T* getOldest(){
+        return (getNextNonEmptyBlock()->modifyIndexType());
+    }
 
 
-	/*
-	 * Writing
-	 */
-	uint32_t getAddressOfCurrentWriteBlock() const{
-		return currentWriteBlock->getBlockStartAddress();
-	}
+    /*
+     * Writing
+     */
+    uint32_t getAddressOfCurrentWriteBlock() const{
+        return currentWriteBlock->getBlockStartAddress();
+    }
 
-	uint32_t getSizeOfCurrentWriteBlock() const{
-		return currentWriteBlock->getSize();
-	}
+    uint32_t getSizeOfCurrentWriteBlock() const{
+        return currentWriteBlock->getSize();
+    }
 
-	uint32_t getCurrentWriteAddress() const{
-		return getAddressOfCurrentWriteBlock() + getSizeOfCurrentWriteBlock();
-	}
+    uint32_t getCurrentWriteAddress() const{
+        return getAddressOfCurrentWriteBlock() + getSizeOfCurrentWriteBlock();
+    }
 
-	void clearCurrentWriteBlock(){
-		currentWriteBlock->setSize(0);
-		currentWriteBlock->setStoredPackets(0);
-	}
+    void clearCurrentWriteBlock(){
+        currentWriteBlock->setSize(0);
+        currentWriteBlock->setStoredPackets(0);
+    }
 
-	void addCurrentWriteBlock(uint32_t size, uint32_t storedPackets){
-		currentWriteBlock->addSize(size);
-		currentWriteBlock->addStoredPackets(storedPackets);
-	}
+    void addCurrentWriteBlock(uint32_t size, uint32_t storedPackets){
+        currentWriteBlock->addSize(size);
+        currentWriteBlock->addStoredPackets(storedPackets);
+    }
 
-	T* modifyCurrentWriteBlockIndexType(){
-		return currentWriteBlock->modifyIndexType();
-	}
-	void updatePreviousWriteSize(uint32_t size, uint32_t storedPackets){
-		typename IndexedRingMemoryArray<T>::Iterator it = getPreviousBlock(currentWriteBlock);
-		it->addSize(size);
-		it->addStoredPackets(storedPackets);
-	}
+    T* modifyCurrentWriteBlockIndexType(){
+        return currentWriteBlock->modifyIndexType();
+    }
+    void updatePreviousWriteSize(uint32_t size, uint32_t storedPackets){
+        typename IndexedRingMemoryArray<T>::Iterator it = getPreviousBlock(currentWriteBlock);
+        it->addSize(size);
+        it->addStoredPackets(storedPackets);
+    }
 
 
-	/**
-	 * Checks if the block has enough space for sizeToWrite
-	 * @param sizeToWrite The data to be written in the Block
-	 * @return Returns true if size to write is smaller the remaining size of the block
-	 */
-	bool hasCurrentWriteBlockEnoughSpace(uint32_t sizeToWrite){
-		typename IndexedRingMemoryArray<T>::Iterator next = getNextWrite();
-		uint32_t addressOfNextBlock = next->getBlockStartAddress();
-		uint32_t availableSize = ((addressOfNextBlock+totalSize) - (getAddressOfCurrentWriteBlock()+getSizeOfCurrentWriteBlock()))%totalSize;
-		return (sizeToWrite < availableSize);
-	}
+    /**
+     * Checks if the block has enough space for sizeToWrite
+     * @param sizeToWrite The data to be written in the Block
+     * @return Returns true if size to write is smaller the remaining size of the block
+     */
+    bool hasCurrentWriteBlockEnoughSpace(uint32_t sizeToWrite){
+        typename IndexedRingMemoryArray<T>::Iterator next = getNextWrite();
+        uint32_t addressOfNextBlock = next->getBlockStartAddress();
+        uint32_t availableSize = ((addressOfNextBlock+totalSize) - (getAddressOfCurrentWriteBlock()+getSizeOfCurrentWriteBlock()))%totalSize;
+        return (sizeToWrite < availableSize);
+    }
 
-	/**
-	 * Checks if the store is full if overwrite old is false
-	 * @return Returns true if it is writeable and false if not
-	 */
-	bool isNextBlockWritable(){
-		//First check if this is the end of the list
-		typename IndexedRingMemoryArray<T>::Iterator next;
-		next = getNextWrite();
-		if((next->getSize()!=0) && (!overwriteOld)){
-			return false;
-		}
-		return true;
-	}
+    /**
+     * Checks if the store is full if overwrite old is false
+     * @return Returns true if it is writeable and false if not
+     */
+    bool isNextBlockWritable(){
+        //First check if this is the end of the list
+        typename IndexedRingMemoryArray<T>::Iterator next;
+        next = getNextWrite();
+        if((next->getSize()!=0) && (!overwriteOld)){
+            return false;
+        }
+        return true;
+    }
 
-	/**
-	 * Updates current write Block Index Type
-	 * @param infoOfNewBlock
-	 */
-	void updateCurrentBlock(T* infoOfNewBlock){
-		currentWriteBlock->setIndexType(infoOfNewBlock);
-	}
+    /**
+     * Updates current write Block Index Type
+     * @param infoOfNewBlock
+     */
+    void updateCurrentBlock(T* infoOfNewBlock){
+        currentWriteBlock->setIndexType(infoOfNewBlock);
+    }
 
 
-	/**
-	 * Succeed to next block, returns FAILED if overwrite is false and the store is full
-	 * @return
-	 */
-	ReturnValue_t writeNext(){
-		//Check Next Block
-		if(!isNextBlockWritable()){
-			//The Index is full and does not overwrite old
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		//Next block can be written, update Metadata
-		currentWriteBlock = getNextWrite();
-		currentWriteBlock->setSize(0);
-		currentWriteBlock->setStoredPackets(0);
-		return HasReturnvaluesIF::RETURN_OK;
-	}
+    /**
+     * Succeed to next block, returns FAILED if overwrite is false and the store is full
+     * @return
+     */
+    ReturnValue_t writeNext(){
+        //Check Next Block
+        if(!isNextBlockWritable()){
+            //The Index is full and does not overwrite old
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        //Next block can be written, update Metadata
+        currentWriteBlock = getNextWrite();
+        currentWriteBlock->setSize(0);
+        currentWriteBlock->setStoredPackets(0);
+        return HasReturnvaluesIF::RETURN_OK;
+    }
 
-	/**
-	 * Serializes the Index and calculates the CRC.
-	 * Parameters according to HasSerializeIF
-	 * @param buffer
-	 * @param size
-	 * @param maxSize
-	 * @param streamEndianness
-	 * @return
-	 */
-	ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-				size_t maxSize, Endianness streamEndianness) const{
-		uint8_t* crcBuffer = *buffer;
-		uint32_t oldSize = *size;
-		if(additionalInfo!=NULL){
-			additionalInfo->serialize(buffer,size,maxSize,streamEndianness);
-		}
-		ReturnValue_t result = currentWriteBlock->serialize(buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-		result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
+    /**
+     * Serializes the Index and calculates the CRC.
+     * Parameters according to HasSerializeIF
+     * @param buffer
+     * @param size
+     * @param maxSize
+     * @param streamEndianness
+     * @return
+     */
+    ReturnValue_t serialize(uint8_t** buffer, size_t* size,
+                size_t maxSize, Endianness streamEndianness) const{
+        uint8_t* crcBuffer = *buffer;
+        uint32_t oldSize = *size;
+        if(additionalInfo!=NULL){
+            additionalInfo->serialize(buffer,size,maxSize,streamEndianness);
+        }
+        ReturnValue_t result = currentWriteBlock->serialize(buffer,size,maxSize,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+                    return result;
+        }
+        result = SerializeAdapter::serialize(&this->size,buffer,size,maxSize,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+                    return result;
+        }
 
-		uint32_t i = 0;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
-			result = SerializeAdapter::serialize(&this->entries[i], buffer, size,
-					maxSize, streamEndianness);
-			++i;
-		}
-		if(result != HasReturnvaluesIF::RETURN_OK){
-			return result;
-		}
-		uint16_t crc = Calculate_CRC(crcBuffer,(*size-oldSize));
-		result = SerializeAdapter::serialize(&crc,buffer,size,maxSize,streamEndianness);
-		return result;
-	}
+        uint32_t i = 0;
+        while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
+            result = SerializeAdapter::serialize(&this->entries[i], buffer, size,
+                    maxSize, streamEndianness);
+            ++i;
+        }
+        if(result != HasReturnvaluesIF::RETURN_OK){
+            return result;
+        }
+        uint16_t crc = Calculate_CRC(crcBuffer,(*size-oldSize));
+        result = SerializeAdapter::serialize(&crc,buffer,size,maxSize,streamEndianness);
+        return result;
+    }
 
 
-	/**
-	 * Get the serialized Size of the index
-	 * @return The serialized size of the index
-	 */
-	size_t getSerializedSize() const {
+    /**
+     * Get the serialized Size of the index
+     * @return The serialized size of the index
+     */
+    size_t getSerializedSize() const {
 
-		uint32_t size = 0;
-		if(additionalInfo!=NULL){
-			size += additionalInfo->getSerializedSize();
-		}
-		size += currentWriteBlock->getSerializedSize();
-		size += SerializeAdapter::getSerializedSize(&this->size);
-		size += (this->entries[0].getSerializedSize()) * this->size;
-		uint16_t crc = 0;
-		size += SerializeAdapter::getSerializedSize(&crc);
-		return size;
-	}
-	/**
-	 * DeSerialize the Indexed Ring from a buffer, deSerializes the current write iterator
-	 * CRC Has to be checked before!
-	 * @param buffer
-	 * @param size
-	 * @param streamEndianness
-	 * @return
-	 */
+        uint32_t size = 0;
+        if(additionalInfo!=NULL){
+            size += additionalInfo->getSerializedSize();
+        }
+        size += currentWriteBlock->getSerializedSize();
+        size += SerializeAdapter::getSerializedSize(&this->size);
+        size += (this->entries[0].getSerializedSize()) * this->size;
+        uint16_t crc = 0;
+        size += SerializeAdapter::getSerializedSize(&crc);
+        return size;
+    }
+    /**
+     * DeSerialize the Indexed Ring from a buffer, deSerializes the current write iterator
+     * CRC Has to be checked before!
+     * @param buffer
+     * @param size
+     * @param streamEndianness
+     * @return
+     */
 
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-				Endianness streamEndianness){
+    ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+                Endianness streamEndianness){
 
-		ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-		if(additionalInfo!=NULL){
-			result = additionalInfo->deSerialize(buffer,size,streamEndianness);
-		}
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
+        ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+        if(additionalInfo!=NULL){
+            result = additionalInfo->deSerialize(buffer,size,streamEndianness);
+        }
+        if(result != HasReturnvaluesIF::RETURN_OK){
+                    return result;
+        }
 
-		Index<T> tempIndex;
-		result = tempIndex.deSerialize(buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-		uint32_t tempSize = 0;
-		result = SerializeAdapter::deSerialize(&tempSize,buffer,size,streamEndianness);
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-		if(this->size != tempSize){
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		uint32_t i = 0;
-		while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
-			result = SerializeAdapter::deSerialize(
-					&this->entries[i], buffer, size,
-					streamEndianness);
-			++i;
-		}
-		if(result != HasReturnvaluesIF::RETURN_OK){
-					return result;
-		}
-		typename IndexedRingMemoryArray<T>::Iterator cmp(&tempIndex);
-		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
-			if(*(cmp.value) == *(it.value)){
-				currentWriteBlock = it;
-				return HasReturnvaluesIF::RETURN_OK;
-			}
-		}
-		//Reached if current write block iterator is not found
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
+        Index<T> tempIndex;
+        result = tempIndex.deSerialize(buffer,size,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+                    return result;
+        }
+        uint32_t tempSize = 0;
+        result = SerializeAdapter::deSerialize(&tempSize,buffer,size,streamEndianness);
+        if(result != HasReturnvaluesIF::RETURN_OK){
+                    return result;
+        }
+        if(this->size != tempSize){
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        uint32_t i = 0;
+        while ((result == HasReturnvaluesIF::RETURN_OK) && (i < this->size)) {
+            result = SerializeAdapter::deSerialize(
+                    &this->entries[i], buffer, size,
+                    streamEndianness);
+            ++i;
+        }
+        if(result != HasReturnvaluesIF::RETURN_OK){
+                    return result;
+        }
+        typename IndexedRingMemoryArray<T>::Iterator cmp(&tempIndex);
+        for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
+            if(*(cmp.value) == *(it.value)){
+                currentWriteBlock = it;
+                return HasReturnvaluesIF::RETURN_OK;
+            }
+        }
+        //Reached if current write block iterator is not found
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 
-	uint32_t getIndexAddress() const {
-		return indexAddress;
-	}
+    uint32_t getIndexAddress() const {
+        return indexAddress;
+    }
 
 
-	/*
-	 * Statistics
-	 */
-	uint32_t getStoredPackets() const {
-		uint32_t size = 0;
-		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
-			size += it->getStoredPackets();
-		}
-		return size;
-	}
+    /*
+     * Statistics
+     */
+    uint32_t getStoredPackets() const {
+        uint32_t size = 0;
+        for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
+            size += it->getStoredPackets();
+        }
+        return size;
+    }
 
-	uint32_t getTotalSize() const {
-		return totalSize;
-	}
+    uint32_t getTotalSize() const {
+        return totalSize;
+    }
 
-	uint32_t getCurrentSize() const{
-		uint32_t size = 0;
-		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
-			size += it->getSize();
-		}
-		return size;
-	}
+    uint32_t getCurrentSize() const{
+        uint32_t size = 0;
+        for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
+            size += it->getSize();
+        }
+        return size;
+    }
 
-	bool isEmpty() const{
-		return getCurrentSize()==0;
-	}
+    bool isEmpty() const{
+        return getCurrentSize()==0;
+    }
 
-	double getPercentageFilled() const{
-		uint32_t filledSize = 0;
-		for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
-			filledSize += it->getSize();
-		}
+    double getPercentageFilled() const{
+        uint32_t filledSize = 0;
+        for(typename IndexedRingMemoryArray<T>::Iterator it= this->begin();it!=this->end();++it){
+            filledSize += it->getSize();
+        }
 
-		return (double)filledSize/(double)this->totalSize;
-	}
+        return (double)filledSize/(double)this->totalSize;
+    }
 
-	typename IndexedRingMemoryArray<T>::Iterator getCurrentWriteBlock() const{
-		return currentWriteBlock;
-	}
-	/**
-	 * Get the next block of the currentWriteBlock.
-	 * Returns the first one if currentWriteBlock is the last one
-	 * @return Iterator pointing to the next block after currentWriteBlock
-	 */
-	typename IndexedRingMemoryArray<T>::Iterator getNextWrite() const{
-		typename IndexedRingMemoryArray<T>::Iterator next(currentWriteBlock);
-		if((this->size != 0) && (currentWriteBlock.value == this->back())){
-			next = this->begin();
-		}else{
-			++next;
-		}
-		return next;
-	}
-	/**
-	 * Get the block in front of the Iterator
-	 * Returns the last block if it is the first block
-	 * @param it iterator which you want the previous block from
-	 * @return pointing to the block before it
-	 */
-	typename IndexedRingMemoryArray<T>::Iterator getPreviousBlock(typename IndexedRingMemoryArray<T>::Iterator it) {
-		if(this->begin() == it){
-			typename IndexedRingMemoryArray<T>::Iterator next((this->back()));
-			return next;
-		}
-		typename IndexedRingMemoryArray<T>::Iterator next(it);
-		--next;
-		return next;
-	}
+    typename IndexedRingMemoryArray<T>::Iterator getCurrentWriteBlock() const{
+        return currentWriteBlock;
+    }
+    /**
+     * Get the next block of the currentWriteBlock.
+     * Returns the first one if currentWriteBlock is the last one
+     * @return Iterator pointing to the next block after currentWriteBlock
+     */
+    typename IndexedRingMemoryArray<T>::Iterator getNextWrite() const{
+        typename IndexedRingMemoryArray<T>::Iterator next(currentWriteBlock);
+        if((this->size != 0) && (currentWriteBlock.value == this->back())){
+            next = this->begin();
+        }else{
+            ++next;
+        }
+        return next;
+    }
+    /**
+     * Get the block in front of the Iterator
+     * Returns the last block if it is the first block
+     * @param it iterator which you want the previous block from
+     * @return pointing to the block before it
+     */
+    typename IndexedRingMemoryArray<T>::Iterator getPreviousBlock(typename IndexedRingMemoryArray<T>::Iterator it) {
+        if(this->begin() == it){
+            typename IndexedRingMemoryArray<T>::Iterator next((this->back()));
+            return next;
+        }
+        typename IndexedRingMemoryArray<T>::Iterator next(it);
+        --next;
+        return next;
+    }
 private:
-	//The total size used by the blocks (without index)
-	uint32_t totalSize;
+    //The total size used by the blocks (without index)
+    uint32_t totalSize;
 
-	//The address of the index
-	const uint32_t indexAddress;
+    //The address of the index
+    const uint32_t indexAddress;
 
-	//The iterators for writing and reading
-	typename IndexedRingMemoryArray<T>::Iterator currentWriteBlock;
-	typename IndexedRingMemoryArray<T>::Iterator currentReadBlock;
+    //The iterators for writing and reading
+    typename IndexedRingMemoryArray<T>::Iterator currentWriteBlock;
+    typename IndexedRingMemoryArray<T>::Iterator currentReadBlock;
 
-	//How much of the current read block is read already
-	uint32_t currentReadSize;
+    //How much of the current read block is read already
+    uint32_t currentReadSize;
 
-	//Cached Size of current read block
-	uint32_t currentReadBlockSizeCached;
+    //Cached Size of current read block
+    uint32_t currentReadBlockSizeCached;
 
-	//Last block of current write (should be write block)
-	typename IndexedRingMemoryArray<T>::Iterator lastBlockToRead;
-	//current size of last Block to read
-	uint32_t lastBlockToReadSize;
+    //Last block of current write (should be write block)
+    typename IndexedRingMemoryArray<T>::Iterator lastBlockToRead;
+    //current size of last Block to read
+    uint32_t lastBlockToReadSize;
 
-	//Additional Info to be serialized with the index
-	SerializeIF* additionalInfo;
+    //Additional Info to be serialized with the index
+    SerializeIF* additionalInfo;
 
-	//Does it overwrite old blocks?
-	const bool overwriteOld;
+    //Does it overwrite old blocks?
+    const bool overwriteOld;
 
 };
 
diff --git a/container/PlacementFactory.h b/container/PlacementFactory.h
index a0aebb7d..94b4aeef 100644
--- a/container/PlacementFactory.h
+++ b/container/PlacementFactory.h
@@ -22,50 +22,50 @@
  */
 class PlacementFactory {
 public:
-	PlacementFactory(StorageManagerIF* backend) :
-			dataBackend(backend) {
-	}
+    PlacementFactory(StorageManagerIF* backend) :
+            dataBackend(backend) {
+    }
 
-	/***
-	 * Generates an object of type T in the backend storage.
-	 *
-	 * @warning Do not use with any Type that allocates memory internally!
-	 *
-	 * @tparam T Type of Object
-	 * @param args Constructor Arguments to be passed
-	 * @return A pointer to the new object or a nullptr in case of failure
-	 */
-	template<typename T, typename ... Args>
-	T* generate(Args&&... args) {
-		store_address_t tempId;
-		uint8_t* pData = nullptr;
-		ReturnValue_t result = dataBackend->getFreeElement(&tempId, sizeof(T),
-				&pData);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return nullptr;
-		}
-		T* temp = new (pData) T(std::forward<Args>(args)...);
-		return temp;
-	}
-	/***
-	 * Function to destroy the object allocated with generate and free space in backend.
-	 * This must be called by the user.
-	 *
-	 * @param thisElement Element to be destroyed
-	 * @return RETURN_OK if the element was destroyed, different errors on failure
-	 */
-	template<typename T>
-	ReturnValue_t destroy(T* thisElement) {
-		if (thisElement == nullptr){
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-		//Need to call destructor first, in case something was allocated by the object (shouldn't do that, however).
-		thisElement->~T();
-		uint8_t* pointer = (uint8_t*) (thisElement);
-		return dataBackend->deleteData(pointer, sizeof(T));
-	}
+    /***
+     * Generates an object of type T in the backend storage.
+     *
+     * @warning Do not use with any Type that allocates memory internally!
+     *
+     * @tparam T Type of Object
+     * @param args Constructor Arguments to be passed
+     * @return A pointer to the new object or a nullptr in case of failure
+     */
+    template<typename T, typename ... Args>
+    T* generate(Args&&... args) {
+        store_address_t tempId;
+        uint8_t* pData = nullptr;
+        ReturnValue_t result = dataBackend->getFreeElement(&tempId, sizeof(T),
+                &pData);
+        if (result != HasReturnvaluesIF::RETURN_OK) {
+            return nullptr;
+        }
+        T* temp = new (pData) T(std::forward<Args>(args)...);
+        return temp;
+    }
+    /***
+     * Function to destroy the object allocated with generate and free space in backend.
+     * This must be called by the user.
+     *
+     * @param thisElement Element to be destroyed
+     * @return RETURN_OK if the element was destroyed, different errors on failure
+     */
+    template<typename T>
+    ReturnValue_t destroy(T* thisElement) {
+        if (thisElement == nullptr){
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        //Need to call destructor first, in case something was allocated by the object (shouldn't do that, however).
+        thisElement->~T();
+        uint8_t* pointer = (uint8_t*) (thisElement);
+        return dataBackend->deleteData(pointer, sizeof(T));
+    }
 private:
-	StorageManagerIF* dataBackend;
+    StorageManagerIF* dataBackend;
 };
 
 #endif /* FRAMEWORK_CONTAINER_PLACEMENTFACTORY_H_ */
diff --git a/container/RingBufferBase.h b/container/RingBufferBase.h
index 886b9fab..9277c50b 100644
--- a/container/RingBufferBase.h
+++ b/container/RingBufferBase.h
@@ -7,107 +7,107 @@
 template<uint8_t N_READ_PTRS = 1>
 class RingBufferBase {
 public:
-	RingBufferBase(size_t startAddress, const size_t size, bool overwriteOld) :
-			start(startAddress), write(startAddress), size(size),
-			overwriteOld(overwriteOld) {
-		for (uint8_t count = 0; count < N_READ_PTRS; count++) {
-			read[count] = startAddress;
-		}
-	}
+    RingBufferBase(size_t startAddress, const size_t size, bool overwriteOld) :
+            start(startAddress), write(startAddress), size(size),
+            overwriteOld(overwriteOld) {
+        for (uint8_t count = 0; count < N_READ_PTRS; count++) {
+            read[count] = startAddress;
+        }
+    }
 
-	virtual ~RingBufferBase() {}
+    virtual ~RingBufferBase() {}
 
-	bool isFull(uint8_t n = 0) {
-		return (availableWriteSpace(n) == 0);
-	}
-	bool isEmpty(uint8_t n = 0) {
-		return (getAvailableReadData(n) == 0);
-	}
+    bool isFull(uint8_t n = 0) {
+        return (availableWriteSpace(n) == 0);
+    }
+    bool isEmpty(uint8_t n = 0) {
+        return (getAvailableReadData(n) == 0);
+    }
 
-	size_t getAvailableReadData(uint8_t n = 0) const {
-		return ((write + size) - read[n]) % size;
-	}
-	size_t availableWriteSpace(uint8_t n = 0) const  {
-		//One less to avoid ambiguous full/empty problem.
-		return (((read[n] + size) - write - 1) % size);
-	}
+    size_t getAvailableReadData(uint8_t n = 0) const {
+        return ((write + size) - read[n]) % size;
+    }
+    size_t availableWriteSpace(uint8_t n = 0) const  {
+        //One less to avoid ambiguous full/empty problem.
+        return (((read[n] + size) - write - 1) % size);
+    }
 
-	bool overwritesOld() const {
-		return overwriteOld;
-	}
+    bool overwritesOld() const {
+        return overwriteOld;
+    }
 
-	size_t getMaxSize() const {
-		return size - 1;
-	}
+    size_t getMaxSize() const {
+        return size - 1;
+    }
 
-	void clear() {
-		write = start;
-		for (uint8_t count = 0; count < N_READ_PTRS; count++) {
-			read[count] = start;
-		}
-	}
+    void clear() {
+        write = start;
+        for (uint8_t count = 0; count < N_READ_PTRS; count++) {
+            read[count] = start;
+        }
+    }
 
-	size_t writeTillWrap() {
-		return (start + size) - write;
-	}
+    size_t writeTillWrap() {
+        return (start + size) - write;
+    }
 
-	size_t readTillWrap(uint8_t n = 0) {
-		return (start + size) - read[n];
-	}
+    size_t readTillWrap(uint8_t n = 0) {
+        return (start + size) - read[n];
+    }
 
-	size_t getStart() const {
-		return start;
-	}
+    size_t getStart() const {
+        return start;
+    }
 
 protected:
-	const size_t start;
-	size_t write;
-	size_t read[N_READ_PTRS];
-	const size_t size;
-	const bool overwriteOld;
+    const size_t start;
+    size_t write;
+    size_t read[N_READ_PTRS];
+    const size_t size;
+    const bool overwriteOld;
 
-	void incrementWrite(uint32_t amount) {
-		write = ((write + amount - start) % size) + start;
-	}
-	void incrementRead(uint32_t amount, uint8_t n = 0) {
-		read[n] = ((read[n] + amount - start) % size) + start;
-	}
+    void incrementWrite(uint32_t amount) {
+        write = ((write + amount - start) % size) + start;
+    }
+    void incrementRead(uint32_t amount, uint8_t n = 0) {
+        read[n] = ((read[n] + amount - start) % size) + start;
+    }
 
-	ReturnValue_t readData(uint32_t amount, uint8_t n = 0) {
-		if (getAvailableReadData(n) >= amount) {
-			incrementRead(amount, n);
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
+    ReturnValue_t readData(uint32_t amount, uint8_t n = 0) {
+        if (getAvailableReadData(n) >= amount) {
+            incrementRead(amount, n);
+            return HasReturnvaluesIF::RETURN_OK;
+        } else {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+    }
 
-	ReturnValue_t writeData(uint32_t amount) {
-		if (availableWriteSpace() >= amount or overwriteOld) {
-			incrementWrite(amount);
-			return HasReturnvaluesIF::RETURN_OK;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
+    ReturnValue_t writeData(uint32_t amount) {
+        if (availableWriteSpace() >= amount or overwriteOld) {
+            incrementWrite(amount);
+            return HasReturnvaluesIF::RETURN_OK;
+        } else {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+    }
 
-	size_t getRead(uint8_t n = 0) const {
-		return read[n];
-	}
+    size_t getRead(uint8_t n = 0) const {
+        return read[n];
+    }
 
-	void setRead(uint32_t read, uint8_t n = 0) {
-		if (read >= start && read < (start+size)) {
-			this->read[n] = read;
-		}
-	}
+    void setRead(uint32_t read, uint8_t n = 0) {
+        if (read >= start && read < (start+size)) {
+            this->read[n] = read;
+        }
+    }
 
-	uint32_t getWrite() const {
-		return write;
-	}
+    uint32_t getWrite() const {
+        return write;
+    }
 
-	void setWrite(uint32_t write) {
-		this->write = write;
-	}
+    void setWrite(uint32_t write) {
+        this->write = write;
+    }
 };
 
 #endif /* FSFW_CONTAINER_RINGBUFFERBASE_H_ */
diff --git a/container/SharedRingBuffer.cpp b/container/SharedRingBuffer.cpp
index 769ce000..1681325d 100644
--- a/container/SharedRingBuffer.cpp
+++ b/container/SharedRingBuffer.cpp
@@ -3,23 +3,23 @@
 #include "../ipc/MutexHelper.h"
 
 SharedRingBuffer::SharedRingBuffer(object_id_t objectId, const size_t size,
-		bool overwriteOld, size_t maxExcessBytes):
-		SystemObject(objectId), SimpleRingBuffer(size, overwriteOld,
-		maxExcessBytes) {
-	mutex = MutexFactory::instance()->createMutex();
+        bool overwriteOld, size_t maxExcessBytes):
+        SystemObject(objectId), SimpleRingBuffer(size, overwriteOld,
+        maxExcessBytes) {
+    mutex = MutexFactory::instance()->createMutex();
 }
 
 
 SharedRingBuffer::SharedRingBuffer(object_id_t objectId, uint8_t *buffer,
-		const size_t size, bool overwriteOld, size_t maxExcessBytes):
-		SystemObject(objectId), SimpleRingBuffer(buffer, size, overwriteOld,
-		maxExcessBytes) {
-	mutex = MutexFactory::instance()->createMutex();
+        const size_t size, bool overwriteOld, size_t maxExcessBytes):
+        SystemObject(objectId), SimpleRingBuffer(buffer, size, overwriteOld,
+        maxExcessBytes) {
+    mutex = MutexFactory::instance()->createMutex();
 }
 
 
 void SharedRingBuffer::setToUseReceiveSizeFIFO(size_t fifoDepth) {
-	this->fifoDepth = fifoDepth;
+    this->fifoDepth = fifoDepth;
 }
 
 ReturnValue_t SharedRingBuffer::lockRingBufferMutex(
@@ -38,20 +38,20 @@ MutexIF* SharedRingBuffer::getMutexHandle() const {
 }
 
 ReturnValue_t SharedRingBuffer::initialize() {
-	if(fifoDepth > 0) {
-		receiveSizesFIFO = new DynamicFIFO<size_t>(fifoDepth);
-	}
-	return SystemObject::initialize();
+    if(fifoDepth > 0) {
+        receiveSizesFIFO = new DynamicFIFO<size_t>(fifoDepth);
+    }
+    return SystemObject::initialize();
 }
 
 DynamicFIFO<size_t>* SharedRingBuffer::getReceiveSizesFIFO() {
-	if(receiveSizesFIFO == nullptr) {
-		// Configuration error.
+    if(receiveSizesFIFO == nullptr) {
+        // Configuration error.
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::warning << "SharedRingBuffer::getReceiveSizesFIFO: Ring buffer"
-				<< " was not configured to have sizes FIFO, returning nullptr!"
-				<< std::endl;
+        sif::warning << "SharedRingBuffer::getReceiveSizesFIFO: Ring buffer"
+                << " was not configured to have sizes FIFO, returning nullptr!"
+                << std::endl;
 #endif
-	}
-	return receiveSizesFIFO;
+    }
+    return receiveSizesFIFO;
 }
diff --git a/container/SharedRingBuffer.h b/container/SharedRingBuffer.h
index 64d7ee29..43ab6e8f 100644
--- a/container/SharedRingBuffer.h
+++ b/container/SharedRingBuffer.h
@@ -15,76 +15,76 @@
  * and unlock operations.
  */
 class SharedRingBuffer: public SystemObject,
-		public SimpleRingBuffer {
+        public SimpleRingBuffer {
 public:
-	/**
-	 * This constructor allocates a new internal buffer with the supplied size.
-	 * @param size
-	 * @param overwriteOld
-	 * If the ring buffer is overflowing at a write operartion, the oldest data
-	 * will be overwritten.
-	 */
-	SharedRingBuffer(object_id_t objectId, const size_t size,
-			bool overwriteOld, size_t maxExcessBytes);
+    /**
+     * This constructor allocates a new internal buffer with the supplied size.
+     * @param size
+     * @param overwriteOld
+     * If the ring buffer is overflowing at a write operartion, the oldest data
+     * will be overwritten.
+     */
+    SharedRingBuffer(object_id_t objectId, const size_t size,
+            bool overwriteOld, size_t maxExcessBytes);
 
-	/**
-	 * @brief	This function can be used to add an optional FIFO to the class
-	 * @details 
-	 * This FIFO will be allocated in the initialize function (and will
-	 * have a fixed maximum size after that). It can be used to store
-	 * values like packet sizes, for example for a shared ring buffer
-	 * used by producer/consumer tasks.
-	 */
-	void setToUseReceiveSizeFIFO(size_t fifoDepth);
+    /**
+     * @brief    This function can be used to add an optional FIFO to the class
+     * @details 
+     * This FIFO will be allocated in the initialize function (and will
+     * have a fixed maximum size after that). It can be used to store
+     * values like packet sizes, for example for a shared ring buffer
+     * used by producer/consumer tasks.
+     */
+    void setToUseReceiveSizeFIFO(size_t fifoDepth);
 
-	/**
-	 * This constructor takes an external buffer with the specified size.
-	 * @param buffer
-	 * @param size
-	 * @param overwriteOld
-	 * If the ring buffer is overflowing at a write operartion, the oldest data
-	 * will be overwritten.
-	 */
-	SharedRingBuffer(object_id_t objectId, uint8_t* buffer, const size_t size,
-			bool overwriteOld, size_t maxExcessBytes);
+    /**
+     * This constructor takes an external buffer with the specified size.
+     * @param buffer
+     * @param size
+     * @param overwriteOld
+     * If the ring buffer is overflowing at a write operartion, the oldest data
+     * will be overwritten.
+     */
+    SharedRingBuffer(object_id_t objectId, uint8_t* buffer, const size_t size,
+            bool overwriteOld, size_t maxExcessBytes);
 
-	/**
-	 * Unless a read-only constant value is read, all operations on the
-	 * shared ring buffer should be protected by calling this function.
-	 * @param timeoutType
-	 * @param timeout
-	 * @return
-	 */
-	virtual ReturnValue_t lockRingBufferMutex(MutexIF::TimeoutType timeoutType,
-	        dur_millis_t timeout);
-	/**
-	 * Any locked mutex also has to be unlocked, otherwise, access to the
-	 * shared ring buffer will be blocked.
-	 * @return
-	 */
-	virtual ReturnValue_t unlockRingBufferMutex();
+    /**
+     * Unless a read-only constant value is read, all operations on the
+     * shared ring buffer should be protected by calling this function.
+     * @param timeoutType
+     * @param timeout
+     * @return
+     */
+    virtual ReturnValue_t lockRingBufferMutex(MutexIF::TimeoutType timeoutType,
+            dur_millis_t timeout);
+    /**
+     * Any locked mutex also has to be unlocked, otherwise, access to the
+     * shared ring buffer will be blocked.
+     * @return
+     */
+    virtual ReturnValue_t unlockRingBufferMutex();
 
-	/**
-	 * The mutex handle can be accessed directly, for example to perform
-	 * the lock with the #MutexHelper for a RAII compliant lock operation.
-	 * @return
-	 */
-	MutexIF* getMutexHandle() const;
+    /**
+     * The mutex handle can be accessed directly, for example to perform
+     * the lock with the #MutexHelper for a RAII compliant lock operation.
+     * @return
+     */
+    MutexIF* getMutexHandle() const;
 
-	ReturnValue_t initialize() override;
+    ReturnValue_t initialize() override;
 
-	/**
-	 * If the shared ring buffer was configured to have a sizes FIFO, a handle
-	 * to that FIFO can be retrieved with this function.
-	 * Do not forget to protect access with a lock if required!
-	 * @return
-	 */
-	DynamicFIFO<size_t>* getReceiveSizesFIFO();
+    /**
+     * If the shared ring buffer was configured to have a sizes FIFO, a handle
+     * to that FIFO can be retrieved with this function.
+     * Do not forget to protect access with a lock if required!
+     * @return
+     */
+    DynamicFIFO<size_t>* getReceiveSizesFIFO();
 private:
-	MutexIF* mutex = nullptr;
+    MutexIF* mutex = nullptr;
 
-	size_t fifoDepth = 0;
-	DynamicFIFO<size_t>* receiveSizesFIFO = nullptr;
+    size_t fifoDepth = 0;
+    DynamicFIFO<size_t>* receiveSizesFIFO = nullptr;
 };
 
 
diff --git a/container/SimpleRingBuffer.cpp b/container/SimpleRingBuffer.cpp
index 88c9290e..8544acbf 100644
--- a/container/SimpleRingBuffer.cpp
+++ b/container/SimpleRingBuffer.cpp
@@ -2,31 +2,31 @@
 #include <cstring>
 
 SimpleRingBuffer::SimpleRingBuffer(const size_t size, bool overwriteOld,
-		size_t maxExcessBytes) :
-		RingBufferBase<>(0, size, overwriteOld),
-		maxExcessBytes(maxExcessBytes) {
-	if(maxExcessBytes > size) {
-		this->maxExcessBytes = size;
-	}
-	else {
-		this->maxExcessBytes = maxExcessBytes;
-	}
-	buffer = new uint8_t[size + maxExcessBytes];
+        size_t maxExcessBytes) :
+        RingBufferBase<>(0, size, overwriteOld),
+        maxExcessBytes(maxExcessBytes) {
+    if(maxExcessBytes > size) {
+        this->maxExcessBytes = size;
+    }
+    else {
+        this->maxExcessBytes = maxExcessBytes;
+    }
+    buffer = new uint8_t[size + maxExcessBytes];
 }
 
 SimpleRingBuffer::SimpleRingBuffer(uint8_t *buffer, const size_t size,
-		bool overwriteOld, size_t maxExcessBytes):
+        bool overwriteOld, size_t maxExcessBytes):
         RingBufferBase<>(0, size, overwriteOld), buffer(buffer) {
-	if(maxExcessBytes > size) {
-		this->maxExcessBytes = size;
-	}
-	else {
-		this->maxExcessBytes = maxExcessBytes;
-	}
+    if(maxExcessBytes > size) {
+        this->maxExcessBytes = size;
+    }
+    else {
+        this->maxExcessBytes = maxExcessBytes;
+    }
 }
 
 SimpleRingBuffer::~SimpleRingBuffer() {
-	delete[] buffer;
+    delete[] buffer;
 }
 
 ReturnValue_t SimpleRingBuffer::getFreeElement(uint8_t **writePointer,
@@ -48,58 +48,58 @@ ReturnValue_t SimpleRingBuffer::getFreeElement(uint8_t **writePointer,
 }
 
 void SimpleRingBuffer::confirmBytesWritten(size_t amount) {
-	if(getExcessBytes() > 0) {
-		moveExcessBytesToStart();
-	}
-	incrementWrite(amount);
+    if(getExcessBytes() > 0) {
+        moveExcessBytesToStart();
+    }
+    incrementWrite(amount);
 
 }
 
 ReturnValue_t SimpleRingBuffer::writeData(const uint8_t* data,
-		size_t amount) {
-	if (availableWriteSpace() >= amount or overwriteOld) {
-		size_t amountTillWrap = writeTillWrap();
-		if (amountTillWrap >= amount) {
-			// remaining size in buffer is sufficient to fit full amount.
-			memcpy(&buffer[write], data, amount);
-		}
-		else {
-			memcpy(&buffer[write], data, amountTillWrap);
-			memcpy(buffer, data + amountTillWrap, amount - amountTillWrap);
-		}
-		incrementWrite(amount);
-		return HasReturnvaluesIF::RETURN_OK;
-	} else {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
+        size_t amount) {
+    if (availableWriteSpace() >= amount or overwriteOld) {
+        size_t amountTillWrap = writeTillWrap();
+        if (amountTillWrap >= amount) {
+            // remaining size in buffer is sufficient to fit full amount.
+            memcpy(&buffer[write], data, amount);
+        }
+        else {
+            memcpy(&buffer[write], data, amountTillWrap);
+            memcpy(buffer, data + amountTillWrap, amount - amountTillWrap);
+        }
+        incrementWrite(amount);
+        return HasReturnvaluesIF::RETURN_OK;
+    } else {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 }
 
 ReturnValue_t SimpleRingBuffer::readData(uint8_t* data, size_t amount,
-		bool incrementReadPtr, bool readRemaining, size_t* trueAmount) {
-	size_t availableData = getAvailableReadData(READ_PTR);
-	size_t amountTillWrap = readTillWrap(READ_PTR);
-	if (availableData < amount) {
-		if (readRemaining) {
-			// more data available than amount specified.
-			amount = availableData;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	if (trueAmount != nullptr) {
-		*trueAmount = amount;
-	}
-	if (amountTillWrap >= amount) {
-		memcpy(data, &buffer[read[READ_PTR]], amount);
-	} else {
-		memcpy(data, &buffer[read[READ_PTR]], amountTillWrap);
-		memcpy(data + amountTillWrap, buffer, amount - amountTillWrap);
-	}
+        bool incrementReadPtr, bool readRemaining, size_t* trueAmount) {
+    size_t availableData = getAvailableReadData(READ_PTR);
+    size_t amountTillWrap = readTillWrap(READ_PTR);
+    if (availableData < amount) {
+        if (readRemaining) {
+            // more data available than amount specified.
+            amount = availableData;
+        } else {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+    }
+    if (trueAmount != nullptr) {
+        *trueAmount = amount;
+    }
+    if (amountTillWrap >= amount) {
+        memcpy(data, &buffer[read[READ_PTR]], amount);
+    } else {
+        memcpy(data, &buffer[read[READ_PTR]], amountTillWrap);
+        memcpy(data + amountTillWrap, buffer, amount - amountTillWrap);
+    }
 
-	if(incrementReadPtr) {
-		deleteData(amount, readRemaining);
-	}
-	return HasReturnvaluesIF::RETURN_OK;
+    if(incrementReadPtr) {
+        deleteData(amount, readRemaining);
+    }
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 size_t SimpleRingBuffer::getExcessBytes() const {
@@ -114,18 +114,18 @@ void SimpleRingBuffer::moveExcessBytesToStart() {
 }
 
 ReturnValue_t SimpleRingBuffer::deleteData(size_t amount,
-		bool deleteRemaining, size_t* trueAmount) {
-	size_t availableData = getAvailableReadData(READ_PTR);
-	if (availableData < amount) {
-		if (deleteRemaining) {
-			amount = availableData;
-		} else {
-			return HasReturnvaluesIF::RETURN_FAILED;
-		}
-	}
-	if (trueAmount != nullptr) {
-		*trueAmount = amount;
-	}
-	incrementRead(amount, READ_PTR);
-	return HasReturnvaluesIF::RETURN_OK;
+        bool deleteRemaining, size_t* trueAmount) {
+    size_t availableData = getAvailableReadData(READ_PTR);
+    if (availableData < amount) {
+        if (deleteRemaining) {
+            amount = availableData;
+        } else {
+            return HasReturnvaluesIF::RETURN_FAILED;
+        }
+    }
+    if (trueAmount != nullptr) {
+        *trueAmount = amount;
+    }
+    incrementRead(amount, READ_PTR);
+    return HasReturnvaluesIF::RETURN_OK;
 }
diff --git a/container/SimpleRingBuffer.h b/container/SimpleRingBuffer.h
index 37ad5679..6f31c5fb 100644
--- a/container/SimpleRingBuffer.h
+++ b/container/SimpleRingBuffer.h
@@ -5,7 +5,7 @@
 #include <cstddef>
 
 /**
- * @brief 	Circular buffer implementation, useful for buffering
+ * @brief     Circular buffer implementation, useful for buffering
  *          into data streams.
  * @details
  * Note that the deleteData() has to be called to increment the read pointer.
@@ -25,104 +25,104 @@ public:
      * with getFreeElement.
      *
      */
-	SimpleRingBuffer(const size_t size, bool overwriteOld,
-	        size_t maxExcessBytes = 0);
-	/**
-	 * This constructor takes an external buffer with the specified size.
-	 * @param buffer
-	 * @param size
-	 * @param overwriteOld
-	 * If the ring buffer is overflowing at a write operartion, the oldest data
+    SimpleRingBuffer(const size_t size, bool overwriteOld,
+            size_t maxExcessBytes = 0);
+    /**
+     * This constructor takes an external buffer with the specified size.
+     * @param buffer
+     * @param size
+     * @param overwriteOld
+     * If the ring buffer is overflowing at a write operartion, the oldest data
      * will be overwritten.
-	 * @param maxExcessBytes
-	 * If the buffer can accomodate additional bytes for contigous write
-	 * operations with getFreeElement, this is the maximum allowed additional
-	 * size
-	 */
-	SimpleRingBuffer(uint8_t* buffer, const size_t size, bool overwriteOld,
-	        size_t maxExcessBytes = 0);
+     * @param maxExcessBytes
+     * If the buffer can accomodate additional bytes for contigous write
+     * operations with getFreeElement, this is the maximum allowed additional
+     * size
+     */
+    SimpleRingBuffer(uint8_t* buffer, const size_t size, bool overwriteOld,
+            size_t maxExcessBytes = 0);
 
-	virtual ~SimpleRingBuffer();
+    virtual ~SimpleRingBuffer();
 
-	/**
-	 * Write to circular buffer and increment write pointer by amount.
-	 * @param data
-	 * @param amount
-	 * @return -@c RETURN_OK if write operation was successfull
-	 * -@c RETURN_FAILED if
-	 */
-	ReturnValue_t writeData(const uint8_t* data, size_t amount);
+    /**
+     * Write to circular buffer and increment write pointer by amount.
+     * @param data
+     * @param amount
+     * @return -@c RETURN_OK if write operation was successfull
+     * -@c RETURN_FAILED if
+     */
+    ReturnValue_t writeData(const uint8_t* data, size_t amount);
 
-	/**
-	 * Returns a pointer to a free element. If the remaining buffer is
-	 * not large enough, the data will be written past the actual size
-	 * and the amount of excess bytes will be cached. This function
-	 * does not increment the write pointer!
-	 * @param writePointer Pointer to a pointer which can be used to write
-	 * contiguous blocks into the ring buffer
-	 * @param amount
-	 * @return
-	 */
-	ReturnValue_t getFreeElement(uint8_t** writePointer, size_t amount);
+    /**
+     * Returns a pointer to a free element. If the remaining buffer is
+     * not large enough, the data will be written past the actual size
+     * and the amount of excess bytes will be cached. This function
+     * does not increment the write pointer!
+     * @param writePointer Pointer to a pointer which can be used to write
+     * contiguous blocks into the ring buffer
+     * @param amount
+     * @return
+     */
+    ReturnValue_t getFreeElement(uint8_t** writePointer, size_t amount);
 
-	/**
-	 * This increments the write pointer and also copies the excess bytes
-	 * to the beginning. It should be called if the write operation
-	 * conducted after calling getFreeElement() was performed.
-	 * @return
-	 */
-	void confirmBytesWritten(size_t amount);
+    /**
+     * This increments the write pointer and also copies the excess bytes
+     * to the beginning. It should be called if the write operation
+     * conducted after calling getFreeElement() was performed.
+     * @return
+     */
+    void confirmBytesWritten(size_t amount);
 
-	virtual size_t getExcessBytes() const;
-	/**
-	 * Helper functions which moves any excess bytes to the start
-	 * of the ring buffer.
-	 * @return
-	 */
-	virtual void moveExcessBytesToStart();
+    virtual size_t getExcessBytes() const;
+    /**
+     * Helper functions which moves any excess bytes to the start
+     * of the ring buffer.
+     * @return
+     */
+    virtual void moveExcessBytesToStart();
 
-	/**
-	 * Read from circular buffer at read pointer.
-	 * @param data
-	 * @param amount
-	 * @param incrementReadPtr
-	 * If this is set to true, the read pointer will be incremented.
-	 * If readRemaining is set to true, the read pointer will be incremented
-	 * accordingly.
-	 * @param readRemaining
-	 * If this is set to true, the data will be read even if the amount
-	 * specified exceeds the read data available.
-	 * @param trueAmount [out]
-	 * If readRemaining was set to true, the true amount read will be assigned
-	 * to the passed value.
-	 * @return
-	 * - @c RETURN_OK if data was read successfully
-	 * - @c RETURN_FAILED if not enough data was available and readRemaining
-	 *      was set to false.
-	 */
-	ReturnValue_t readData(uint8_t* data, size_t amount,
-			bool incrementReadPtr = false, bool readRemaining = false,
-			size_t* trueAmount = nullptr);
+    /**
+     * Read from circular buffer at read pointer.
+     * @param data
+     * @param amount
+     * @param incrementReadPtr
+     * If this is set to true, the read pointer will be incremented.
+     * If readRemaining is set to true, the read pointer will be incremented
+     * accordingly.
+     * @param readRemaining
+     * If this is set to true, the data will be read even if the amount
+     * specified exceeds the read data available.
+     * @param trueAmount [out]
+     * If readRemaining was set to true, the true amount read will be assigned
+     * to the passed value.
+     * @return
+     * - @c RETURN_OK if data was read successfully
+     * - @c RETURN_FAILED if not enough data was available and readRemaining
+     *      was set to false.
+     */
+    ReturnValue_t readData(uint8_t* data, size_t amount,
+            bool incrementReadPtr = false, bool readRemaining = false,
+            size_t* trueAmount = nullptr);
 
-	/**
-	 * Delete data by incrementing read pointer.
-	 * @param amount
-	 * @param deleteRemaining
-	 * If the amount specified is larger than the remaing size to read and this
-	 * is set to true, the remaining amount will be deleted as well
-	 * @param trueAmount [out]
-	 * If deleteRemaining was set to true, the amount deleted will be assigned
-	 * to the passed value.
-	 * @return
-	 */
-	ReturnValue_t deleteData(size_t amount, bool deleteRemaining = false,
-	        size_t* trueAmount = nullptr);
+    /**
+     * Delete data by incrementing read pointer.
+     * @param amount
+     * @param deleteRemaining
+     * If the amount specified is larger than the remaing size to read and this
+     * is set to true, the remaining amount will be deleted as well
+     * @param trueAmount [out]
+     * If deleteRemaining was set to true, the amount deleted will be assigned
+     * to the passed value.
+     * @return
+     */
+    ReturnValue_t deleteData(size_t amount, bool deleteRemaining = false,
+            size_t* trueAmount = nullptr);
 
 private:
-	static const uint8_t READ_PTR = 0;
-	uint8_t* buffer = nullptr;
-	size_t maxExcessBytes;
-	size_t excessBytes = 0;
+    static const uint8_t READ_PTR = 0;
+    uint8_t* buffer = nullptr;
+    size_t maxExcessBytes;
+    size_t excessBytes = 0;
 };
 
 #endif /* FSFW_CONTAINER_SIMPLERINGBUFFER_H_ */
diff --git a/container/SinglyLinkedList.h b/container/SinglyLinkedList.h
index eb6ae276..02d590c5 100644
--- a/container/SinglyLinkedList.h
+++ b/container/SinglyLinkedList.h
@@ -5,71 +5,71 @@
 #include <cstdint>
 
 /**
- * @brief	Linked list data structure,
- * 			each entry has a pointer to the next entry (singly)
+ * @brief    Linked list data structure,
+ *             each entry has a pointer to the next entry (singly)
  * @ingroup container
  */
 template<typename T>
 class LinkedElement {
 public:
-	T *value;
-	class Iterator {
-	public:
-		LinkedElement<T> *value = nullptr;
-		Iterator() {}
+    T *value;
+    class Iterator {
+    public:
+        LinkedElement<T> *value = nullptr;
+        Iterator() {}
 
-		Iterator(LinkedElement<T> *element) :
-				value(element) {
-		}
+        Iterator(LinkedElement<T> *element) :
+                value(element) {
+        }
 
-		Iterator& operator++() {
-			value = value->getNext();
-			return *this;
-		}
+        Iterator& operator++() {
+            value = value->getNext();
+            return *this;
+        }
 
-		Iterator operator++(int) {
-			Iterator tmp(*this);
-			operator++();
-			return tmp;
-		}
+        Iterator operator++(int) {
+            Iterator tmp(*this);
+            operator++();
+            return tmp;
+        }
 
-		bool operator==(Iterator other) {
-			return value == other.value;
-		}
+        bool operator==(Iterator other) {
+            return value == other.value;
+        }
 
-		bool operator!=(Iterator other) {
-			return !(*this == other);
-		}
-		T *operator->() {
-			return value->value;
-		}
-	};
+        bool operator!=(Iterator other) {
+            return !(*this == other);
+        }
+        T *operator->() {
+            return value->value;
+        }
+    };
 
-	LinkedElement(T* setElement, LinkedElement<T>* setNext = nullptr):
-	       value(setElement), next(setNext) {}
+    LinkedElement(T* setElement, LinkedElement<T>* setNext = nullptr):
+           value(setElement), next(setNext) {}
 
-	virtual ~LinkedElement(){}
+    virtual ~LinkedElement(){}
 
-	virtual LinkedElement* getNext() const {
-		return next;
-	}
+    virtual LinkedElement* getNext() const {
+        return next;
+    }
 
-	virtual void setNext(LinkedElement* next) {
-		this->next = next;
-	}
+    virtual void setNext(LinkedElement* next) {
+        this->next = next;
+    }
 
-	virtual void setEnd() {
-	    this->next = nullptr;
-	}
+    virtual void setEnd() {
+        this->next = nullptr;
+    }
 
-	LinkedElement* begin() {
-		return this;
-	}
-	LinkedElement* end() {
-		return nullptr;
-	}
+    LinkedElement* begin() {
+        return this;
+    }
+    LinkedElement* end() {
+        return nullptr;
+    }
 private:
-	LinkedElement *next;
+    LinkedElement *next;
 };
 
 template<typename T>
@@ -77,52 +77,52 @@ class SinglyLinkedList {
 public:
     using ElementIterator = typename LinkedElement<T>::Iterator;
 
-	SinglyLinkedList() {}
+    SinglyLinkedList() {}
 
-	SinglyLinkedList(ElementIterator start) :
-			start(start.value) {}
+    SinglyLinkedList(ElementIterator start) :
+            start(start.value) {}
 
-	SinglyLinkedList(LinkedElement<T>* startElement) :
-			start(startElement) {}
+    SinglyLinkedList(LinkedElement<T>* startElement) :
+            start(startElement) {}
 
-	ElementIterator begin() const {
-		return ElementIterator::Iterator(start);
-	}
+    ElementIterator begin() const {
+        return ElementIterator::Iterator(start);
+    }
 
-	/** Returns iterator to nulltr */
-	ElementIterator end() const {
-		return ElementIterator::Iterator();
-	}
+    /** Returns iterator to nulltr */
+    ElementIterator end() const {
+        return ElementIterator::Iterator();
+    }
 
-	/**
-	 * Returns last element in singly linked list.
-	 * @return
-	 */
-	ElementIterator back() const {
-	    LinkedElement<T> *element = start;
-	    while (element->getNext() != nullptr) {
-	        element = element->getNext();
-	    }
-	    return ElementIterator::Iterator(element);
-	}
+    /**
+     * Returns last element in singly linked list.
+     * @return
+     */
+    ElementIterator back() const {
+        LinkedElement<T> *element = start;
+        while (element->getNext() != nullptr) {
+            element = element->getNext();
+        }
+        return ElementIterator::Iterator(element);
+    }
 
-	size_t getSize() const {
-		size_t size = 0;
-		LinkedElement<T> *element = start;
-		while (element != nullptr) {
-			size++;
-			element = element->getNext();
-		}
-		return size;
-	}
-	void setStart(LinkedElement<T>* firstElement) {
-		start = firstElement;
-	}
+    size_t getSize() const {
+        size_t size = 0;
+        LinkedElement<T> *element = start;
+        while (element != nullptr) {
+            size++;
+            element = element->getNext();
+        }
+        return size;
+    }
+    void setStart(LinkedElement<T>* firstElement) {
+        start = firstElement;
+    }
 
-	void setNext(LinkedElement<T>* currentElement,
-	        LinkedElement<T>* nextElement) {
-	    currentElement->setNext(nextElement);
-	}
+    void setNext(LinkedElement<T>* currentElement,
+            LinkedElement<T>* nextElement) {
+        currentElement->setNext(nextElement);
+    }
 
     void setLast(LinkedElement<T>* lastElement) {
         lastElement->setEnd();
@@ -148,7 +148,7 @@ public:
     }
 
 protected:
-	LinkedElement<T> *start = nullptr;
+    LinkedElement<T> *start = nullptr;
 };
 
 #endif /* SINGLYLINKEDLIST_H_ */