refactor: prefer std::queue over QQueue (#5704)

* refactor: prefer std::queue over QQueue

* refactor: prefer std::pair over QPair

qt/FileTreeView.cc

@@ -5,10 +5,10 @@
 
 #include <algorithm>
 #include <cassert>
+#include <queue>
 
 #include <QHeaderView>
 #include <QMenu>
-#include <QQueue>
 #include <QResizeEvent>
 #include <QSortFilterProxyModel>
 
@@ -263,13 +263,14 @@ void FileTreeView::onlyCheckSelectedItems()
         }
     }
 
-    QQueue<QModelIndex> parents_queue;
-    parents_queue.enqueue(root_index);
+    auto parents_queue = std::queue<QModelIndex>{};
+    parents_queue.emplace(root_index);
     QModelIndexList unwanted_indices;
 
-    while (!parents_queue.isEmpty())
+    while (!std::empty(parents_queue))
     {
-        QModelIndex const parent_index = parents_queue.dequeue();
+        auto const parent_index = std::move(parents_queue.front());
+        parents_queue.pop();
 
         if (std::binary_search(wanted_indices.begin(), wanted_indices.end(), parent_index))
         {
@@ -299,7 +300,7 @@ void FileTreeView::onlyCheckSelectedItems()
             }
             else
             {
-                parents_queue.enqueue(child_index);
+                parents_queue.emplace(child_index);
             }
         }
     }

qt/MainWindow.cc

@@ -491,12 +491,12 @@ QMenu* MainWindow::createOptionsMenu()
 
 QMenu* MainWindow::createStatsModeMenu()
 {
-    std::array<QPair<QAction*, QString>, 4> const stats_modes = {
-        qMakePair(ui_.action_TotalRatio, total_ratio_stats_mode_name_),
-        qMakePair(ui_.action_TotalTransfer, total_transfer_stats_mode_name_),
-        qMakePair(ui_.action_SessionRatio, session_ratio_stats_mode_name_),
-        qMakePair(ui_.action_SessionTransfer, session_transfer_stats_mode_name_)
-    };
+    auto const stats_modes = std::array<std::pair<QAction*, QString>, 4>{ {
+        { ui_.action_TotalRatio, total_ratio_stats_mode_name_ },
+        { ui_.action_TotalTransfer, total_transfer_stats_mode_name_ },
+        { ui_.action_SessionRatio, session_ratio_stats_mode_name_ },
+        { ui_.action_SessionTransfer, session_transfer_stats_mode_name_ },
+    } };
 
     auto* action_group = new QActionGroup(this);
     auto* menu = new QMenu(this);

qt/RpcQueue.cc

@@ -39,7 +39,7 @@ void RpcQueue::stepFinished()
         }
 
         // run next request, if we have one to run and there was no error (or if we tolerate errors)
-        if ((result.success || tolerate_errors_) && !queue_.isEmpty())
+        if ((result.success || tolerate_errors_) && !std::empty(queue_))
         {
             runNext(future);
             return;
@@ -63,7 +63,9 @@ void RpcQueue::runNext(RpcResponseFuture const& response)
 {
     assert(!queue_.isEmpty());
 
-    auto next = queue_.dequeue();
+    auto next = std::move(queue_.front());
+    queue_.pop();
+
     next_error_handler_ = next.second;
     future_watcher_.setFuture((next.first)(response));
 }

qt/RpcQueue.h

@@ -7,13 +7,13 @@
 
 #include <cstdint>
 #include <functional>
+#include <queue>
 #include <type_traits>
+#include <utility>
 
 #include <QFutureInterface>
 #include <QFutureWatcher>
 #include <QObject>
-#include <QPair>
-#include <QQueue>
 
 #include <libtransmission/tr-macros.h>
 
@@ -35,13 +35,13 @@ public:
     template<typename Func>
     void add(Func func)
     {
-        queue_.enqueue(qMakePair(normalizeFunc(func), ErrorHandlerFunction()));
+        queue_.emplace(normalizeFunc(func), ErrorHandlerFunction());
     }
 
     template<typename Func, typename ErrorHandler>
     void add(Func func, ErrorHandler error_handler)
     {
-        queue_.enqueue(qMakePair(normalizeFunc(func), normalizeErrorHandler(error_handler)));
+        queue_.emplace(normalizeFunc(func), normalizeErrorHandler(error_handler));
     }
 
     // The first function in queue is ran synchronously
@@ -151,7 +151,7 @@ private:
     Tag const tag_ = next_tag++;
     bool tolerate_errors_ = {};
     QFutureInterface<RpcResponse> promise_;
-    QQueue<QPair<QueuedFunction, ErrorHandlerFunction>> queue_;
+    std::queue<std::pair<QueuedFunction, ErrorHandlerFunction>> queue_;
     ErrorHandlerFunction next_error_handler_;
     QFutureWatcher<RpcResponse> future_watcher_;