Fix warnings regarding Resource static cast

Signed-off-by: Trial97 <alexandru.tripon97@gmail.com>

launcher/minecraft/mod/ModFolderModel.cpp

@@ -48,16 +48,10 @@
 #include <QThreadPool>
 #include <QUrl>
 #include <QUuid>
-#include <algorithm>
 
 #include "Application.h"
 
-#include "Json.h"
 #include "minecraft/mod/tasks/LocalModParseTask.h"
-#include "minecraft/mod/tasks/LocalResourceUpdateTask.h"
-#include "modplatform/ModIndex.h"
-#include "modplatform/flame/FlameAPI.h"
-#include "modplatform/flame/FlameModIndex.h"
 
 ModFolderModel::ModFolderModel(const QDir& dir, BaseInstance* instance, bool is_indexed, bool create_dir, QObject* parent)
     : ResourceFolderModel(QDir(dir), instance, is_indexed, create_dir, parent)
@@ -246,7 +240,7 @@ void ModFolderModel::onParseSucceeded(int ticket, QString mod_id)
 
     auto result = cast_task->result();
     if (result && resource)
-        resource->finishResolvingWithDetails(std::move(result->details));
+        static_cast<Mod*>(resource.get())->finishResolvingWithDetails(std::move(result->details));
 
     emit dataChanged(index(row), index(row, columnCount(QModelIndex()) - 1));
 }

launcher/minecraft/mod/ModFolderModel.h

@@ -47,10 +47,6 @@
 #include "Mod.h"
 #include "ResourceFolderModel.h"
 
-#include "minecraft/mod/tasks/LocalModParseTask.h"
-#include "minecraft/mod/tasks/ResourceFolderLoadTask.h"
-#include "modplatform/ModIndex.h"
-
 class BaseInstance;
 class QFileSystemWatcher;
 

launcher/minecraft/mod/Resource.h

@@ -41,7 +41,6 @@
 #include <QPointer>
 
 #include "MetadataHandler.h"
-#include "ModDetails.h"
 #include "QObjectPtr.h"
 
 enum class ResourceType {

launcher/minecraft/mod/ResourceFolderModel.cpp

@@ -16,8 +16,6 @@
 #include "Application.h"
 #include "FileSystem.h"
 
-#include "QVariantUtils.h"
-#include "StringUtils.h"
 #include "minecraft/mod/tasks/ResourceFolderLoadTask.h"
 
 #include "Json.h"
@@ -327,7 +325,7 @@ bool ResourceFolderModel::update()
     return true;
 }
 
