dspx 0.1.1-alpha.0

package/src/native/utils/CircularBufferVector.cc

@@ -0,0 +1,145 @@
+#include "CircularBufferVector.h"
+#include <algorithm>
+#include <stdexcept>
+
+using namespace dsp::utils;
+
+// -----------------------------------------------------------------------------
+// Constructor
+// Initializes the circular buffer with a specified size
+// @ param size - The size of the circular buffer
+// @ return void
+template <typename T>
+CircularBufferVector<T>::CircularBufferVector(size_t size)
+    : head(0), tail(0), capacity(std::max(size, static_cast<size_t>(1))), count(0)
+{
+    this->buffer.resize(this->capacity);
+}
+
+// -----------------------------------------------------------------------------
+// Method: push
+// Adds an item to the circular buffer
+// @ param item - The item to add
+// @ return bool - True if the item was added, false if the buffer is full
+template <typename T>
+bool CircularBufferVector<T>::push(const T &item)
+{
+    if (isFull())
+    {
+        return false; // Buffer is full
+    }
+
+    this->buffer[this->head] = item;
+    this->head = (this->head + 1) % this->capacity;
+    this->count++;
+    return true;
+}
+
+// -----------------------------------------------------------------------------
+// Method: pop
+// Removes an item from the circular buffer
+// @ param item - The item to remove
+// @ return bool - True if the item was removed, false if the buffer is empty
+template <typename T>
+bool CircularBufferVector<T>::pop(T &item) noexcept
+{
+    if (isEmpty())
+    {
+        return false; // Buffer is empty
+    }
+
+    item = this->buffer[this->tail];
+    this->tail = (this->tail + 1) % this->capacity;
+    this->count--;
+    return true;
+}
+
+// -----------------------------------------------------------------------------
+// Method: clear
+// Clears the circular buffer
+// @ param void
+// @ return void
+template <typename T>
+void CircularBufferVector<T>::clear() noexcept
+{
+    this->head = 0;
+    this->tail = 0;
+    this->count = 0;
+}
+
+// -----------------------------------------------------------------------------
+// Method: pushOverwrite
+// Adds an item to the circular buffer, overwriting the oldest item if full
+// @ param item - The item to add
+// @ return void
+template <typename T>
+void CircularBufferVector<T>::pushOverwrite(const T &item)
+{
+    this->buffer[this->head] = item;
+    this->head = (this->head + 1) % this->capacity;
+
+    this->count < this->capacity ? ++this->count : this->tail = (this->tail + 1) % this->capacity;
+}
+
+// -----------------------------------------------------------------------------
+// Getter: getCapacity
+// @ param void
+// @ return size_t - The capacity of the circular buffer
+template <typename T>
+size_t CircularBufferVector<T>::getCapacity() const noexcept
+{
+    return this->capacity;
+}
+
+// -----------------------------------------------------------------------------
+// Getter: getCount
+// @ param void
+// @ return size_t - The number of elements in the circular buffer
+template <typename T>
+size_t CircularBufferVector<T>::getCount() const noexcept
+{
+    return this->count;
+}
+
+// -----------------------------------------------------------------------------
+// Getter: isEmpty
+// @ param void
+// @ return bool - True if the buffer is empty, false otherwise
+template <typename T>
+bool CircularBufferVector<T>::isEmpty() const noexcept
+{
+    return this->count == 0;
+}
+
+// -----------------------------------------------------------------------------
+// Getter: isFull
+// @ param void
+// @ return bool - True if the buffer is full, false otherwise
+template <typename T>
+bool CircularBufferVector<T>::isFull() const noexcept
+{
+    return this->count == this->capacity;
+}
+
+// -----------------------------------------------------------------------------
+// Getter: peek
+// @ param void
+// @ return T - The item at the head of the buffer
+template <typename T>
+T CircularBufferVector<T>::peek() const
+{
+    if (isEmpty())
+    {
+        throw std::runtime_error("Buffer is empty");
+    }
+
+    return this->buffer[this->tail];
+}
+
+// Explicit template instantiation for common types
+namespace dsp::utils
+{
+    template class CircularBufferVector<int>;
+    template class CircularBufferVector<float>;
+    template class CircularBufferVector<double>;
+}

