New QueueFromVector class

Author: pschatzmann

examples/tests/basic/test-queue/test-queue.ino

@@ -0,0 +1,24 @@
+#include "AudioTools.h"
+
+//Queue<int> q;
+QueueFromVector<int> q{0,10};
+
+void setup(){
+    Serial.begin(115200);
+    assert(q.empty());
+
+    for (int j=0;j<10;j++){
+        q.enqueue(j);
+        assert(!q.empty());
+        assert(q.size()==j+1);
+    }
+    int number;
+    for (int j=0;j<10;j++){
+        q.dequeue(number);
+        assert(number == j);
+        assert(q.size()==10-(j+1));
+    }
+    assert(q.empty());
+}
+
+void loop(){}

src/AudioBasic/Collections.h

@@ -9,5 +9,6 @@
 #include "AudioBasic/Collections/List.h"
 #include "AudioBasic/Collections/Stack.h"
 #include "AudioBasic/Collections/Queue.h"
+#include "AudioBasic/Collections/QueueFromVector.h"
 #include "AudioBasic/Collections/BitVector.h"
 #include "AudioBasic/Collections/Slice.h"

src/AudioBasic/Collections/QueueFromVector.h

@@ -0,0 +1,87 @@
+#pragma once
+#include "AudioBasic/Collections/List.h"
+
+namespace audio_tools {
+
+/**
+ * @brief FIFO Queue which is based on a Vector
+ * @ingroup collections
+ * @author Phil Schatzmann
+ * @copyright GPLv3
+ * @tparam T 
+ */
+template <class T> 
+class QueueFromVector {
+    public:
+        QueueFromVector(T empty, size_t size) { 
+            null_value = empty;
+            resize(size); 
+        };
+
+        bool enqueue(T& data){
+            if (is_full()) 
+                return false;
+            vector[_size++] = data;
+            return true;
+        }
+
+        bool peek(T& data){
+            if (_size <= 0 ) {
+                data = null_value;
+                return false;
+            }
+            data = vector[0];
+            return true;
+        }
+
+        bool dequeue(T& data){
+            if (_size <= 0 ) {
+                data = null_value;
+                return false;
+            }
+            data = vector[0];
+            memmove(&vector[0], &vector[1], _size*sizeof(T));
+            vector[_size--] = null_value;
+            return true;
+        }
+
+        size_t size() {
+            return _size;
+        }
+
+        bool resize(size_t size) {
+            if (!vector.resize(size)){
+                return false;
+            } 
+            _size = size;
+            return clear();
+        }
+
+        bool clear() {
+            for (int j=0;j<_size;j++){
+                vector[j] = null_value;
+            }
+            _size = 0;
+            return true;
+        }
+
+        bool empty() {
+            return _size == 0;
+        }
+
+        bool is_full() {
+            return _size >= vector.size(); 
+        }
+
+        void setAllocator(Allocator &allocator){
+            vector.setAllocator(allocator);
+        }
+
+    protected:
+        Vector<T> vector;
+        size_t _size = 0;
+        int empty_pos = 0;
+        T null_value;
+};
+
+}

src/AudioTools/Buffers.h

@@ -690,39 +690,26 @@ class NBuffer : public BaseBuffer<T> {
     return *actual_read_buffer;
   }
 
