fix: clang-tidy warwnings

Author: closetcaiman

packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioParamHostObject.h

@@ -39,7 +39,7 @@ class AudioParamHostObject : public JsiHostObject {
   friend class AudioNodeHostObject;
 
   std::shared_ptr<AudioParam> param_;
-  AutomationControlQueue controlQueue_ = AutomationControlQueue();
+  AutomationControlQueue controlQueue_;
   float defaultValue_;
   float minValue_;
   float maxValue_;

packages/react-native-audio-api/common/cpp/audioapi/core/utils/Constants.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <cmath>
+#include <cstddef>
 #include <limits>
 #include <new>
 #include <numbers>
@@ -44,4 +45,7 @@ using std::hardware_destructive_interference_size;
 constexpr std::size_t hardware_constructive_interference_size = 64;
 constexpr std::size_t hardware_destructive_interference_size = 64;
 #endif
+
+// audio param
+inline constexpr size_t AUDIO_PARAM_MAX_QUEUED_EVENTS = 32;
 } // namespace audioapi

packages/react-native-audio-api/common/cpp/audioapi/core/utils/automation/AutomationControlQueue.cpp

@@ -12,7 +12,7 @@ Result<NoneType, std::string> AutomationControlQueue::checkCurveExclusion(
     const AutomationEvent &event) {
   if (event.getType() == AutomationEventType::SET_VALUE_CURVE) {
     const auto *conflict = findEventInInterval(event.getStartTime(), event.getEndTime());
-    if (conflict) {
+    if (conflict != nullptr) {
       return Err(
           std::format(
               "Cannot schedule curve event from time {} to {} because it conflicts with an existing event of type {} at time {}.",
@@ -23,7 +23,7 @@ Result<NoneType, std::string> AutomationControlQueue::checkCurveExclusion(
     }
   } else {
     const auto *conflict = findEventAtTime(event.getAutomationEventTime());
-    if (conflict && conflict->getType() == AutomationEventType::SET_VALUE_CURVE) {
+    if ((conflict != nullptr) && conflict->getType() == AutomationEventType::SET_VALUE_CURVE) {
       return Err(
           std::format(
               "Cannot schedule event of type {} at time {} because it conflicts with an existing curve event from time {} to {}.",

packages/react-native-audio-api/common/cpp/audioapi/core/utils/automation/AutomationControlQueue.h

@@ -24,8 +24,8 @@ class AutomationControlQueue : public AutomationQueueBase<AutomationEvent> {
   void cancelScheduledValues(double cancelTime) override;
 
  private:
-  const AutomationEvent *findEventAtTime(double time) const;
-  const AutomationEvent *findEventInInterval(double startTime, double endTime) const;
+  [[nodiscard]] const AutomationEvent *findEventAtTime(double time) const;
+  [[nodiscard]] const AutomationEvent *findEventInInterval(double startTime, double endTime) const;
 };
 
 } // namespace audioapi

packages/react-native-audio-api/common/cpp/audioapi/core/utils/automation/AutomationQueueBase.hpp

@@ -1,13 +1,19 @@
 #pragma once
 
 #include <utility>
+#include "audioapi/core/utils/Constants.h"
 #include "audioapi/utils/BoundedPriorityQueue.hpp"
 
 namespace audioapi {
 
 template <typename TEvent>
 class AutomationQueueBase {
  public:
+  AutomationQueueBase() = default;
+  AutomationQueueBase(const AutomationQueueBase &) = delete;
+  AutomationQueueBase &operator=(const AutomationQueueBase &) = delete;
+  AutomationQueueBase(AutomationQueueBase &&) noexcept = delete;
+  AutomationQueueBase &operator=(AutomationQueueBase &&) noexcept = delete;
   virtual ~AutomationQueueBase() = default;
 
   /// @brief Cancel scheduled parameter changes at or after the given time.
@@ -23,12 +29,12 @@ class AutomationQueueBase {
   }
 
   /// @brief Check if the event queue is empty.
-  [[nodiscard]] inline bool isEmpty() const noexcept {
+  [[nodiscard]] bool isEmpty() const noexcept {
     return eventQueue_.isEmpty();
   }
 
   /// @brief Check if the event queue is full.
-  [[nodiscard]] inline bool isFull() const noexcept {
+  [[nodiscard]] bool isFull() const noexcept {
     return eventQueue_.isFull();
   }
 
@@ -51,7 +57,7 @@ class AutomationQueueBase {
     }
   };
 
-  BoundedPriorityQueue<TEvent, 32, EventComparator> eventQueue_;
+  BoundedPriorityQueue<TEvent, AUDIO_PARAM_MAX_QUEUED_EVENTS, EventComparator> eventQueue_;
 };
 
 } // namespace audioapi

packages/react-native-audio-api/common/cpp/audioapi/utils/BoundedPriorityQueue.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <array>
 #include <cstddef>
 #include <functional>
 #include <memory_resource>
@@ -28,9 +29,9 @@ class BoundedPriorityQueue {
   static constexpr size_t kBufferSize = Capacity * kNodeSize + 256;
 
   // Members must be declared in this order: buffer_ → mono_ → pool_ → set_.
-  alignas(std::max_align_t) std::byte buffer_[kBufferSize];
+  alignas(std::max_align_t) std::array<std::byte, kBufferSize> buffer_;
   std::pmr::monotonic_buffer_resource mono_{
-      buffer_,
+      buffer_.data(),
       sizeof(buffer_),
       std::pmr::null_memory_resource()};
   std::pmr::unsynchronized_pool_resource pool_{
@@ -43,7 +44,7 @@ class BoundedPriorityQueue {
  public:
   /// @brief Forward iterator that exposes const T& directly.
   struct Iterator {
-    typename SetType::const_iterator inner_;
+    SetType::const_iterator inner_;
 
     const T &operator*() const noexcept {
       return *inner_;
@@ -68,14 +69,17 @@ class BoundedPriorityQueue {
 
   BoundedPriorityQueue(const BoundedPriorityQueue &) = delete;
   BoundedPriorityQueue &operator=(const BoundedPriorityQueue &) = delete;
+  BoundedPriorityQueue(BoundedPriorityQueue &&) noexcept = delete;
+  BoundedPriorityQueue &operator=(BoundedPriorityQueue &&) noexcept = delete;
 
   /// @brief Insert a value in sorted order. Amortized O(1) when inserting the largest element
   /// (common case: events scheduled in chronological order), O(log n) otherwise.
   /// @return True if inserted, false if full.
   template <typename U>
   bool push(U &&value) {
-    if (isFull()) [[unlikely]]
-      return false;
+    if (isFull()) {
+      [[unlikely]] return false;
+    }
     // Hint with end(): amortized O(1) when the new event has the largest key (in-order scheduling).
     set_.insert(set_.end(), std::forward<U>(value));
     return true;
@@ -84,8 +88,9 @@ class BoundedPriorityQueue {
   /// @brief Remove and return the smallest element (front). Amortized O(1).
   /// @return True if successful, false if empty.
   bool pop(T &out) {
-    if (isEmpty()) [[unlikely]]
-      return false;
+    if (isEmpty()) {
+      [[unlikely]] return false;
+    }
     auto node = set_.extract(set_.begin());
     out = std::move(node.value());
     return true;
@@ -94,54 +99,56 @@ class BoundedPriorityQueue {
   /// @brief Remove the smallest element (front) without retrieving it. Amortized O(1).
   /// @return True if successful, false if empty.
   bool pop() {
-    if (isEmpty()) [[unlikely]]
-      return false;
+    if (isEmpty()) {
+      [[unlikely]] return false;
+    }
     set_.erase(set_.begin());
     return true;
   }
 
   /// @brief Remove the largest element (back). Amortized O(1).
   /// @return True if successful, false if empty.
   bool popBack() {
-    if (isEmpty()) [[unlikely]]
-      return false;
+    if (isEmpty()) {
+      [[unlikely]] return false;
+    }
     set_.erase(std::prev(set_.end()));
     return true;
   }
 
   /// @brief Peek at the smallest element (front).
-  [[nodiscard]] inline const T &peekFront() const noexcept {
+  [[nodiscard]] const T &peekFront() const noexcept {
     return *set_.begin();
   }
 
   /// @brief Peek at the smallest element (front), mutable.
-  [[nodiscard]] inline T &peekFrontMut() noexcept {
+  [[nodiscard]] T &peekFrontMut() noexcept {
     return const_cast<T &>(*set_.begin());
   }
 
   /// @brief Peek at the largest element (back).
-  [[nodiscard]] inline const T &peekBack() const noexcept {
+  [[nodiscard]] const T &peekBack() const noexcept {
     return *std::prev(set_.end());
   }
 
   /// @brief Peek at the largest element (back), mutable.
-  [[nodiscard]] inline T &peekBackMut() noexcept {
+  [[nodiscard]] T &peekBackMut() noexcept {
     return const_cast<T &>(*std::prev(set_.end()));
   }
 
-  [[nodiscard]] inline bool isEmpty() const noexcept {
+  [[nodiscard]] bool isEmpty() const noexcept {
     return set_.empty();
   }
 
-  [[nodiscard]] inline bool isFull() const noexcept {
+  [[nodiscard]] bool isFull() const noexcept {
     return set_.size() >= Capacity;
   }
 
-  [[nodiscard]] inline size_t size() const noexcept {
+  [[nodiscard]] size_t size() const noexcept {
     return set_.size();
   }
 
-  [[nodiscard]] inline size_t getCapacity() const noexcept {
+  [[nodiscard]] size_t getCapacity() const noexcept {
     return Capacity;
   }