refactor(sonar): fix sonar warnings

src/network/host_discovery.cpp

@@ -182,9 +182,20 @@ namespace {
    * @brief Thread-safe collector updated by the lwIP mDNS search callback.
    */
   struct DiscoveryCollector {
-    mutable std::mutex mutex;  ///< Guards the partial discovery state shared with the callback.
-    std::unordered_map<std::string, PendingDiscoveredService> servicesByInstance;  ///< Partial records keyed by instance domain.
-    std::unordered_map<std::string, std::string> ipv4ByDomain;  ///< Resolved IPv4 addresses keyed by target host domain.
+    /**
+     * @brief Construct an empty discovery collector.
+     */
+    DiscoveryCollector() = default;
+
+  private:
+    friend void remember_ptr_service_instance(DiscoveryCollector *collector, std::string instanceDomain);
+    friend void remember_srv_service_target(DiscoveryCollector *collector, std::string instanceDomain, std::string targetDomain, uint16_t port);
+    friend void remember_a_record(DiscoveryCollector *collector, std::string domain, std::string ipv4Address);
+    friend network::DiscoverHostsResult build_discover_hosts_result(const DiscoveryCollector &collector);
+
+    mutable std::mutex mutex_;  ///< Guards the partial discovery state shared with the callback.
+    std::unordered_map<std::string, PendingDiscoveredService> servicesByInstance_;  ///< Partial records keyed by instance domain.
+    std::unordered_map<std::string, std::string> ipv4ByDomain_;  ///< Resolved IPv4 addresses keyed by target host domain.
   };
 
   std::string encoded_domain_to_string(const char *encodedDomain, std::size_t encodedLength) {
@@ -235,8 +246,8 @@ namespace {
       return;
     }
 
-    const std::scoped_lock lock(collector->mutex);
-    PendingDiscoveredService &service = collector->servicesByInstance[instanceDomain];
+    const std::scoped_lock lock(collector->mutex_);
+    PendingDiscoveredService &service = collector->servicesByInstance_[instanceDomain];
     service.instanceDomain = std::move(instanceDomain);
     if (service.displayName.empty()) {
       service.displayName = first_dns_label(service.instanceDomain);
@@ -248,8 +259,8 @@ namespace {
       return;
     }
 
-    const std::scoped_lock lock(collector->mutex);
-    PendingDiscoveredService &service = collector->servicesByInstance[instanceDomain];
+    const std::scoped_lock lock(collector->mutex_);
+    PendingDiscoveredService &service = collector->servicesByInstance_[instanceDomain];
     service.instanceDomain = std::move(instanceDomain);
     if (service.displayName.empty()) {
       service.displayName = first_dns_label(service.instanceDomain);
@@ -263,8 +274,8 @@ namespace {
       return;
     }
 
-    const std::scoped_lock lock(collector->mutex);
-    collector->ipv4ByDomain[std::move(domain)] = std::move(ipv4Address);
+    const std::scoped_lock lock(collector->mutex_);
+    collector->ipv4ByDomain_[std::move(domain)] = std::move(ipv4Address);
   }
 
   /**
@@ -315,14 +326,14 @@ namespace {
   network::DiscoverHostsResult build_discover_hosts_result(const DiscoveryCollector &collector) {
     network::DiscoverHostsResult result {};
 
-    const std::scoped_lock lock(collector.mutex);
-    for (const auto &[instanceDomain, service] : collector.servicesByInstance) {
+    const std::scoped_lock lock(collector.mutex_);
+    for (const auto &[instanceDomain, service] : collector.servicesByInstance_) {
       (void) instanceDomain;
       if (service.targetDomain.empty() || service.port == 0) {
         continue;
       }
-      const auto addressIterator = collector.ipv4ByDomain.find(service.targetDomain);
-      if (addressIterator == collector.ipv4ByDomain.end()) {
+      const auto addressIterator = collector.ipv4ByDomain_.find(service.targetDomain);
+      if (addressIterator == collector.ipv4ByDomain_.end()) {
         continue;
       }
 

src/streaming/ffmpeg_stream_backend.cpp

@@ -457,7 +457,7 @@ namespace streaming {
 
     bool textureNeedsUpload = false;
     if (const std::uint64_t publishedFrameVersion = video_.publishedFrameVersion.load(); publishedFrameVersion != video_.renderedFrameVersion) {
-      std::scoped_lock lock(video_.frameMutex);
+      std::scoped_lock lock(video_.frame_mutex());
       if (video_.latestFrameVersion != video_.renderedFrameVersion && video_.latestFrame.width > 0 && video_.latestFrame.height > 0) {
         std::swap(video_.renderFrame, video_.latestFrame);
         video_.renderedFrameVersion = video_.latestFrameVersion;
@@ -611,7 +611,7 @@ namespace streaming {
     video_.renderFrame = LatestVideoFrame {};
     video_.decodeFrame = LatestVideoFrame {};
     {
-      std::scoped_lock lock(video_.frameMutex);
+      std::scoped_lock lock(video_.frame_mutex());
       video_.latestFrame = LatestVideoFrame {};
       video_.latestFrameVersion = 0;
     }
@@ -742,7 +742,7 @@ namespace streaming {
     std::memcpy(nextFrame.vPlane.data(), frameToPresent->data[2], nextFrame.vPlane.size());
 
     {
-      std::scoped_lock lock(video_.frameMutex);
+      std::scoped_lock lock(video_.frame_mutex());
       std::swap(video_.latestFrame, video_.decodeFrame);
       ++video_.latestFrameVersion;
       video_.publishedFrameVersion.store(video_.latestFrameVersion);

src/streaming/ffmpeg_stream_backend.h

@@ -277,7 +277,20 @@ namespace streaming {
       std::uint64_t renderedFrameVersion = 0;
       std::vector<std::uint8_t> convertedBuffer;
       std::vector<std::uint8_t> packetBuffer;
-      mutable std::mutex frameMutex;
+
+      /**
+       * @brief Return the mutex guarding decoded frame publication.
+       *
+       * @return Mutex used to exchange frames between decode and render threads.
+       */
+      [[nodiscard]] std::mutex &frame_mutex() const {
+        return frameMutex_;
+      }
+
+    private:
+      mutable std::mutex frameMutex_;  ///< Guards latest decoded frame publication between worker and render threads.
+
+    public:
       SDL_Rect directFramebufferDestination {0, 0, 0, 0};
       LatestVideoFrame latestFrame;
       LatestVideoFrame decodeFrame;