-  int bufferCountFilled() {
-    int result = 0;
-    for (int j = 0; j < buffer_count; j++) {
-      if (filled_buffers[j] != nullptr) {
-        result++;
-      }
-    }
-    return result;
+  virtual int bufferCountFilled() {
+      return filled_buffers.size();
   }
 
-  int bufferCountEmpty() {
-    int result = 0;
-    for (int j = 0; j < buffer_count; j++) {
-      if (avaliable_buffers[j] != nullptr) {
-        result++;
-      }
-    }
-    return result;
+  virtual int bufferCountEmpty() {
+      return available_buffers.size();
   }
 
-  void resize(int size, int count) { 
+  virtual void resize(int size, int count) { 
     if (buffer_size==size && buffer_count == count)
       return;
     freeMemory();
     filled_buffers.resize(count);
-    avaliable_buffers.resize(count);
+    available_buffers.resize(count);
 
-    write_buffer_count = 0;
     buffer_count = count;
     buffer_size = size;
     for (int j = 0; j < count; j++) {
-      avaliable_buffers[j] = new SingleBuffer<T>(size);
-      if (avaliable_buffers[j] == nullptr) {
+      available_buffers[j] = new SingleBuffer<T>(size);
+      if (available_buffers[j] == nullptr) {
         LOGE("Not Enough Memory for buffer %d", j);
       }
     }
@@ -733,11 +720,10 @@ class NBuffer : public BaseBuffer<T> {
  protected:
   int buffer_size = 0;
   uint16_t buffer_count = 0;
-  uint16_t write_buffer_count = 0;
   BaseBuffer<T> *actual_read_buffer = nullptr;
   BaseBuffer<T> *actual_write_buffer = nullptr;
-  Vector<BaseBuffer<T> *> avaliable_buffers;
-  Vector<BaseBuffer<T> *> filled_buffers;
+  QueueFromVector<BaseBuffer<T> *> available_buffers{nullptr,0};
+  QueueFromVector<BaseBuffer<T> *> filled_buffers{nullptr,0};
   unsigned long start_time = 0;
   unsigned long sample_count = 0;
 
@@ -774,50 +760,22 @@ class NBuffer : public BaseBuffer<T> {
 
   virtual BaseBuffer<T> *getNextAvailableBuffer() {
     BaseBuffer<T> *result = nullptr;
-    for (int j = 0; j < buffer_count; j++) {
-      result = avaliable_buffers[j];
-      if (result != nullptr) {
-        avaliable_buffers[j] = nullptr;
-        break;
-      }
-    }
+    available_buffers.dequeue(result);
     return result;
   }
 
   virtual bool addAvailableBuffer(BaseBuffer<T> *buffer) {
-    bool result = false;
-    for (int j = 0; j < buffer_count; j++) {
-      if (avaliable_buffers[j] == nullptr) {
-        avaliable_buffers[j] = buffer;
-        result = true;
-        break;
-      }
-    }
-    return result;
+    return available_buffers.enqueue(buffer);
   }
 
   virtual BaseBuffer<T> *getNextFilledBuffer() {
     BaseBuffer<T> *result = nullptr;
-    if (write_buffer_count > 0) {
-      // get oldest entry
-      result = filled_buffers[0];
-      // move data by 1 entry to the left
-      for (int j = 0; j < write_buffer_count - 1; j++)
-        filled_buffers[j] = filled_buffers[j + 1];
-      // clear last enty
-      filled_buffers[write_buffer_count - 1] = nullptr;
-      write_buffer_count--;
-    }
+    filled_buffers.dequeue(result);
     return result;
   }
 
   virtual bool addFilledBuffer(BaseBuffer<T> *buffer) {
-    bool result = false;
-    if (write_buffer_count < buffer_count) {
-      filled_buffers[write_buffer_count++] = buffer;
-      result = true;
-    }
-    return result;
+    return filled_buffers.enqueue(buffer);
   }
 };
 

src/Concurrency/SynchronizedBuffers.h

@@ -160,7 +160,6 @@ class SynchronizedNBuffer : public NBuffer<T> {
     setWriteMaxWait(write_max_wait);
 
     // setup buffers
-    NBuffer<T>::write_buffer_count = 0;
     for (int j = 0; j < bufferCount; j++) {
       BaseBuffer<T> *tmp = new SingleBuffer<T>(bufferSize);
       if (tmp != nullptr) {
@@ -185,6 +184,14 @@ class SynchronizedNBuffer : public NBuffer<T> {
     return max_size;
   }
 
+  int bufferCountFilled() {
+      return filled_buffers.size();
+  }
+
+  int bufferCountEmpty() {
+      return available_buffers.size();
+  }
+
 protected:
   QueueRTOS<BaseBuffer<T>*> available_buffers{0,portMAX_DELAY,0};
   QueueRTOS<BaseBuffer<T>*> filled_buffers{0,portMAX_DELAY,0};