mirror of
https://github.com/swift-project/pilotclient.git
synced 2026-04-03 07:35:48 +08:00
933271b828
* Include only what is used * Use forward declaration when possible * Sorted includes refs #598
543 lines
23 KiB
C++
543 lines
23 KiB
C++
/* Copyright (C) 2013
|
|
* 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/aircraftmatcher.h"
|
|
#include "blackcore/application.h"
|
|
#include "blackcore/webdataservices.h"
|
|
#include "blackmisc/aviation/aircrafticaocode.h"
|
|
#include "blackmisc/aviation/airlineicaocode.h"
|
|
#include "blackmisc/aviation/callsign.h"
|
|
#include "blackmisc/aviation/livery.h"
|
|
#include "blackmisc/logcategory.h"
|
|
#include "blackmisc/logcategorylist.h"
|
|
#include "blackmisc/logmessage.h"
|
|
#include "blackmisc/simulation/simulatedaircraft.h"
|
|
#include "blackmisc/statusmessagelist.h"
|
|
|
|
#include <QList>
|
|
#include <QStringList>
|
|
#include <QtGlobal>
|
|
|
|
using namespace BlackMisc;
|
|
using namespace BlackMisc::Simulation;
|
|
using namespace BlackMisc::Network;
|
|
using namespace BlackMisc::Aviation;
|
|
using namespace BlackCore;
|
|
|
|
namespace BlackCore
|
|
{
|
|
const CLogCategoryList &CAircraftMatcher::getLogCategories()
|
|
{
|
|
static const BlackMisc::CLogCategoryList cats { BlackMisc::CLogCategory::matching() };
|
|
return cats;
|
|
}
|
|
|
|
CAircraftMatcher::CAircraftMatcher(MatchingMode matchingMode, QObject *parent) :
|
|
QObject(parent),
|
|
m_matchingMode(matchingMode)
|
|
{ }
|
|
|
|
CAircraftMatcher::~CAircraftMatcher()
|
|
{ }
|
|
|
|
CAircraftModel CAircraftMatcher::getClosestMatch(const CSimulatedAircraft &remoteAircraft, CStatusMessageList *log) const
|
|
{
|
|
CAircraftModelList matchedModels(this->m_modelSet); // Models for this matching
|
|
const MatchingMode mode = this->m_matchingMode;
|
|
|
|
// Manually set string?
|
|
if (remoteAircraft.getModel().hasManuallySetString())
|
|
{
|
|
// the user did a manual mapping "by hand", so he really should know what he is doing
|
|
// no matching
|
|
logDetails(log, remoteAircraft, "Manually set model " + remoteAircraft.getModelString());
|
|
return remoteAircraft.getModel();
|
|
}
|
|
|
|
CAircraftModel matchedModel(remoteAircraft.getModel());
|
|
if (matchedModels.isEmpty())
|
|
{
|
|
logDetails(log, remoteAircraft, "No models for matching, using default", CStatusMessage::SeverityError);
|
|
matchedModel = this->getDefaultModel();
|
|
matchedModel.setCallsign(remoteAircraft.getCallsign());
|
|
return matchedModel;
|
|
}
|
|
|
|
do
|
|
{
|
|
if (matchedModels.isEmpty())
|
|
{
|
|
logDetails(log, remoteAircraft, "No models for matching, using default", CStatusMessage::SeverityWarning);
|
|
matchedModel = this->getDefaultModel();
|
|
break;
|
|
}
|
|
|
|
// try to find in installed models by model string
|
|
if (mode.testFlag(ByModelString))
|
|
{
|
|
matchedModel = matchByExactModelString(remoteAircraft, matchedModels, log);
|
|
if (matchedModel.hasModelString()) { break; }
|
|
}
|
|
else if (log)
|
|
{
|
|
logDetails(log, remoteAircraft, "Skipping model string match");
|
|
}
|
|
|
|
// primary reduction
|
|
bool reduced = false;
|
|
do
|
|
{
|
|
// by livery, then by ICAO
|
|
if (mode.testFlag(ByLivery))
|
|
{
|
|
matchedModels = ifPossibleReduceByLiveryAndIcaoCode(remoteAircraft, matchedModels, reduced, log);
|
|
if (reduced) { break; }
|
|
}
|
|
else if (log)
|
|
{
|
|
logDetails(log, remoteAircraft, "Skipping livery reduction");
|
|
}
|
|
|
|
// by ICAO data from set
|
|
if (mode.testFlag(ByIcaoData))
|
|
{
|
|
// if already matched by livery skip
|
|
matchedModels = ifPossibleReduceByIcaoData(remoteAircraft, matchedModels, false, reduced, log);
|
|
if (reduced) { break; }
|
|
}
|
|
else if (log)
|
|
{
|
|
logDetails(log, remoteAircraft, "Skipping ICAO reduction");
|
|
}
|
|
|
|
// family
|
|
if (mode.testFlag(ByFamily))
|
|
{
|
|
QString family = remoteAircraft.getAircraftIcaoCode().getFamily();
|
|
matchedModels = ifPossibleReduceByFamily(remoteAircraft, family, matchedModels, "real family", reduced, log);
|
|
if (reduced) { break; }
|
|
|
|
// scenario: the ICAO actually is the family
|
|
family = remoteAircraft.getAircraftIcaoCodeDesignator();
|
|
matchedModels = ifPossibleReduceByFamily(remoteAircraft, family, matchedModels, "ICAO treated as family", reduced, log);
|
|
if (reduced) { break; }
|
|
}
|
|
else if (log)
|
|
{
|
|
logDetails(log, remoteAircraft, "Skipping family match");
|
|
}
|
|
|
|
// combined code
|
|
if (mode.testFlag(ByCombinedCode))
|
|
{
|
|
matchedModels = ifPossibleReduceByCombinedCode(remoteAircraft, matchedModels, true, reduced, log);
|
|
if (reduced) { break; }
|
|
}
|
|
else if (log)
|
|
{
|
|
logDetails(log, remoteAircraft, "Skipping combined code match");
|
|
}
|
|
}
|
|
while (false);
|
|
|
|
// here we have a list of possible models, we reduce/refine further
|
|
bool military = remoteAircraft.getModel().isMilitary();
|
|
matchedModels = ifPossibleReduceByManufacturer(remoteAircraft, matchedModels, "2nd pass", reduced, log);
|
|
matchedModels = ifPossibleReduceByMilitaryFlag(remoteAircraft, military, matchedModels, reduced, log);
|
|
|
|
// expect first to be the right one in order
|
|
matchedModel = matchedModels.isEmpty() ? getDefaultModel() : matchedModels.front();
|
|
}
|
|
while (false);
|
|
|
|
// copy over callsign and other data
|
|
matchedModel.setCallsign(remoteAircraft.getCallsign());
|
|
|
|
Q_ASSERT_X(!matchedModel.getCallsign().isEmpty(), Q_FUNC_INFO, "Missing callsign");
|
|
Q_ASSERT_X(matchedModel.hasModelString(), Q_FUNC_INFO, "Missing model string");
|
|
Q_ASSERT_X(matchedModel.getModelType() != CAircraftModel::TypeUnknown, Q_FUNC_INFO, "Missing model type");
|
|
|
|
return matchedModel;
|
|
}
|
|
|
|
CAircraftModel CAircraftMatcher::reverseLookup(const CAircraftModel &modelToLookup, const QString &liveryInfo, CStatusMessageList *log)
|
|
{
|
|
CAircraftModel model(modelToLookup);
|
|
const CCallsign callsign(model.getCallsign());
|
|
const QStringList liveryModelStrings = CAircraftModel::splitNetworkLiveryString(liveryInfo);
|
|
const QString modelString(modelToLookup.hasModelString() ? modelToLookup.getModelString() : liveryModelStrings[1]);
|
|
QString liveryCode(liveryModelStrings[0]);
|
|
|
|
if (!modelString.isEmpty())
|
|
{
|
|
// if we find the model here we have a fully defined DB model
|
|
const CAircraftModel modelFromDb(sApp->getWebDataServices()->getModelForModelString(modelString));
|
|
if (modelFromDb.hasValidDbKey())
|
|
{
|
|
model = modelFromDb;
|
|
if (log) { logDetails(log, callsign, QString("Reverse looked up DB model `%1` for %2").arg(modelFromDb.getDbKey()).arg(callsign.toQString())); }
|
|
}
|
|
else
|
|
{
|
|
if (log) { logDetails(log, callsign, QString("Reverse looked, not found model for `%1`").arg(modelString)); }
|
|
}
|
|
}
|
|
|
|
// only if not yet matched with DB
|
|
const QString aircraftIcaoDesignator(model.getAircraftIcaoCodeDesignator());
|
|
const QString airlineIcaoDesignator(model.getAirlineIcaoCodeDesignator());
|
|
if (!model.hasValidDbKey())
|
|
{
|
|
// try to match by livery
|
|
if (liveryCode.isEmpty() && !airlineIcaoDesignator.isEmpty())
|
|
{
|
|
// we create a standard livery code, then we try to find based on this
|
|
liveryCode = CLivery::getStandardCode(model.getAirlineIcaoCode());
|
|
}
|
|
|
|
if (CLivery::isValidCombinedCode(liveryCode))
|
|
{
|
|
// search DB model by livery
|
|
const CAircraftModelList models(sApp->getWebDataServices()->getModelsForAircraftDesignatorAndLiveryCombinedCode(aircraftIcaoDesignator, liveryCode));
|
|
if (models.isEmpty())
|
|
{
|
|
// no models for that livery, search for livery only
|
|
const CLivery databaseLivery(sApp->getWebDataServices()->getLiveryForCombinedCode(liveryCode));
|
|
if (databaseLivery.hasValidDbKey())
|
|
{
|
|
// we have found a livery in the DB
|
|
model.setLivery(databaseLivery);
|
|
if (log) { logDetails(log, callsign, QString("Reverse lookup, set livery `%1`").arg(databaseLivery.getCombinedCodePlusInfo())); }
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// model by livery data found
|
|
model = models.front();
|
|
if (log) { logDetails(log, callsign, QString("Reverse lookup, DB model `%1` for %2/%3, found %4").arg(model.getDbKey()).arg(aircraftIcaoDesignator).arg(liveryCode).arg(models.size())); }
|
|
}
|
|
}
|
|
|
|
// if no DB livery, create own dummy livery
|
|
if (!model.hasValidDbKey() && !model.getLivery().hasValidDbKey())
|
|
{
|
|
// create a pseudo livery, try to find airline first
|
|
CAirlineIcaoCode airlineIcao(sApp->getWebDataServices()->smartAirlineIcaoSelector(CAirlineIcaoCode(airlineIcaoDesignator)));
|
|
if (!airlineIcao.hasValidDbKey())
|
|
{
|
|
// no DB data, we update as much as possible
|
|
airlineIcao = model.getAirlineIcaoCode();
|
|
airlineIcao.updateMissingParts(CAirlineIcaoCode(airlineIcaoDesignator));
|
|
}
|
|
if (!airlineIcaoDesignator.isEmpty())
|
|
{
|
|
const CLivery liveryDummy(CLivery::getStandardCode(airlineIcao), airlineIcao, "Generated");
|
|
model.setLivery(liveryDummy);
|
|
if (log) { logDetails(log, callsign, QString("Reverse lookup, set dummy livery `%1`").arg(liveryDummy.getCombinedCodePlusInfo())); }
|
|
}
|
|
}
|
|
|
|
if (!model.getAircraftIcaoCode().hasValidDbKey())
|
|
{
|
|
CAircraftIcaoCode aircraftIcao(sApp->getWebDataServices()->getAircraftIcaoCodeForDesignator(aircraftIcaoDesignator));
|
|
if (!aircraftIcao.hasValidDbKey())
|
|
{
|
|
// no DB data, we update as much as possible
|
|
aircraftIcao = model.getAircraftIcaoCode();
|
|
aircraftIcao.updateMissingParts(CAircraftIcaoCode(aircraftIcaoDesignator));
|
|
if (log) { logDetails(log, callsign, QString("Reverse lookup, aircraft `%1` not found in DB").arg(aircraftIcaoDesignator)); }
|
|
}
|
|
model.setAircraftIcaoCode(aircraftIcao);
|
|
if (log) { logDetails(log, callsign, QString("Reverse lookup, set aircraft `%1`").arg(aircraftIcao.getCombinedIcaoStringWithKey())); }
|
|
}
|
|
} // model from DB
|
|
|
|
if (model.getModelType() != CAircraftModel::TypeUnknown) { model.setModelType(modelToLookup.getModelType()); }
|
|
model.setCallsign(modelToLookup.getCallsign());
|
|
return model;
|
|
}
|
|
|
|
int CAircraftMatcher::setModelSet(const CAircraftModelList &models)
|
|
{
|
|
CAircraftModelList modelsCleaned(models);
|
|
int r1 = modelsCleaned.removeAllWithoutModelString();
|
|
int r2 = modelsCleaned.removeIfExcluded();
|
|
if ((r1 + r2) > 0)
|
|
{
|
|
CLogMessage(this).warning("Removed models for matcher, without string %1, excluded %2") << r1 << r2;
|
|
}
|
|
if (modelsCleaned.isEmpty())
|
|
{
|
|
CLogMessage(this).error("No models for matching, that will not work");
|
|
}
|
|
else
|
|
{
|
|
CLogMessage(this).info("Set %1 models in matcher") << modelsCleaned.size();
|
|
}
|
|
this->m_modelSet = modelsCleaned;
|
|
return models.size();
|
|
}
|
|
|
|
const CAircraftModel &CAircraftMatcher::getDefaultModel() const
|
|
{
|
|
return m_defaultModel;
|
|
}
|
|
|
|
void CAircraftMatcher::setDefaultModel(const BlackMisc::Simulation::CAircraftModel &defaultModel)
|
|
{
|
|
m_defaultModel = defaultModel;
|
|
m_defaultModel.setModelType(CAircraftModel::TypeModelMatchingDefaultModel);
|
|
}
|
|
|
|
CAircraftModel CAircraftMatcher::matchByExactModelString(const CSimulatedAircraft &remoteAircraft, const CAircraftModelList &models, CStatusMessageList *log)
|
|
{
|
|
if (remoteAircraft.getModelString().isEmpty())
|
|
{
|
|
if (log) { logDetails(log, remoteAircraft, "No model string, no exact match possible"); }
|
|
return CAircraftModel();
|
|
}
|
|
|
|
CAircraftModel model = models.findFirstByModelStringOrDefault(remoteAircraft.getModelString());
|
|
if (log)
|
|
{
|
|
if (model.hasModelString())
|
|
{
|
|
logDetails(log, remoteAircraft, "Found exact match for " + model.getModelString());
|
|
}
|
|
else
|
|
{
|
|
logDetails(log, remoteAircraft, "No exact match for " + model.getModelString());
|
|
}
|
|
}
|
|
model.setModelType(CAircraftModel::TypeModelMatching);
|
|
model.setCallsign(remoteAircraft.getCallsign());
|
|
return model;
|
|
}
|
|
|
|
CAircraftModelList CAircraftMatcher::ifPossibleReduceByLiveryAndIcaoCode(const CSimulatedAircraft &remoteAircraft, const CAircraftModelList &inList, bool &reduced, CStatusMessageList *log)
|
|
{
|
|
reduced = false;
|
|
if (!remoteAircraft.getLivery().hasCombinedCode())
|
|
{
|
|
if (log) { logDetails(log, remoteAircraft, "No livery code, no reduction possible"); }
|
|
return inList;
|
|
}
|
|
|
|
const CAircraftModelList byLivery(
|
|
inList.findByAircraftDesignatorAndLiveryCombinedCode(
|
|
remoteAircraft.getLivery().getCombinedCode(),
|
|
remoteAircraft.getAircraftIcaoCodeDesignator()
|
|
));
|
|
|
|
if (byLivery.isEmpty())
|
|
{
|
|
if (log) { logDetails(log, remoteAircraft, "Not found by livery code " + remoteAircraft.getLivery().getCombinedCode()); }
|
|
return inList;
|
|
}
|
|
reduced = true;
|
|
return byLivery;
|
|
}
|
|
|
|
CAircraftModelList CAircraftMatcher::ifPossibleReduceByIcaoData(const CSimulatedAircraft &remoteAircraft, const CAircraftModelList &inList, bool ignoreAirline, bool &reduced, CStatusMessageList *log)
|
|
{
|
|
reduced = false;
|
|
if (!remoteAircraft.hasAircraftDesignator())
|
|
{
|
|
if (log) { logDetails(log, remoteAircraft, "No aircraft designator, skipping step"); }
|
|
return inList;
|
|
}
|
|
|
|
BlackMisc::Simulation::CAircraftModelList searchModels(inList.findByIcaoDesignators(
|
|
remoteAircraft.getAircraftIcaoCode(),
|
|
ignoreAirline ? CAirlineIcaoCode() : remoteAircraft.getAirlineIcaoCode()));
|
|
|
|
if (!searchModels.isEmpty())
|
|
{
|
|
if (log)
|
|
{
|
|
logDetails(log, remoteAircraft,
|
|
"Possible aircraft " + QString::number(searchModels.size()) +
|
|
", found by ICAO " + remoteAircraft.getAircraftIcaoCodeDesignator() + " " +
|
|
(ignoreAirline ? "" : remoteAircraft.getAirlineIcaoCodeDesignator()));
|
|
}
|
|
reduced = true;
|
|
return searchModels;
|
|
}
|
|
else
|
|
{
|
|
if (!ignoreAirline && remoteAircraft.hasAircraftAndAirlineDesignator())
|
|
{
|
|
// we have searched by aircraft and airline, but not found anything
|
|
if (log)
|
|
{
|
|
logDetails(log, remoteAircraft,
|
|
"Not found by ICAO " +
|
|
remoteAircraft.getAircraftIcaoCodeDesignator() + " " + remoteAircraft.getAirlineIcaoCodeDesignator() +
|
|
" relaxing to only ICAO " + remoteAircraft.getAircraftIcaoCodeDesignator());
|
|
}
|
|
// recursive lookup by ignoring airline
|
|
return ifPossibleReduceByIcaoData(remoteAircraft, inList, true, reduced, log);
|
|
}
|
|
if (log) { logDetails(log, remoteAircraft, "Not found by ICAO " + remoteAircraft.getAircraftIcaoCodeDesignator() + " " + remoteAircraft.getAirlineIcaoCodeDesignator()); }
|
|
}
|
|
return inList;
|
|
}
|
|
|
|
CAircraftModelList CAircraftMatcher::ifPossibleReduceByFamily(const CSimulatedAircraft &remoteAircraft, const QString &family, const CAircraftModelList &inList, const QString &hint, bool &reduced, CStatusMessageList *log)
|
|
{
|
|
// Use an algorithm to find the best match
|
|
reduced = true;
|
|
if (family.isEmpty())
|
|
{
|
|
if (log) { logDetails(log, remoteAircraft, "No family, skipping step (" + hint + ")"); }
|
|
return inList;
|
|
}
|
|
if (inList.isEmpty())
|
|
{
|
|
if (log) { logDetails(log, remoteAircraft, "No models for family match (" + hint + ")"); }
|
|
return inList;
|
|
}
|
|
|
|
CAircraftModelList found(inList.findByFamily(family));
|
|
if (found.isEmpty())
|
|
{
|
|
if (log) { logDetails(log, remoteAircraft, "Not found by family " + family + " (" + hint + ")"); }
|
|
return inList;
|
|
}
|
|
|
|
reduced = true;
|
|
logDetails(log, remoteAircraft, "Found by family " + family + " (" + hint + ") size " + QString::number(found.size()));
|
|
return found;
|
|
}
|
|
|
|
CAircraftModelList CAircraftMatcher::ifPossibleReduceByManufacturer(const CSimulatedAircraft &remoteAircraft, const CAircraftModelList &inList, const QString &info, bool &reduced, CStatusMessageList *log)
|
|
{
|
|
reduced = false;
|
|
if (inList.isEmpty())
|
|
{
|
|
if (log) { logDetails(log , remoteAircraft, info + " " + "Empty input list, cannot reduce"); }
|
|
return inList;
|
|
}
|
|
|
|
const QString m = remoteAircraft.getAircraftIcaoCode().getManufacturer();
|
|
if (m.isEmpty())
|
|
{
|
|
if (log) { logDetails(log , remoteAircraft, info + " No manufacturer, cannot reduce " + QString::number(inList.size()) + " entries"); }
|
|
return inList;
|
|
}
|
|
|
|
const CAircraftModelList outList(inList.findByManunfacturer(m));
|
|
if (outList.isEmpty())
|
|
{
|
|
if (log) { logDetails(log , remoteAircraft, info + " Not found " + m + ", cannot reduce"); }
|
|
return inList;
|
|
}
|
|
|
|
if (log) { logDetails(log , remoteAircraft, info + " Reduced by " + m + " results: " + QString::number(outList.size())); }
|
|
reduced = true;
|
|
return outList;
|
|
}
|
|
|
|
CAircraftModelList CAircraftMatcher::ifPossibleReduceByAirline(const CSimulatedAircraft &remoteAircraft, const CAircraftModelList &inList, const QString &info, bool &reduced, CStatusMessageList *log)
|
|
{
|
|
reduced = false;
|
|
if (inList.isEmpty())
|
|
{
|
|
if (log) { logDetails(log , remoteAircraft, info + " " + "Empty input list, cannot reduce"); }
|
|
return inList;
|
|
}
|
|
|
|
if (!remoteAircraft.hasAirlineDesignator())
|
|
{
|
|
if (log) { logDetails(log , remoteAircraft, info + " " + "No airline, cannot reduce " + QString::number(inList.size()) + " entries"); }
|
|
return inList;
|
|
}
|
|
|
|
const CAircraftModelList outList(inList.findByIcaoDesignators(CAircraftIcaoCode(), remoteAircraft.getAirlineIcaoCode()));
|
|
if (outList.isEmpty())
|
|
{
|
|
if (log) { logDetails(log , remoteAircraft, info + " Cannot reduce by " + remoteAircraft.getAirlineIcaoCodeDesignator() + " results: " + QString::number(outList.size())); }
|
|
return inList;
|
|
}
|
|
|
|
if (log) { logDetails(log , remoteAircraft, info + " Reduced reduce by " + remoteAircraft.getAirlineIcaoCodeDesignator() + " to " + QString::number(outList.size())); }
|
|
reduced = true;
|
|
return outList;
|
|
}
|
|
|
|
CAircraftModelList CAircraftMatcher::ifPossibleReduceByCombinedCode(const CSimulatedAircraft &remoteAircraft, const CAircraftModelList &inList, bool relaxIfNotFound, bool &reduced, CStatusMessageList *log)
|
|
{
|
|
reduced = false;
|
|
if (!remoteAircraft.getAircraftIcaoCode().hasValidCombinedType())
|
|
{
|
|
if (log) { logDetails(log, remoteAircraft, "No valid combined code"); }
|
|
return inList;
|
|
}
|
|
|
|
const QString cc = remoteAircraft.getAircraftIcaoCode().getCombinedType();
|
|
CAircraftModelList byCombinedCode(inList.findByCombinedCode(cc));
|
|
if (byCombinedCode.isEmpty())
|
|
{
|
|
if (log) { logDetails(log, remoteAircraft, "Not found by combined code " + cc); }
|
|
if (relaxIfNotFound)
|
|
{
|
|
|
|
}
|
|
return inList;
|
|
}
|
|
|
|
if (log) { logDetails(log, remoteAircraft, "Found by combined code " + cc + ", possible " + QString::number(byCombinedCode.size())); }
|
|
if (byCombinedCode.size() > 1)
|
|
{
|
|
byCombinedCode = ifPossibleReduceByAirline(remoteAircraft, byCombinedCode, "Combined code", reduced, log);
|
|
byCombinedCode = ifPossibleReduceByManufacturer(remoteAircraft, byCombinedCode, "Combined code", reduced, log);
|
|
reduced = true;
|
|
}
|
|
return byCombinedCode;
|
|
}
|
|
|
|
CAircraftModelList CAircraftMatcher::ifPossibleReduceByMilitaryFlag(const BlackMisc::Simulation::CSimulatedAircraft &remoteAircraft, bool military, const CAircraftModelList &inList, bool &reduced, CStatusMessageList *log)
|
|
{
|
|
reduced = false;
|
|
CAircraftModelList byMilitaryFlag(inList.findByMilitaryFlag(military));
|
|
const QString mil(military ? "military" : "civilian");
|
|
if (byMilitaryFlag.isEmpty())
|
|
{
|
|
if (log) { logDetails(log, remoteAircraft, "Not found by " + mil); }
|
|
return inList;
|
|
}
|
|
|
|
if (log)
|
|
{
|
|
if (inList.size() > byMilitaryFlag.size())
|
|
{
|
|
logDetails(log, remoteAircraft, "Reduced to " + mil + " aircraft, size " + QString::number(byMilitaryFlag.size()));
|
|
}
|
|
else
|
|
{
|
|
logDetails(log, remoteAircraft, "Not reduced by " + mil + ", size " + QString::number(byMilitaryFlag.size()));
|
|
}
|
|
}
|
|
return byMilitaryFlag;
|
|
}
|
|
|
|
void CAircraftMatcher::logDetails(CStatusMessageList *log, const CSimulatedAircraft &remoteAircraft, const QString &message, CStatusMessage::StatusSeverity s)
|
|
{
|
|
logDetails(log, remoteAircraft.getCallsign(), message, s);
|
|
}
|
|
|
|
void CAircraftMatcher::logDetails(CStatusMessageList *log, const CCallsign &callsign, const QString &message, CStatusMessage::StatusSeverity s)
|
|
{
|
|
if (!log) { return; }
|
|
if (message.isEmpty()) { return; }
|
|
const CStatusMessage m(getLogCategories(), s, callsign.isEmpty() ? callsign.toQString() + ": " + message.trimmed() : message.trimmed());
|
|
log->push_back(m);
|
|
}
|
|
} // namespace
|