package/src/native/utils/CircularBufferVector.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <vector>
+#include <stdexcept>
+
+namespace dsp::utils
+{
+    template <typename T>
+
+    class CircularBufferVector
+    {
+    public:
+        // constructors
+        explicit CircularBufferVector(size_t size);
+        CircularBufferVector(const CircularBufferVector &other) = delete;            // disable copy to avoid shallow copy
+        CircularBufferVector &operator=(const CircularBufferVector &other) = delete; // disable copy assignment to avoid shallow copy
+
+        // move semantics
+        CircularBufferVector(CircularBufferVector &&other) noexcept = default;
+        CircularBufferVector &operator=(CircularBufferVector &&other) noexcept = default;
+
+        // methods
+        bool push(const T &item);
+        bool pop(T &item) noexcept;
+        void clear() noexcept;
+        void pushOverwrite(const T &item);
+
+        // getters
+        size_t getCapacity() const noexcept;
+        size_t getCount() const noexcept;
+        bool isEmpty() const noexcept;
+        bool isFull() const noexcept;
+        T peek() const;
+
+        // destructor not needed since vector manages its own memory
+        ~CircularBufferVector() = default;
+
+    private:
+        std::vector<T> buffer;
+        size_t head;
+        size_t tail;
+        size_t capacity;
+        size_t count;
+    };
+}

package/src/native/utils/NapiUtils.cc

@@ -0,0 +1,53 @@
+#include "NapiUtils.h"
+
+template <typename T>
+std::vector<T> dsp::utils::NapiArrayToVector(const Napi::Array &arr)
+{
+    std::vector<T> vec;
+    vec.reserve(arr.Length());
+    for (uint32_t j = 0; j < arr.Length(); ++j)
+    {
+        if (std::is_same<T, bool>::value)
+        {
+            vec.push_back(arr.Get(j).As<Napi::Boolean>().Value());
+        }
+        else if (std::is_same<T, double>::value)
+        {
+            // Use DoubleValue() for double to preserve precision
+            vec.push_back(static_cast<T>(arr.Get(j).As<Napi::Number>().DoubleValue()));
+        }
+        else
+        {
+            // Use FloatValue() for float types
+            vec.push_back(static_cast<T>(arr.Get(j).As<Napi::Number>().FloatValue()));
+        }
+    }
+    return vec;
+}
+
+template <typename T>
+Napi::Array dsp::utils::VectorToNapiArray(Napi::Env env, const std::vector<T> &vec)
+{
+    Napi::Array arr = Napi::Array::New(env, vec.size());
+    for (size_t j = 0; j < vec.size(); ++j)
+    {
+        if (std::is_same<T, bool>::value)
+        {
+            arr.Set(j, Napi::Boolean::New(env, static_cast<bool>(vec[j])));
+        }
+        else
+        {
+            arr.Set(j, Napi::Number::New(env, static_cast<double>(vec[j])));
+        }
+    }
+    return arr;
+}
+
+// Explicit template instantiations
+template std::vector<float> dsp::utils::NapiArrayToVector<float>(const Napi::Array &);
+template std::vector<double> dsp::utils::NapiArrayToVector<double>(const Napi::Array &);
+template std::vector<bool> dsp::utils::NapiArrayToVector<bool>(const Napi::Array &);
+
+template Napi::Array dsp::utils::VectorToNapiArray<float>(Napi::Env, const std::vector<float> &);
+template Napi::Array dsp::utils::VectorToNapiArray<double>(Napi::Env, const std::vector<double> &);
+template Napi::Array dsp::utils::VectorToNapiArray<bool>(Napi::Env, const std::vector<bool> &);

package/src/native/utils/NapiUtils.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <napi.h>
+#include <vector>
+#include <type_traits> // For std::is_same
+
+namespace dsp::utils
+{
+    /**
+     * @brief Helper to convert Napi::Array to std::vector
+     */
+    template <typename T>
+    std::vector<T> NapiArrayToVector(const Napi::Array &arr);
+
+    /**
+     * @brief Helper to convert std::vector to Napi::Array
+     */
+    template <typename T>
+    Napi::Array VectorToNapiArray(Napi::Env env, const std::vector<T> &vec);
+
+} // namespace dsp::utils