-void ResourceFolderModel::resolveResource(Resource* res)
+void ResourceFolderModel::resolveResource(Resource::Ptr res)
 {
     if (!res->shouldResolve()) {
         return;
@@ -386,7 +384,7 @@ void ResourceFolderModel::onUpdateSucceeded()
 void ResourceFolderModel::onParseSucceeded(int ticket, QString resource_id)
 {
     auto iter = m_active_parse_tasks.constFind(ticket);
-    if (iter == m_active_parse_tasks.constEnd())
+    if (iter == m_active_parse_tasks.constEnd() || !m_resources_index.contains(resource_id))
         return;
 
     int row = m_resources_index[resource_id];
@@ -705,7 +703,7 @@ QString ResourceFolderModel::instDirPath() const
 void ResourceFolderModel::onParseFailed(int ticket, QString resource_id)
 {
     auto iter = m_active_parse_tasks.constFind(ticket);
-    if (iter == m_active_parse_tasks.constEnd())
+    if (iter == m_active_parse_tasks.constEnd() || !m_resources_index.contains(resource_id))
         return;
 
     auto removed_index = m_resources_index[resource_id];
@@ -724,3 +722,126 @@ void ResourceFolderModel::onParseFailed(int ticket, QString resource_id)
     }
     endRemoveRows();
 }
+
+void ResourceFolderModel::applyUpdates(QSet<QString>& current_set, QSet<QString>& new_set, QMap<QString, Resource::Ptr>& new_resources)
+{
+    // see if the kept resources changed in some way
+    {
+        QSet<QString> kept_set = current_set;
+        kept_set.intersect(new_set);
+
+        for (auto const& kept : kept_set) {
+            auto row_it = m_resources_index.constFind(kept);
+            Q_ASSERT(row_it != m_resources_index.constEnd());
+            auto row = row_it.value();
+
+            auto& new_resource = new_resources[kept];
+            auto const& current_resource = m_resources.at(row);
+
+            if (new_resource->dateTimeChanged() == current_resource->dateTimeChanged()) {
+                // no significant change, ignore...
+                continue;
+            }
+
+            // If the resource is resolving, but something about it changed, we don't want to
+            // continue the resolving.
+            if (current_resource->isResolving()) {
+                auto ticket = current_resource->resolutionTicket();
+                if (m_active_parse_tasks.contains(ticket)) {
+                    auto task = (*m_active_parse_tasks.find(ticket)).get();
+                    task->abort();
+                }
+            }
+
+            m_resources[row].reset(new_resource);
+            resolveResource(m_resources.at(row));
+            emit dataChanged(index(row, 0), index(row, columnCount(QModelIndex()) - 1));
+        }
+    }
+
+    // remove resources no longer present
+    {
+        QSet<QString> removed_set = current_set;
+        removed_set.subtract(new_set);
+
+        QList<int> removed_rows;
+        for (auto& removed : removed_set)
+            removed_rows.append(m_resources_index[removed]);
+
+        std::sort(removed_rows.begin(), removed_rows.end(), std::greater<int>());
+
+        for (auto& removed_index : removed_rows) {
+            auto removed_it = m_resources.begin() + removed_index;
+
+            Q_ASSERT(removed_it != m_resources.end());
+
+            if ((*removed_it)->isResolving()) {
+                auto ticket = (*removed_it)->resolutionTicket();
+                if (m_active_parse_tasks.contains(ticket)) {
+                    auto task = (*m_active_parse_tasks.find(ticket)).get();
+                    task->abort();
+                }
+            }
+
+            beginRemoveRows(QModelIndex(), removed_index, removed_index);
+            m_resources.erase(removed_it);
+            endRemoveRows();
+        }
+    }
+
+    // add new resources to the end
+    {
+        QSet<QString> added_set = new_set;
+        added_set.subtract(current_set);
+
+        // When you have a Qt build with assertions turned on, proceeding here will abort the application
+        if (added_set.size() > 0) {
+            beginInsertRows(QModelIndex(), static_cast<int>(m_resources.size()),
+                            static_cast<int>(m_resources.size() + added_set.size() - 1));
+
+            for (auto& added : added_set) {
+                auto res = new_resources[added];
+                m_resources.append(res);
+                resolveResource(m_resources.last());
+            }
+
+            endInsertRows();
+        }
+    }
+
+    // update index
+    {
+        m_resources_index.clear();
+        int idx = 0;
+        for (auto const& mod : qAsConst(m_resources)) {
+            m_resources_index[mod->internal_id()] = idx;
+            idx++;
+        }
+    }
+}
+Resource::Ptr ResourceFolderModel::find(QString id)
+{
+    auto iter =
+        std::find_if(m_resources.constBegin(), m_resources.constEnd(), [&](Resource::Ptr const& r) { return r->internal_id() == id; });
+    if (iter == m_resources.constEnd())
+        return nullptr;
+    return *iter;
+}
+QList<Resource*> ResourceFolderModel::allResources()
+{
+    QList<Resource*> result;
+    result.reserve(m_resources.size());
+    for (const Resource ::Ptr& resource : m_resources)
+        result.append((resource.get()));
+    return result;
+}
+QList<Resource*> ResourceFolderModel::selectedResources(const QModelIndexList& indexes)
+{
+    QList<Resource*> result;
+    for (const QModelIndex& index : indexes) {
+        if (index.column() != 0)
+            continue;
+        result.append(&at(index.row()));
+    }
+    return result;
+}

launcher/minecraft/mod/ResourceFolderModel.h

@@ -20,55 +20,35 @@
 class QSortFilterProxyModel;
 
 /* A macro to define useful functions to handle Resource* -> T* more easily on derived classes */
-#define RESOURCE_HELPERS(T)                                                                        \
+#define RESOURCE_HELPERS(T)                                         \
-    [[nodiscard]] T& operator[](int index)                                                         \
+    [[nodiscard]] T& at(int index)                                  \
-    {                                                                                              \
+    {                                                               \
-        return *static_cast<T*>(m_resources[index].get());                                         \
+        return *static_cast<T*>(m_resources[index].get());          \
-    }                                                                                              \
+    }                                                               \
-    [[nodiscard]] T& at(int index)                                                                 \
+    [[nodiscard]] const T& at(int index) const                      \
-    {                                                                                              \
+    {                                                               \
-        return *static_cast<T*>(m_resources[index].get());                                         \
+        return *static_cast<const T*>(m_resources.at(index).get()); \
-    }                                                                                              \
+    }                                                               \
-    [[nodiscard]] const T& at(int index) const                                                     \
+    QList<T*> selected##T##s(const QModelIndexList& indexes)        \
-    {                                                                                              \
+    {                                                               \
-        return *static_cast<const T*>(m_resources.at(index).get());                                \
+        QList<T*> result;                                           \
-    }                                                                                              \
+        for (const QModelIndex& index : indexes) {                  \
-    [[nodiscard]] T& first()                                                                       \
+            if (index.column() != 0)                                \
-    {                                                                                              \
+                continue;                                           \
-        return *static_cast<T*>(m_resources.first().get());                                        \
+                                                                    \
-    }                                                                                              \
+            result.append(&at(index.row()));                        \
-    [[nodiscard]] T& last()                                                                        \
+        }                                                           \
-    {                                                                                              \
+        return result;                                              \
-        return *static_cast<T*>(m_resources.last().get());                                         \
+    }                                                               \
-    }                                                                                              \
+    QList<T*> all##T##s()                                           \
-    [[nodiscard]] T* find(QString id)                                                              \
+    {                                                               \
-    {                                                                                              \
+        QList<T*> result;                                           \
-        auto iter = std::find_if(m_resources.constBegin(), m_resources.constEnd(),                 \
+        result.reserve(m_resources.size());                         \
-                                 [id](Resource::Ptr const& r) { return r->internal_id() == id; }); \
+                                                                    \
-        if (iter == m_resources.constEnd())                                                        \
+        for (const Resource::Ptr& resource : m_resources)           \
-            return nullptr;                                                                        \
+            result.append(static_cast<T*>(resource.get()));         \
-        return static_cast<T*>((*iter).get());                                                     \
+                                                                    \
-    }                                                                                              \
+        return result;                                              \
-    QList<T*> selected##T##s(const QModelIndexList& indexes)                                       \
-    {                                                                                              \
-        QList<T*> result;                                                                          \
-        for (const QModelIndex& index : indexes) {                                                 \
-            if (index.column() != 0)                                                               \
-                continue;                                                                          \
-                                                                                                   \
-            result.append(&at(index.row()));                                                       \
-        }                                                                                          \
-        return result;                                                                             \
-    }                                                                                              \
-    QList<T*> all##T##s()                                                                          \
-    {                                                                                              \
-        QList<T*> result;                                                                          \
-        result.reserve(m_resources.size());                                                        \
-                                                                                                   \
-        for (const Resource::Ptr& resource : m_resources)                                          \
-            result.append(static_cast<T*>(resource.get()));                                        \
-                                                                                                   \
-        return result;                                                                             \
     }
 
 /** A basic model for external resources.
@@ -133,11 +113,17 @@ class ResourceFolderModel : public QAbstractListModel {
     virtual bool update();
 
     /** Creates a new parse task, if needed, for 'res' and start it.*/
-    virtual void resolveResource(Resource* res);
+    virtual void resolveResource(Resource::Ptr res);
 
     [[nodiscard]] qsizetype size() const { return m_resources.size(); }
     [[nodiscard]] bool empty() const { return size() == 0; }
-    RESOURCE_HELPERS(Resource)
+
+    [[nodiscard]] Resource& at(int index) { return *m_resources[index].get(); }
+    [[nodiscard]] const Resource& at(int index) const { return *m_resources.at(index).get(); }
+    QList<Resource*> selectedResources(const QModelIndexList& indexes);
+    QList<Resource*> allResources();
+
+    [[nodiscard]] Resource::Ptr find(QString id);
 
     [[nodiscard]] QDir const& dir() const { return m_dir; }
 
@@ -225,10 +211,8 @@ class ResourceFolderModel : public QAbstractListModel {
      *  It uses set operations to find differences between the current state and the updated state,
      *  to act only on those disparities.
      *
-     *  The implementation is at the end of this header.
      */
-    template <typename T>
+    void applyUpdates(QSet<QString>& current_set, QSet<QString>& new_set, QMap<QString, Resource::Ptr>& new_resources);
-    void applyUpdates(QSet<QString>& current_set, QSet<QString>& new_set, QMap<QString, T>& new_resources);
 
    protected slots:
     void directoryChanged(QString);
@@ -281,102 +265,3 @@ class ResourceFolderModel : public QAbstractListModel {
     QMap<int, Task::Ptr> m_active_parse_tasks;
     std::atomic<int> m_next_resolution_ticket = 0;
 };
-
-/* Template definition to avoid some code duplication */
-template <typename T>
-void ResourceFolderModel::applyUpdates(QSet<QString>& current_set, QSet<QString>& new_set, QMap<QString, T>& new_resources)
-{
-    // see if the kept resources changed in some way
-    {
-        QSet<QString> kept_set = current_set;
-        kept_set.intersect(new_set);
-
-        for (auto const& kept : kept_set) {
-            auto row_it = m_resources_index.constFind(kept);
-            Q_ASSERT(row_it != m_resources_index.constEnd());
-            auto row = row_it.value();
-
-            auto& new_resource = new_resources[kept];
-            auto const& current_resource = m_resources.at(row);
-
-            if (new_resource->dateTimeChanged() == current_resource->dateTimeChanged()) {
-                // no significant change, ignore...
-                continue;
-            }
-
-            // If the resource is resolving, but something about it changed, we don't want to
-            // continue the resolving.
-            if (current_resource->isResolving()) {
-                auto ticket = current_resource->resolutionTicket();
-                if (m_active_parse_tasks.contains(ticket)) {
-                    auto task = (*m_active_parse_tasks.find(ticket)).get();
-                    task->abort();
-                }
-            }
-
-            m_resources[row].reset(new_resource);
-            resolveResource(m_resources.at(row).get());
-            emit dataChanged(index(row, 0), index(row, columnCount(QModelIndex()) - 1));
-        }
-    }
-
-    // remove resources no longer present
-    {
-        QSet<QString> removed_set = current_set;
-        removed_set.subtract(new_set);
-
-        QList<int> removed_rows;
-        for (auto& removed : removed_set)
-            removed_rows.append(m_resources_index[removed]);
-
-        std::sort(removed_rows.begin(), removed_rows.end(), std::greater<int>());
-
-        for (auto& removed_index : removed_rows) {
-            auto removed_it = m_resources.begin() + removed_index;
-
-            Q_ASSERT(removed_it != m_resources.end());
-
-            if ((*removed_it)->isResolving()) {
-                auto ticket = (*removed_it)->resolutionTicket();
-                if (m_active_parse_tasks.contains(ticket)) {
-                    auto task = (*m_active_parse_tasks.find(ticket)).get();
-                    task->abort();
-                }
-            }
-
-            beginRemoveRows(QModelIndex(), removed_index, removed_index);
-            m_resources.erase(removed_it);
-            endRemoveRows();
-        }
-    }
-
-    // add new resources to the end
-    {
-        QSet<QString> added_set = new_set;
-        added_set.subtract(current_set);
-
-        // When you have a Qt build with assertions turned on, proceeding here will abort the application
-        if (added_set.size() > 0) {
-            beginInsertRows(QModelIndex(), static_cast<int>(m_resources.size()),
-                            static_cast<int>(m_resources.size() + added_set.size() - 1));
-
-            for (auto& added : added_set) {
-                auto res = new_resources[added];
-                m_resources.append(res);
-                resolveResource(m_resources.last().get());
-            }
-
-            endInsertRows();
-        }
-    }
-
-    // update index
-    {
-        m_resources_index.clear();
-        int idx = 0;
-        for (auto const& mod : qAsConst(m_resources)) {
-            m_resources_index[mod->internal_id()] = idx;
-            idx++;
-        }
-    }
-}

launcher/minecraft/mod/ResourcePackFolderModel.cpp

@@ -45,7 +45,6 @@
 #include "Version.h"
 
 #include "minecraft/mod/tasks/LocalResourcePackParseTask.h"
-#include "minecraft/mod/tasks/ResourceFolderLoadTask.h"
 
 ResourcePackFolderModel::ResourcePackFolderModel(const QDir& dir, BaseInstance* instance, bool is_indexed, bool create_dir, QObject* parent)
     : ResourceFolderModel(dir, instance, is_indexed, create_dir, parent)
@@ -55,7 +54,7 @@ ResourcePackFolderModel::ResourcePackFolderModel(const QDir& dir, BaseInstance*
         QStringList({ tr("Enable"), tr("Image"), tr("Name"), tr("Pack Format"), tr("Last Modified"), tr("Provider"), tr("Size") });
     m_column_sort_keys = { SortType::ENABLED, SortType::NAME,     SortType::NAME, SortType::PACK_FORMAT,
                            SortType::DATE,    SortType::PROVIDER, SortType::SIZE };
-    m_column_resize_modes = { QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Stretch, QHeaderView::Interactive,
+    m_column_resize_modes = { QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Stretch,    QHeaderView::Interactive,
                               QHeaderView::Interactive, QHeaderView::Interactive, QHeaderView::Interactive };
     m_columnsHideable = { false, true, false, true, true, true, true };
 }

launcher/ui/pages/instance/ModFolderPage.cpp

@@ -51,22 +51,15 @@
 
 #include "Application.h"
 
-#include "ui/GuiUtil.h"
 #include "ui/dialogs/CustomMessageBox.h"
 #include "ui/dialogs/ResourceDownloadDialog.h"
 #include "ui/dialogs/ResourceUpdateDialog.h"
 
-#include "DesktopServices.h"
-
 #include "minecraft/PackProfile.h"
 #include "minecraft/VersionFilterData.h"
 #include "minecraft/mod/Mod.h"
 #include "minecraft/mod/ModFolderModel.h"
 
-#include "modplatform/ModIndex.h"
-#include "modplatform/ResourceAPI.h"
-
-#include "Version.h"
 #include "tasks/ConcurrentTask.h"
 #include "tasks/Task.h"
 #include "ui/dialogs/ProgressDialog.h"

launcher/ui/pages/instance/ResourcePackPage.cpp

@@ -37,8 +37,6 @@
 
 #include "ResourcePackPage.h"
 
-#include "ResourceDownloadTask.h"
-
 #include "ui/dialogs/CustomMessageBox.h"
 #include "ui/dialogs/ProgressDialog.h"
 #include "ui/dialogs/ResourceDownloadDialog.h"