pollymc/launcher/minecraft/Component.cpp

477 lines
11 KiB
C++
Raw Normal View History

// SPDX-License-Identifier: GPL-3.0-only
/*
* PolyMC - Minecraft Launcher
* Copyright (C) 2022 Sefa Eyeoglu <contact@scrumplex.net>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, version 3.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
* This file incorporates work covered by the following copyright and
* permission notice:
*
* Copyright 2013-2021 MultiMC Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <meta/VersionList.h>
#include <meta/Index.h>
#include "Component.h"
#include <QSaveFile>
#include "meta/Version.h"
#include "VersionFile.h"
#include "minecraft/PackProfile.h"
#include "FileSystem.h"
#include "OneSixVersionFormat.h"
#include "Application.h"
#include <assert.h>
Component::Component(PackProfile * parent, const QString& uid)
{
2018-07-15 18:21:05 +05:30
assert(parent);
m_parent = parent;
2018-07-15 18:21:05 +05:30
m_uid = uid;
}
Component::Component(PackProfile * parent, std::shared_ptr<Meta::Version> version)
{
2018-07-15 18:21:05 +05:30
assert(parent);
m_parent = parent;
2018-07-15 18:21:05 +05:30
m_metaVersion = version;
m_uid = version->uid();
m_version = m_cachedVersion = version->version();
m_cachedName = version->name();
m_loaded = version->isLoaded();
}
Component::Component(PackProfile * parent, const QString& uid, std::shared_ptr<VersionFile> file)
{
2018-07-15 18:21:05 +05:30
assert(parent);
m_parent = parent;
2018-07-15 18:21:05 +05:30
m_file = file;
m_uid = uid;
m_cachedVersion = m_file->version;
m_cachedName = m_file->name;
m_loaded = true;
}
std::shared_ptr<Meta::Version> Component::getMeta()
{
2018-07-15 18:21:05 +05:30
return m_metaVersion;
}
void Component::applyTo(LaunchProfile* profile)
{
2018-07-15 18:21:05 +05:30
// do not apply disabled components
if(!isEnabled())
{
return;
}
auto vfile = getVersionFile();
if(vfile)
{
vfile->applyTo(profile, m_parent->runtimeContext());
2018-07-15 18:21:05 +05:30
}
else
{
profile->applyProblemSeverity(getProblemSeverity());
}
}
std::shared_ptr<class VersionFile> Component::getVersionFile() const
{
2018-07-15 18:21:05 +05:30
if(m_metaVersion)
{
if(!m_metaVersion->isLoaded())
{
m_metaVersion->load(Net::Mode::Online);
}
return m_metaVersion->data();
}
else
{
return m_file;
}
}
std::shared_ptr<class Meta::VersionList> Component::getVersionList() const
{
2018-07-15 18:21:05 +05:30
// FIXME: what if the metadata index isn't loaded yet?
if(APPLICATION->metadataIndex()->hasUid(m_uid))
2018-07-15 18:21:05 +05:30
{
return APPLICATION->metadataIndex()->get(m_uid);
2018-07-15 18:21:05 +05:30
}
return nullptr;
}
int Component::getOrder()
{
2018-07-15 18:21:05 +05:30
if(m_orderOverride)
return m_order;
2018-07-15 18:21:05 +05:30
auto vfile = getVersionFile();
if(vfile)
{
return vfile->order;
}
return 0;
}
void Component::setOrder(int order)
{
2018-07-15 18:21:05 +05:30
m_orderOverride = true;
m_order = order;
}
QString Component::getID()
{
2018-07-15 18:21:05 +05:30
return m_uid;
}
QString Component::getName()
{
2018-07-15 18:21:05 +05:30
if (!m_cachedName.isEmpty())
return m_cachedName;
return m_uid;
}
QString Component::getVersion()
{
2018-07-15 18:21:05 +05:30
return m_cachedVersion;
}
QString Component::getFilename()
{
2018-07-15 18:21:05 +05:30
return m_parent->patchFilePathForUid(m_uid);
}
QDateTime Component::getReleaseDateTime()
{
2018-07-15 18:21:05 +05:30
if(m_metaVersion)
{
return m_metaVersion->time();
}
auto vfile = getVersionFile();
if(vfile)
{
return vfile->releaseTime;
}
// FIXME: fake
return QDateTime::currentDateTime();
}
bool Component::isEnabled()
{
2018-07-15 18:21:05 +05:30
return !canBeDisabled() || !m_disabled;
}
bool Component::canBeDisabled()
{
2018-07-15 18:21:05 +05:30
return isRemovable() && !m_dependencyOnly;
}
bool Component::setEnabled(bool state)
{
2018-07-15 18:21:05 +05:30
bool intendedDisabled = !state;
if (!canBeDisabled())
{
intendedDisabled = false;
}
if(intendedDisabled != m_disabled)
{
m_disabled = intendedDisabled;
emit dataChanged();
return true;
}
return false;
}
bool Component::isCustom()
{
2018-07-15 18:21:05 +05:30
return m_file != nullptr;
}
bool Component::isCustomizable()
{
2018-07-15 18:21:05 +05:30
if(m_metaVersion)
{
if(getVersionFile())
{
return true;
}
}
return false;
}
bool Component::isRemovable()
{
2018-07-15 18:21:05 +05:30
return !m_important;
}
bool Component::isRevertible()
{
2018-07-15 18:21:05 +05:30
if (isCustom())
{
if(APPLICATION->metadataIndex()->hasUid(m_uid))
2018-07-15 18:21:05 +05:30
{
return true;
}
}
return false;
}
bool Component::isMoveable()
{
2018-07-15 18:21:05 +05:30
// HACK, FIXME: this was too dumb and wouldn't follow dependency constraints anyway. For now hardcoded to 'true'.
return true;
}
bool Component::isVersionChangeable()
{
2018-07-15 18:21:05 +05:30
auto list = getVersionList();
if(list)
{
if(!list->isLoaded())
{
list->load(Net::Mode::Online);
}
return list->count() != 0;
}
return false;
}
void Component::setImportant(bool state)
{
2018-07-15 18:21:05 +05:30
if(m_important != state)
{
m_important = state;
emit dataChanged();
}
}
ProblemSeverity Component::getProblemSeverity() const
{
2018-07-15 18:21:05 +05:30
auto file = getVersionFile();
if(file)
{
return file->getProblemSeverity();
}
return ProblemSeverity::Error;
}
const QList<PatchProblem> Component::getProblems() const
{
2018-07-15 18:21:05 +05:30
auto file = getVersionFile();
if(file)
{
return file->getProblems();
}
return {{ProblemSeverity::Error, QObject::tr("Patch is not loaded yet.")}};
}
void Component::setVersion(const QString& version)
{
2018-07-15 18:21:05 +05:30
if(version == m_version)
{
return;
}
m_version = version;
if(m_loaded)
{
// we are loaded and potentially have state to invalidate
if(m_file)
{
// we have a file... explicit version has been changed and there is nothing else to do.
}
else
{
// we don't have a file, therefore we are loaded with metadata
m_cachedVersion = version;
// see if the meta version is loaded
auto metaVersion = APPLICATION->metadataIndex()->get(m_uid, version);
2018-07-15 18:21:05 +05:30
if(metaVersion->isLoaded())
{
// if yes, we can continue with that.
m_metaVersion = metaVersion;
}
else
{
// if not, we need loading
m_metaVersion.reset();
m_loaded = false;
}
updateCachedData();
}
}
else
{
// not loaded... assume it will be sorted out later by the update task
}
emit dataChanged();
}
bool Component::customize()
{
2018-07-15 18:21:05 +05:30
if(isCustom())
{
return false;
}
2018-07-15 18:21:05 +05:30
auto filename = getFilename();
if(!FS::ensureFilePathExists(filename))
{
return false;
}
// FIXME: get rid of this try-catch.
try
{
QSaveFile jsonFile(filename);
if(!jsonFile.open(QIODevice::WriteOnly))
{
return false;
}
auto vfile = getVersionFile();
if(!vfile)
{
return false;
}
auto document = OneSixVersionFormat::versionFileToJson(vfile);
jsonFile.write(document.toJson());
if(!jsonFile.commit())
{
return false;
}
m_file = vfile;
m_metaVersion.reset();
emit dataChanged();
}
catch (const Exception &error)
{
qWarning() << "Version could not be loaded:" << error.cause();
}
return true;
}
bool Component::revert()
{
2018-07-15 18:21:05 +05:30
if(!isCustom())
{
// already not custom
return true;
}
auto filename = getFilename();
bool result = true;
// just kill the file and reload
if(QFile::exists(filename))
{
result = QFile::remove(filename);
}
if(result)
{
// file gone...
m_file.reset();
2018-07-15 18:21:05 +05:30
// check local cache for metadata...
auto version = APPLICATION->metadataIndex()->get(m_uid, m_version);
2018-07-15 18:21:05 +05:30
if(version->isLoaded())
{
m_metaVersion = version;
}
else
{
m_metaVersion.reset();
m_loaded = false;
}
emit dataChanged();
}
return result;
}
/**
* deep inspecting compare for requirement sets
* By default, only uids are compared for set operations.
* This compares all fields of the Require structs in the sets.
*/
static bool deepCompare(const std::set<Meta::Require> & a, const std::set<Meta::Require> & b)
{
2018-07-15 18:21:05 +05:30
// NOTE: this needs to be rewritten if the type of Meta::RequireSet changes
if(a.size() != b.size())
{
return false;
}
for(const auto & reqA :a)
{
const auto &iter2 = b.find(reqA);
if(iter2 == b.cend())
{
return false;
}
const auto & reqB = *iter2;
if(!reqA.deepEquals(reqB))
{
return false;
}
}
return true;
}
void Component::updateCachedData()
{
2018-07-15 18:21:05 +05:30
auto file = getVersionFile();
if(file)
{
bool changed = false;
if(m_cachedName != file->name)
{
m_cachedName = file->name;
changed = true;
}
if(m_cachedVersion != file->version)
{
m_cachedVersion = file->version;
changed = true;
}
if(m_cachedVolatile != file->m_volatile)
{
m_cachedVolatile = file->m_volatile;
changed = true;
}
if(!deepCompare(m_cachedRequires, file->requires))
{
m_cachedRequires = file->requires;
changed = true;
}
if(!deepCompare(m_cachedConflicts, file->conflicts))
{
m_cachedConflicts = file->conflicts;
changed = true;
}
if(changed)
{
emit dataChanged();
}
}
else
{
// in case we removed all the metadata
m_cachedRequires.clear();
m_cachedConflicts.clear();
emit dataChanged();
}
}