rename DynamicFifo to DynamicFifo and make enums public.

Author: robosam2003

dynamicFifo.h renamed to DynamicFifo.h

@@ -4,28 +4,26 @@
 #include <iostream>
 
 
-
-
 template<class T>
-class Fifo { /// essentially a circular fifo
+class DynamicFifo { /// essentially a circular fifo
 private:
     T* elem;
     int nextFree;
     int endPointer;
     unsigned int sz;
 
+
+public:
     enum Fifo_STATUS {
         Fifo_FULL,
         Fifo_EMPTY,
         Fifo_GOOD
     };
-
-public:
     /**
      * @brief Construct a new Fifo object
      * @param s
      */
-    explicit Fifo(int s);
+    explicit DynamicFifo(int s);
 
 /*    *//**
      * @brief Construct a new Fifo object from an initializer list
@@ -35,39 +33,39 @@ class Fifo { /// essentially a circular fifo
 
 
     /**
-     * @brief Copy constructor for Fifo
+     * @brief Copy constructor for DynamicFifo
      * @param a
      */
-    Fifo(const Fifo& a); // copy constructor
+    DynamicFifo(const DynamicFifo& a); // copy constructor
 
     /**
-     * @brief Copy assignment constructor for Fifo
+     * @brief Copy assignment constructor for DynamicFifo
      * @param a
-     * @return Fifo&
+     * @return DynamicFifo&
      */
-    Fifo& operator=(const Fifo& a); // copy assignment
+    DynamicFifo& operator=(const DynamicFifo& a); // copy assignment
 
     /**
-     * @brief Move constructor for Fifo
+     * @brief Move constructor for DynamicFifo
      * @param a
      */
-    Fifo(Fifo&& a) noexcept ; // move constructor
+    DynamicFifo(DynamicFifo&& a) noexcept ; // move constructor
 
     /**
-     * @brief Move assignment constructor for Fifo
+     * @brief Move assignment constructor for DynamicFifo
      * @param a
-     * @return Fifo&
+     * @return DynamicFifo&
      */
-    Fifo& operator=(Fifo&& a) noexcept; // move assignment
+    DynamicFifo& operator=(DynamicFifo&& a) noexcept; // move assignment
 
 
     /**
-     * @brief C-style cast operator for dynamicFifo. Does not resize the fifo. Usage: e.g.
-     * @example Fifo\<double\> g;\n  Fifo\<float\> f = (Fifo\<float\>) g;
+     * @brief C-style cast operator for DynamicFifo. Does not resize the fifo. Usage: e.g.
+     * @example DynamicFifo\<double\> g;\n  DynamicFifo\<float\> f = (DynamicFifo\<float\>) g;
      * @return Fifo_STATUS
      */
     template <typename D>
-        explicit operator Fifo<D>() const;
+        explicit operator DynamicFifo<D>() const;
 
     /**
      * @brief operator []
@@ -84,9 +82,9 @@ class Fifo { /// essentially a circular fifo
     T& operator[](int i) const;
 
     /**
-     * @brief Get the T at index i of the Fifo
+     * @brief Get the T at index i of the DynamicFifo
      * @param i
-     * @return The T at index i of the Fifo (not elem)
+     * @return The T at index i of the DynamicFifo (not elem)
      */
     T& atFifoIndex(int i);
 
@@ -163,7 +161,7 @@ class Fifo { /// essentially a circular fifo
     int used_space() const;
 
 
-    ~Fifo() { delete[] elem; } // destructor
+    ~DynamicFifo() { delete[] elem; } // destructor
 };
 
 #include "dynamicFifo.tpp" // implementation file

Fifo.h

@@ -13,13 +13,14 @@ class Fifo { /// essentially a circular fifo
     int nextFree;
     int endPointer;
 
-    enum class Fifo_STATUS {
+
+
+public:
+    enum Fifo_STATUS {
         Fifo_FULL,
         Fifo_EMPTY,
         Fifo_GOOD
     };
-
-public:
     /**
      * @brief Construct a new Fifo object
      * @param s

Fifo.tpp

@@ -96,7 +96,7 @@ T& Fifo<T, sz>::atFifoIndex(int i) const{
 }
 
 template<class T, unsigned int sz>
-Fifo_STATUS Fifo<T, sz>::push(const T& item) { // returns the status of the fifo
+typename Fifo<T, sz>::Fifo_STATUS Fifo<T, sz>::push(const T& item) { // returns the status of the fifo
     if (fifo_status()==Fifo_STATUS::Fifo_FULL) {
         // throw std::length_error("NA"); // throw does not work with arduino :(
         return Fifo_STATUS::Fifo_FULL; // status code
@@ -166,7 +166,7 @@ T Fifo<T, sz>::peekFront(int i) const {
 }
 
 template<class T, unsigned int sz>
-Fifo_STATUS Fifo<T, sz>::fifo_status() const {
+typename Fifo<T, sz>::Fifo_STATUS Fifo<T, sz>::fifo_status() const {
     if (nextFree==endPointer) {
         return Fifo_STATUS::Fifo_EMPTY; // fifo empty
     }

README.md

@@ -47,12 +47,12 @@ Fifo<Vector<double, 6>, 256> e2 = (Fifo<Vector<double, 6>, 256>) e1;
 ```
 
 ### Dynamic Fifo
-`dynamicFifo` is an identical to `Fifo` in functionality, but uses dynamic memory allocation, not a template.
+`DynamicFifo` is an identical to `Fifo` in functionality, but uses dynamic memory allocation, not a template.
 It is useful when the size of the Fifo is not known at compile time, or when writing libraries etc. (e.g. [LSM6DSO32](https://github.com/TeamSunride/Arduino-LSM6DSO32))
 
 ```cpp
-#include "dynamicFifo.h"
-// dynamicFifo is initialised with a template type and size as a parameter.
+#include "DynamicFifo.h"
+// DynamicFifo is initialised with a template type and size as a parameter.
 Fifo<float> e1 (256);
 e1.push(3.14159);
 

dynamicFifo.tpp

@@ -2,13 +2,13 @@
 // Created by robos on 30/06/2022.
 //
 
-#include "dynamicFifo.h"
+#include "DynamicFifo.h"
 #include "Vector.h"
 
 
 
 template<class T>
-Fifo<T>::Fifo(int s) {
+DynamicFifo<T>::DynamicFifo(int s) {
     elem = new T[s]; // allocates on the free store (the heap)
     sz = s;
     nextFree=0;
@@ -28,28 +28,28 @@ Fifo<T>::Fifo(std::initializer_list<T> lst) {
 */
 
 template<class T>
-T &Fifo<T>::operator[](int i) {
+T &DynamicFifo<T>::operator[](int i) {
     return elem[i%sz]; // if the index is larger than the sz, it wraps around;
 }
 
 template<class T>
-T &Fifo<T>::operator[](int i) const {
+T &DynamicFifo<T>::operator[](int i) const {
     return elem[i%sz]; // if the index is larger than the sz, it wraps around;
 }
 
 template<class T>
-T& Fifo<T>::atFifoIndex(int i) {
+T& DynamicFifo<T>::atFifoIndex(int i) {
     return elem[(endPointer+i) % sz];
 }
 
 template<class T>
-T& Fifo<T>::atFifoIndex(int i) const{
+T& DynamicFifo<T>::atFifoIndex(int i) const{
     return elem[(endPointer+i) % sz];
 }
 
 
 template<class T>
-Fifo_STATUS Fifo<T>::push(const T& item) {
+typename DynamicFifo<T>::Fifo_STATUS DynamicFifo<T>::push(const T& item) {
     if (fifo_status()==Fifo_STATUS::Fifo_FULL) {
         // throw std::length_error("NA"); // throw does not work with arduino :(
         return Fifo_STATUS::Fifo_FULL; // status code
@@ -67,7 +67,7 @@ Fifo_STATUS Fifo<T>::push(const T& item) {
 }
 
 template<class T>
-T Fifo<T>::pop() { /// Note: You should check the status of the fifo before calling this function
+T DynamicFifo<T>::pop() { /// Note: You should check the status of the fifo before calling this function
     if (fifo_status()==Fifo_STATUS::Fifo_EMPTY) {
         return {0}; // return 0
     }
@@ -83,7 +83,7 @@ T Fifo<T>::pop() { /// Note: You should check the status of the fifo before call
 
 
 template<class T>
-T Fifo<T>::peekBack() const { // GitHub copilot for the win
+T DynamicFifo<T>::peekBack() const { // GitHub copilot for the win
     if (fifo_status()==Fifo_STATUS::Fifo_EMPTY) {
         return {0}; // return 0
     }
@@ -92,7 +92,7 @@ T Fifo<T>::peekBack() const { // GitHub copilot for the win
 }
 
 template<class T>
-T Fifo<T>::peekBack(int i) const {
+T DynamicFifo<T>::peekBack(int i) const {
     if (fifo_status()==Fifo_STATUS::Fifo_EMPTY) {
         return {0}; // return 0
     }
@@ -103,7 +103,7 @@ T Fifo<T>::peekBack(int i) const {
 
 
 template<class T>
-T Fifo<T>::peekFront() const {
+T DynamicFifo<T>::peekFront() const {
     if (fifo_status()==Fifo_STATUS::Fifo_EMPTY) {
         return {0}; // return 0
     }
@@ -112,7 +112,7 @@ T Fifo<T>::peekFront() const {
 }
 
 template<class T>
-T Fifo<T>::peekFront(int i) const {
+T DynamicFifo<T>::peekFront(int i) const {
     if (fifo_status()==Fifo_STATUS::Fifo_EMPTY) {
         return {0}; // return 0
     }
@@ -121,7 +121,7 @@ T Fifo<T>::peekFront(int i) const {
 }
 
 template<class T>
-Fifo_STATUS Fifo<T>::fifo_status() const {
+typename DynamicFifo<T>::Fifo_STATUS DynamicFifo<T>::fifo_status() const {
     if (nextFree==endPointer) {
         return Fifo_STATUS::Fifo_EMPTY; // fifo empty
     }
@@ -133,12 +133,12 @@ Fifo_STATUS Fifo<T>::fifo_status() const {
 }
 
 template<class T>
-int Fifo<T>::size() const{
+int DynamicFifo<T>::size() const{
     return sz;
 }
 
 template<class T>
-int Fifo<T>::free_space() const{
+int DynamicFifo<T>::free_space() const{
     if (fifo_status()==Fifo_STATUS::Fifo_FULL){
         return 0;
     }
@@ -152,8 +152,8 @@ int Fifo<T>::free_space() const{
 
 template<class T>
 template<typename D>
-Fifo<T>::operator Fifo<D>() const {
-    Fifo<D> r(sz);
+DynamicFifo<T>::operator DynamicFifo<D>() const {
+    DynamicFifo<D> r(sz);
     for (int i=0;i<used_space();i++) {
         D item = static_cast<D>(elem[i]);
         r.push(item);
@@ -163,7 +163,7 @@ Fifo<T>::operator Fifo<D>() const {
 
 // copy constructor
 template<class T>
-Fifo<T>::Fifo(const Fifo &a) {
+DynamicFifo<T>::DynamicFifo(const DynamicFifo &a) {
     elem = new T[a.sz];
     sz = a.sz;
     nextFree = a.nextFree;
@@ -175,7 +175,7 @@ Fifo<T>::Fifo(const Fifo &a) {
 
 // copy assignment operator
 template<class T>
-Fifo<T> &Fifo<T>::operator=(const Fifo &a) {
+DynamicFifo<T> &DynamicFifo<T>::operator=(const DynamicFifo &a) {
     T* p = new T[a.sz];
     for (int i=0;i<a.sz;i++) {
         p[i] = a.elem[i];
@@ -190,7 +190,7 @@ Fifo<T> &Fifo<T>::operator=(const Fifo &a) {
 
 // move constructor
 template<class T>
-Fifo<T>::Fifo(Fifo &&a) noexcept {
+DynamicFifo<T>::DynamicFifo(DynamicFifo &&a) noexcept {
     elem = a.elem;
     sz = a.sz;
     nextFree = a.nextFree;
@@ -200,7 +200,7 @@ Fifo<T>::Fifo(Fifo &&a) noexcept {
 
 // move assignment operator
 template<class T>
-Fifo<T> &Fifo<T>::operator=(Fifo &&a) noexcept {
+DynamicFifo<T> &DynamicFifo<T>::operator=(DynamicFifo &&a) noexcept {
     if (this != &a) {
         delete[] elem;
         elem = a.elem;
@@ -213,6 +213,6 @@ Fifo<T> &Fifo<T>::operator=(Fifo &&a) noexcept {
 }
 
 template<class T>
-int Fifo<T>::used_space() const {
+int DynamicFifo<T>::used_space() const {
     return sz-free_space();
 }