new fifo init

container/FIFO.h

@@ -1,82 +1,26 @@
-#ifndef FIFO_H_
+#ifndef FRAMEWORK_CONTAINER_FIFO_H_
-#define FIFO_H_
+#define FRAMEWORK_CONTAINER_FIFO_H_
 
-#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/container/FIFOBase.h>
+#include <vector>
 
 /**
- * @brief Simple First-In-First-Out data structure
+ * @brief 	Simple First-In-First-Out data structure. The maximum size
+ * 			can be set in the constructor. THe public interface of
+ * 			FIFOBase exposes the user interface for the FIFO.
  * @tparam T Entry Type
  * @tparam capacity Maximum capacity
  */
-template<typename T, uint8_t capacity>
+template<typename T>
-class FIFO {
+class FIFO: public FIFOBase<T> {
-private:
-	uint8_t readIndex, writeIndex, currentSize;
-	T data[capacity];
-
-	uint8_t next(uint8_t current) {
-		++current;
-		if (current == capacity) {
-			current = 0;
-		}
-		return current;
-	}
 public:
-	FIFO() :
+	FIFO(size_t maxCapacity): FIFOBase<T>(values.data(), maxCapacity) {
-			readIndex(0), writeIndex(0), currentSize(0) {
+		values.reserve(maxCapacity);
-	}
+		values.resize(maxCapacity);
+	};
 
-	bool empty() {
+private:
-		return (currentSize == 0);
+	std::vector<T> values;
-	}
-
-	bool full() {
-		return (currentSize == capacity);
-	}
-
-	uint8_t size(){
-		return currentSize;
-	}
-
-	ReturnValue_t insert(T value) {
-		if (full()) {
-			return FULL;
-		} else {
-			data[writeIndex] = value;
-			writeIndex = next(writeIndex);
-			++currentSize;
-			return HasReturnvaluesIF::RETURN_OK;
-		}
-	}
-
-	ReturnValue_t retrieve(T *value) {
-		if (empty()) {
-			return EMPTY;
-		} else {
-			*value = data[readIndex];
-			readIndex = next(readIndex);
-			--currentSize;
-			return HasReturnvaluesIF::RETURN_OK;
-		}
-	}
-
-	ReturnValue_t peek(T * value) {
-	    if(empty()) {
-	        return EMPTY;
-	    } else {
-	       *value = data[readIndex];
-	       return HasReturnvaluesIF::RETURN_OK;
-	    }
-	}
-
-	ReturnValue_t pop() {
-		T value;
-		return this->retrieve(&value);
-	}
-
-	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);
 };
 
-#endif /* FIFO_H_ */
+#endif /* FRAMEWORK_CONTAINER_FIFO_H_ */

container/FIFOBase.h

@@ -0,0 +1,59 @@
+#ifndef FRAMEWORK_CONTAINER_FIFOBASE_H_
+#define FRAMEWORK_CONTAINER_FIFOBASE_H_
+
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <cstddef>
+
+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);
+
+
+	/** Default ctor, no input arguments required. */
+	FIFOBase(T* values, const size_t maxCapacity);
+
+	/**
+	 * Insert value into FIFO
+	 * @param value
+	 * @return
+	 */
+	ReturnValue_t insert(T value);
+	/**
+	 * Retrieve item from FIFO. This removes the item from the FIFO.
+	 * @param value
+	 * @return
+	 */
+	ReturnValue_t retrieve(T *value);
+	/**
+	 * Retrieve item from FIFO without removing it from FIFO.
+	 * @param value
+	 * @return
+	 */
+	ReturnValue_t peek(T * value);
+	/**
+	 * Remove item from FIFO.
+	 * @return
+	 */
+	ReturnValue_t pop();
+
+	bool empty();
+	bool full();
+	size_t size();
+
+private:
+	T* values;
+	size_t maxCapacity;
+
+	size_t readIndex = 0;
+	size_t writeIndex = 0;
+	size_t currentSize = 0;
+
+	size_t next(size_t current);
+};
+
+#include <framework/container/FIFOBase.tpp>
+
+#endif /* FRAMEWORK_CONTAINER_FIFOBASE_H_ */

container/FIFOBase.tpp

@@ -0,0 +1,76 @@
+#ifndef FRAMEWORK_CONTAINER_FIFOBASE_TPP_
+#define FRAMEWORK_CONTAINER_FIFOBASE_TPP_
+
+#ifndef FRAMEWORK_CONTAINER_FIFOBASE_H_
+#error Include FIFOBase.h before FIFOBase.tpp!
+#endif
+
+template<typename T>
+inline FIFOBase<T>::FIFOBase(T* values, const size_t maxCapacity):
+		values(values), maxCapacity(maxCapacity) {};
+
+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;
+	}
+};
+
+template<typename T>
+inline ReturnValue_t FIFOBase<T>::retrieve(T* value) {
+	if (empty()) {
+		return EMPTY;
+	} else {
+		*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 {
+		*value = values[readIndex];
+		return HasReturnvaluesIF::RETURN_OK;
+	}
+};
+
+template<typename T>
+inline ReturnValue_t FIFOBase<T>::pop() {
+	T value;
+	return this->retrieve(&value);
+};
+
+template<typename T>
+inline bool FIFOBase<T>::empty() {
+	return (currentSize == 0);
+};
+
+template<typename T>
+inline bool FIFOBase<T>::full() {
+	return (currentSize == maxCapacity);
+}
+
+template<typename T>
+inline size_t FIFOBase<T>::size() {
+	return currentSize;
+}
+
+template<typename T>
+inline size_t FIFOBase<T>::next(size_t current) {
+	++current;
+	if (current == maxCapacity) {
+		current = 0;
+	}
+	return current;
+}
+
+#endif

container/StaticFIFO.h

@@ -0,0 +1,23 @@
+#ifndef FRAMEWORK_CONTAINER_STATICFIFO_H_
+#define FRAMEWORK_CONTAINER_STATICFIFO_H_
+
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/container/FIFOBase.h>
+
+/**
+ * @brief 	Simple First-In-First-Out data structure with size fixed at
+ * 			compile time. The public interface of FIFOBase exposes
+ * 			the user interface for the FIFO.
+ * @tparam T Entry Type
+ * @tparam capacity Maximum capacity
+ */
+template<typename T, size_t capacity>
+class StaticFIFO: public FIFOBase<T> {
+public:
+	StaticFIFO(): FIFOBase<T>(values.data(), capacity) {};
+
+private:
+	std::array<T, capacity> values;
+};
+
+#endif /* FRAMEWORK_CONTAINERS_STATICFIFO_H_ */