mirror of
https://github.com/swift-project/pilotclient.git
synced 2026-03-23 15:25:35 +08:00
2f0253b3eb
* this was recently discussed https://swift-project.slack.com/archives/C04J6J76N/p1508430536000065 * for config parser already implemented * for XP the loading from multiple dirs still needs to be implemented (see todo)
418 lines
20 KiB
C++
418 lines
20 KiB
C++
/* Copyright (C) 2015
|
|
* swift project Community / Contributors
|
|
*
|
|
* This file is part of swift project. It is subject to the license terms in the LICENSE file found in the top-level
|
|
* directory of this distribution and at http://www.swift-project.org/license.html. No part of swift project,
|
|
* including this file, may be copied, modified, propagated, or distributed except according to the terms
|
|
* contained in the LICENSE file.
|
|
*/
|
|
|
|
#include "blackcore/db/databaseutils.h"
|
|
#include "blackmisc/simulation/aircraftmodelutils.h"
|
|
#include "blackmisc/simulation/fscommon/aircraftcfgentries.h"
|
|
#include "blackmisc/simulation/fscommon/aircraftcfgparser.h"
|
|
#include "blackmisc/simulation/fscommon/fscommonutil.h"
|
|
#include "blackmisc/fileutils.h"
|
|
#include "blackmisc/logmessage.h"
|
|
#include "blackmisc/statusmessagelist.h"
|
|
#include "blackmisc/worker.h"
|
|
|
|
#include <QDateTime>
|
|
#include <QDir>
|
|
#include <QFile>
|
|
#include <QFileInfo>
|
|
#include <QFileInfoList>
|
|
#include <QFlags>
|
|
#include <QIODevice>
|
|
#include <QList>
|
|
#include <QMetaType>
|
|
#include <QSettings>
|
|
#include <QTextStream>
|
|
#include <Qt>
|
|
#include <QtGlobal>
|
|
#include <atomic>
|
|
#include <tuple>
|
|
|
|
using namespace BlackMisc;
|
|
using namespace BlackMisc::Simulation;
|
|
using namespace BlackMisc::Simulation::FsCommon;
|
|
using namespace BlackMisc::Network;
|
|
using namespace BlackCore::Db;
|
|
|
|
namespace BlackMisc
|
|
{
|
|
namespace Simulation
|
|
{
|
|
namespace FsCommon
|
|
{
|
|
// response for async. loading
|
|
using LoaderResponse = std::tuple<CAircraftCfgEntriesList, CAircraftModelList, BlackMisc::CStatusMessageList, bool>;
|
|
|
|
CAircraftCfgParser::CAircraftCfgParser(const CSimulatorInfo &simInfo) :
|
|
IAircraftModelLoader(simInfo)
|
|
{ }
|
|
|
|
std::unique_ptr<CAircraftCfgParser> CAircraftCfgParser::createModelLoader(const CSimulatorInfo &simInfo)
|
|
{
|
|
return std::make_unique<CAircraftCfgParser>(simInfo);
|
|
}
|
|
|
|
CAircraftCfgParser::~CAircraftCfgParser()
|
|
{
|
|
// that should be safe as long as the worker uses deleteLater (which it does)
|
|
if (m_parserWorker) { m_parserWorker->waitForFinished(); }
|
|
}
|
|
|
|
void CAircraftCfgParser::startLoadingFromDisk(LoadMode mode, const ModelConsolidation &modelConsolidation, const QStringList &modelDirectories)
|
|
{
|
|
static const CStatusMessage statusLoadingOk(this, CStatusMessage::SeverityInfo, "Aircraft config parser loaded data");
|
|
static const CStatusMessage statusLoadingError(this, CStatusMessage::SeverityError, "Aircraft config parser did not load data");
|
|
|
|
const CSimulatorInfo simulator = this->getSimulator();
|
|
const QStringList modelDirs = this->getInitializedModelDirectories(modelDirectories, simulator);
|
|
const QStringList excludedDirectoryPatterns(m_settings.getModelExcludeDirectoryPatternsOrDefault(simulator)); // copy
|
|
|
|
if (mode.testFlag(LoadInBackground))
|
|
{
|
|
if (m_parserWorker && !m_parserWorker->isFinished()) { return; }
|
|
m_parserWorker = BlackMisc::CWorker::fromTask(this, "CAircraftCfgParser::changeDirectory",
|
|
[this, modelDirs, excludedDirectoryPatterns, simulator, modelConsolidation]()
|
|
{
|
|
bool ok = false;
|
|
CStatusMessageList msgs;
|
|
const auto aircraftCfgEntriesList = this->performParsing(modelDirs, excludedDirectoryPatterns, msgs, &ok);
|
|
CAircraftModelList models;
|
|
if (ok)
|
|
{
|
|
models = aircraftCfgEntriesList.toAircraftModelList(simulator, true, msgs);
|
|
if (modelConsolidation) { modelConsolidation(models, true); }
|
|
}
|
|
return std::make_tuple(aircraftCfgEntriesList, models, msgs, ok);
|
|
});
|
|
m_parserWorker->thenWithResult<LoaderResponse>(this, [this, simulator](const LoaderResponse & tuple)
|
|
{
|
|
const bool ok = std::get<3>(tuple);
|
|
m_loadingMessages = std::get<2>(tuple);
|
|
if (ok)
|
|
{
|
|
m_parsedCfgEntriesList = std::get<0>(tuple);
|
|
const CAircraftModelList models(std::get<1>(tuple));
|
|
const bool hasData = !models.isEmpty();
|
|
if (hasData)
|
|
{
|
|
this->setCachedModels(models, simulator); // not thread safe
|
|
}
|
|
// currently I treat no data as error
|
|
emit this->loadingFinished(hasData ? statusLoadingOk : statusLoadingError, simulator, ParsedData);
|
|
}
|
|
else
|
|
{
|
|
CStatusMessage status = m_loadingMessages.toSingleMessage();
|
|
status.setSeverity(CStatusMessage::SeverityError);
|
|
emit this->loadingFinished(status, simulator, ParsedData);
|
|
}
|
|
});
|
|
}
|
|
else if (mode == LoadDirectly)
|
|
{
|
|
bool ok;
|
|
CStatusMessageList msgs;
|
|
m_parsedCfgEntriesList = performParsing(modelDirs, excludedDirectoryPatterns, msgs, &ok);
|
|
const CAircraftModelList models(m_parsedCfgEntriesList.toAircraftModelList(simulator, true, msgs));
|
|
m_loadingMessages = msgs;
|
|
const bool hasData = !models.isEmpty();
|
|
if (hasData)
|
|
{
|
|
this->setCachedModels(models);
|
|
}
|
|
// currently I treat no data as error
|
|
emit this->loadingFinished(hasData ? statusLoadingOk : statusLoadingError, simulator, ParsedData);
|
|
}
|
|
}
|
|
|
|
bool CAircraftCfgParser::isLoadingFinished() const
|
|
{
|
|
return !m_parserWorker || m_parserWorker->isFinished();
|
|
}
|
|
|
|
CAircraftCfgEntriesList CAircraftCfgParser::performParsing(const QStringList &directories, const QStringList &excludeDirectories, CStatusMessageList &messages, bool *ok)
|
|
{
|
|
CAircraftCfgEntriesList entries;
|
|
bool dirOk = false;
|
|
bool success = true;
|
|
for (const QString &dir : directories)
|
|
{
|
|
entries.push_back(performParsing(dir, excludeDirectories, messages, &dirOk));
|
|
success &= dirOk;
|
|
}
|
|
*ok = success;
|
|
return entries;
|
|
}
|
|
|
|
CAircraftCfgEntriesList CAircraftCfgParser::performParsing(const QString &directory, const QStringList &excludeDirectories, CStatusMessageList &messages, bool *ok)
|
|
{
|
|
//
|
|
// function has to be threadsafe
|
|
//
|
|
|
|
*ok = false;
|
|
if (m_cancelLoading) { return CAircraftCfgEntriesList(); }
|
|
|
|
// excluded?
|
|
if (CFileUtils::isExcludedDirectory(directory, excludeDirectories))
|
|
{
|
|
CLogMessage(this).debug() << "Skipping directory " << directory;
|
|
*ok = true;
|
|
return CAircraftCfgEntriesList();
|
|
}
|
|
|
|
// set directory with name filters, get aircraft.cfg and sub directories
|
|
const QDir dir(directory, fileFilter(), QDir::Name, QDir::Files | QDir::AllDirs | QDir::NoDotAndDotDot);
|
|
if (!dir.exists())
|
|
{
|
|
*ok = true;
|
|
return CAircraftCfgEntriesList(); // can happen if there are shortcuts or linked dirs not available
|
|
}
|
|
|
|
const QString currentDir = dir.absolutePath();
|
|
CAircraftCfgEntriesList result;
|
|
|
|
// Dirs last is crucial,since I will break recursion on "aircraft.cfg" level
|
|
const QFileInfoList files = dir.entryInfoList(QDir::Files | QDir::AllDirs | QDir::NoDotAndDotDot, QDir::DirsLast);
|
|
for (const auto &fileInfo : files)
|
|
{
|
|
if (m_cancelLoading) { return CAircraftCfgEntriesList(); }
|
|
if (fileInfo.isDir())
|
|
{
|
|
const QString nextDir = fileInfo.absoluteFilePath();
|
|
if (currentDir.startsWith(nextDir, Qt::CaseInsensitive)) { continue; } // do not go up
|
|
if (dir == currentDir) { continue; } // do not recursively call same directory
|
|
|
|
bool dirOk;
|
|
const CAircraftCfgEntriesList subList(performParsing(nextDir, excludeDirectories, messages, &dirOk));
|
|
if (dirOk)
|
|
{
|
|
result.push_back(subList);
|
|
}
|
|
else
|
|
{
|
|
CLogMessage(this).warning("Parsing failed for %1") << nextDir;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// due to the filter we expect only "aircraft.cfg" here
|
|
// remark: in a 1st version I have used QSettings to parse to file as ini file
|
|
// unfortunately some files are malformed which could end up in wrong data
|
|
|
|
const QString fileName = fileInfo.absoluteFilePath();
|
|
QFile file(fileName);
|
|
if (!file.open(QFile::ReadOnly | QFile::Text))
|
|
{
|
|
CLogMessage(this).warning("Unable to read file %1") << fileName;
|
|
continue;
|
|
}
|
|
QTextStream in(&file);
|
|
QList<CAircraftCfgEntries> tempEntries;
|
|
|
|
// parse through the file
|
|
QString atcType;
|
|
QString atcModel;
|
|
QString fltSection("[FLTSIM.0]");
|
|
int fltsimCounter = 0;
|
|
FileSection currentSection = Unknown;
|
|
bool isRotorcraftPath = fileName.contains("rotorcraft", Qt::CaseInsensitive);
|
|
|
|
while (!in.atEnd())
|
|
{
|
|
const QString lineFixed(in.readLine().trimmed());
|
|
if (lineFixed.isEmpty()) { continue; }
|
|
if (lineFixed.startsWith("["))
|
|
{
|
|
if (lineFixed.startsWith("[GENERAL]", Qt::CaseInsensitive)) { currentSection = General; continue; }
|
|
if (lineFixed.startsWith(fltSection, Qt::CaseInsensitive))
|
|
{
|
|
CAircraftCfgEntries e(fileName, fltsimCounter);
|
|
if (isRotorcraftPath)
|
|
{
|
|
e.setRotorcraft(true);
|
|
}
|
|
tempEntries.append(e);
|
|
currentSection = Fltsim;
|
|
fltSection = QString("[FLTSIM.%1]").arg(++fltsimCounter);
|
|
continue;
|
|
}
|
|
currentSection = Unknown;
|
|
continue;
|
|
}
|
|
switch (currentSection)
|
|
{
|
|
case General:
|
|
{
|
|
if (lineFixed.startsWith("//")) { break; }
|
|
if (atcType.isEmpty() || atcModel.isEmpty())
|
|
{
|
|
const QString c = getFixedIniLineContent(lineFixed);
|
|
if (lineFixed.startsWith("atc_type", Qt::CaseInsensitive))
|
|
{
|
|
atcType = c;
|
|
}
|
|
else if (lineFixed.startsWith("atc_model", Qt::CaseInsensitive))
|
|
{
|
|
atcModel = c;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case Fltsim:
|
|
{
|
|
if (lineFixed.startsWith("//")) { break; }
|
|
CAircraftCfgEntries &e = tempEntries[tempEntries.size() - 1];
|
|
if (lineFixed.startsWith("atc_", Qt::CaseInsensitive))
|
|
{
|
|
if (lineFixed.startsWith("atc_parking_codes", Qt::CaseInsensitive))
|
|
{
|
|
e.setAtcParkingCode(getFixedIniLineContent(lineFixed));
|
|
}
|
|
else if (lineFixed.startsWith("atc_airline", Qt::CaseInsensitive))
|
|
{
|
|
e.setAtcAirline(getFixedIniLineContent(lineFixed));
|
|
}
|
|
else if (lineFixed.startsWith("atc_id_color", Qt::CaseInsensitive))
|
|
{
|
|
e.setAtcIdColor(getFixedIniLineContent(lineFixed));
|
|
}
|
|
}
|
|
else if (lineFixed.startsWith("ui_", Qt::CaseInsensitive))
|
|
{
|
|
if (lineFixed.startsWith("ui_manufacturer", Qt::CaseInsensitive))
|
|
{
|
|
e.setUiManufacturer(getFixedIniLineContent(lineFixed));
|
|
}
|
|
else if (lineFixed.startsWith("ui_typerole", Qt::CaseInsensitive))
|
|
{
|
|
bool r = getFixedIniLineContent(lineFixed).toLower().contains("rotor");
|
|
e.setRotorcraft(r);
|
|
}
|
|
else if (lineFixed.startsWith("ui_type", Qt::CaseInsensitive))
|
|
{
|
|
e.setUiType(getFixedIniLineContent(lineFixed));
|
|
}
|
|
else if (lineFixed.startsWith("ui_variation", Qt::CaseInsensitive))
|
|
{
|
|
e.setUiVariation(getFixedIniLineContent(lineFixed));
|
|
}
|
|
}
|
|
else if (lineFixed.startsWith("description", Qt::CaseInsensitive))
|
|
{
|
|
e.setDescription(getFixedIniLineContent(lineFixed));
|
|
}
|
|
else if (lineFixed.startsWith("texture", Qt::CaseInsensitive))
|
|
{
|
|
e.setTexture(getFixedIniLineContent(lineFixed));
|
|
}
|
|
else if (lineFixed.startsWith("createdBy", Qt::CaseInsensitive))
|
|
{
|
|
e.setCreatedBy(getFixedIniLineContent(lineFixed));
|
|
}
|
|
else if (lineFixed.startsWith("sim", Qt::CaseInsensitive))
|
|
{
|
|
e.setSimName(getFixedIniLineContent(lineFixed));
|
|
}
|
|
else if (lineFixed.startsWith("title", Qt::CaseInsensitive))
|
|
{
|
|
e.setTitle(getFixedIniLineContent(lineFixed));
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
case Unknown: break;
|
|
}
|
|
} // all lines
|
|
file.close();
|
|
|
|
// store all entries
|
|
QDateTime fileTimestamp(fileInfo.lastModified());
|
|
if (!fileTimestamp.isValid() || fileInfo.created() > fileTimestamp)
|
|
{
|
|
fileTimestamp = fileInfo.created();
|
|
}
|
|
Q_ASSERT_X(fileTimestamp.isValid(), Q_FUNC_INFO, "Missing file timestamp");
|
|
for (const CAircraftCfgEntries &e : as_const(tempEntries))
|
|
{
|
|
if (e.getTitle().isEmpty())
|
|
{
|
|
CLogMessage(this).info("FS model in %1, index %2 has no title") << fileName << e.getIndex();
|
|
continue;
|
|
}
|
|
CAircraftCfgEntries newEntries(e);
|
|
newEntries.setAtcModel(atcModel);
|
|
newEntries.setAtcType(atcType);
|
|
newEntries.setUtcTimestamp(fileTimestamp);
|
|
result.push_back(newEntries);
|
|
}
|
|
*ok = true;
|
|
return result; // do not go any deeper in file tree, we found aircraft.cfg
|
|
}
|
|
}
|
|
|
|
// all files finished,
|
|
// normally reached when no aircraft.cfg is found
|
|
*ok = true;
|
|
return result;
|
|
}
|
|
|
|
QString CAircraftCfgParser::fixedStringContent(const QSettings &settings, const QString &key)
|
|
{
|
|
return fixedStringContent(settings.value(key));
|
|
}
|
|
|
|
QString CAircraftCfgParser::fixedStringContent(const QVariant &qv)
|
|
{
|
|
if (qv.isNull() || !qv.isValid())
|
|
{
|
|
return ""; // normal when there is no settings value
|
|
}
|
|
else if (static_cast<QMetaType::Type>(qv.type()) == QMetaType::QStringList)
|
|
{
|
|
const QStringList l = qv.toStringList();
|
|
return l.join(",").trimmed();
|
|
}
|
|
else if (static_cast<QMetaType::Type>(qv.type()) == QMetaType::QString)
|
|
{
|
|
return qv.toString().trimmed();
|
|
}
|
|
Q_ASSERT(false);
|
|
return "";
|
|
}
|
|
|
|
QString CAircraftCfgParser::getFixedIniLineContent(const QString &line)
|
|
{
|
|
if (line.isEmpty()) { return ""; }
|
|
int index = line.indexOf('=');
|
|
if (index < 0) { return ""; }
|
|
if (line.length() < index + 1) { return ""; }
|
|
|
|
QString content(line.midRef(index + 1).trimmed().toString());
|
|
|
|
// fix "" strings, some are malformed and just contain " at beginning, not at the end
|
|
if (content.endsWith('"')) { content.remove(content.size() - 1 , 1); }
|
|
if (content.startsWith('"')) { content.remove(0 , 1); }
|
|
|
|
// fix C style linebreaks
|
|
content.replace("\\n", " ");
|
|
content.replace("\\t", " ");
|
|
return content;
|
|
}
|
|
|
|
const QString &CAircraftCfgParser::fileFilter()
|
|
{
|
|
static const QString f("aircraft.cfg");
|
|
return f;
|
|
}
|
|
} // ns
|
|
} // ns
|
|
} // ns
|
|
|
|
Q_DECLARE_METATYPE(BlackMisc::Simulation::FsCommon::LoaderResponse)
|