623 lines
23 KiB
C++
Executable File
623 lines
23 KiB
C++
Executable File
/**
|
|
* Handler for all oc situation data at the client
|
|
* $Id: handler_oc_situation_data.cpp 57655 2022-07-20 11:38:28Z karwat $
|
|
* $HeadURL: svn://192.168.133.21/TDS/branches/product/features/3dws_devel/Lts/Services/OcSituationClient/handler_oc_situation_data.cpp $
|
|
* $Author: karwat $
|
|
* Created by Philipp Dassow, NLST, 01-03-2018
|
|
*/
|
|
|
|
#include "handler_oc_central_aes_data.h"
|
|
|
|
#include <QLineF>
|
|
#include <QPointF>
|
|
#include <QTimer>
|
|
#include <Common/LtsCoordTrans/lts_coord_trans.h>
|
|
#include <LtsUtilsCore/qbytearray_byteaccess.h>
|
|
|
|
#include "central_aes_byte_reader.h"
|
|
#include "main_handler.h"
|
|
#include "settings.h"
|
|
|
|
namespace OcSituationClient
|
|
{
|
|
|
|
HandlerOcCentralAesData::HandlerOcCentralAesData(const std::shared_ptr<AreaEffectSimulation::Interface::Dtc> &aesDtc,
|
|
const std::shared_ptr<AreaEffectSimulation::Interface::Ftc> &aesFtc,
|
|
const std::shared_ptr<TrainingAreaBaseOC::Interface::Dts> &tabocDts,
|
|
QObject *parent)
|
|
: QObject(parent), m_aesDtc(aesDtc), m_aesFtc(aesFtc), m_tabocDts(tabocDts), m_logger(getLogger("HandlerOcCentralAesData"))
|
|
{
|
|
}
|
|
|
|
HandlerOcCentralAesData::~HandlerOcCentralAesData() {}
|
|
|
|
bool HandlerOcCentralAesData::init()
|
|
{
|
|
// AES DTC enable
|
|
if (!m_aesDtc->enableNContamination() || !m_aesDtc->enableBCContamination() || !m_aesDtc->enableExplosionArea() || !m_aesDtc->enableExplosionSingle()
|
|
|| !m_aesDtc->enableMineArea() || !m_aesDtc->enableFunctionalArea() || !m_aesDtc->enableBoobyTrap() || !m_aesDtc->enableOffRouteMine()
|
|
|| !m_aesDtc->enableExplosionCluster())
|
|
{
|
|
ERROR_LOG(m_logger) << "Enabling AES Data-Topics failed.";
|
|
return false;
|
|
}
|
|
|
|
// AES FTC enable
|
|
if (!m_aesFtc->enableNContaminationModify() || !m_aesFtc->enableNContaminationRemove() || !m_aesFtc->enableBCContaminationModify()
|
|
|| !m_aesFtc->enableBCContaminationRemove() || !m_aesFtc->enableExplosionAreaModify() || !m_aesFtc->enableExplosionAreaRemove()
|
|
|| !m_aesFtc->enableExplosionSingleModify() || !m_aesFtc->enableExplosionSingleRemove() || !m_aesFtc->enableMineAreaModify() || !m_aesFtc->enableMineAreaRemove()
|
|
|| !m_aesFtc->enableFunctionalAreaModify() || !m_aesFtc->enableFunctionalAreaRemove() || !m_aesFtc->enableBoobyTrapModify() || !m_aesFtc->enableBoobyTrapRemove()
|
|
|| !m_aesFtc->enableOffRouteMineModify() || !m_aesFtc->enableOffRouteMineRemove() || !m_aesFtc->enableExplosionClusterOcModify()
|
|
|| !m_aesFtc->enableExplosionClusterRemove() || !m_aesFtc->enableMineAreaReferenceModify())
|
|
{
|
|
ERROR_LOG(m_logger) << "Enabling AES Function-Topics failed.";
|
|
return false;
|
|
}
|
|
|
|
// TABOC DTS enable
|
|
if (!m_tabocDts->enableCentralAesOverload())
|
|
{
|
|
ERROR_LOG(m_logger) << "Enabling TABOC Data-Topics failed.";
|
|
return false;
|
|
}
|
|
|
|
m_aesDtc->nContaminations(
|
|
[this](const AreaEffectSimulation::NContamination &data)
|
|
{
|
|
if (!data.isCentral())
|
|
return;
|
|
|
|
m_allCentralAesItems.insert(data.id(), AreaEffectSimulation::AesType::AtNContamination);
|
|
});
|
|
|
|
m_aesDtc->bCContaminations(
|
|
[this](const AreaEffectSimulation::BCContamination &data)
|
|
{
|
|
if (!data.isCentral())
|
|
return;
|
|
|
|
m_allCentralAesItems.insert(data.id(), AreaEffectSimulation::AesType::AtBCContamination);
|
|
});
|
|
|
|
m_aesDtc->explosionAreas(
|
|
[this](const AreaEffectSimulation::ExplosionArea &data)
|
|
{
|
|
if (!data.isCentral())
|
|
return;
|
|
|
|
m_allCentralAesItems.insert(data.id(), AreaEffectSimulation::AesType::AtExplosionArea);
|
|
});
|
|
|
|
m_aesDtc->explosionSingles(
|
|
[this](const AreaEffectSimulation::ExplosionSingle &data)
|
|
{
|
|
if (!data.isCentral())
|
|
return;
|
|
|
|
m_allCentralAesItems.insert(data.id(), AreaEffectSimulation::AesType::AtExplosionSingle);
|
|
});
|
|
|
|
m_aesDtc->mineAreas(
|
|
[this](const AreaEffectSimulation::MineArea &data)
|
|
{
|
|
if (!data.isCentral())
|
|
return;
|
|
|
|
m_allCentralAesItems.insert(data.id(), AreaEffectSimulation::AesType::AtMineArea);
|
|
});
|
|
|
|
m_aesDtc->functionalAreas(
|
|
[this](const AreaEffectSimulation::FunctionalArea &data)
|
|
{
|
|
if (!data.isCentral())
|
|
return;
|
|
|
|
m_allCentralAesItems.insert(data.id(), AreaEffectSimulation::AesType::AtFunctionalArea);
|
|
});
|
|
|
|
m_aesDtc->boobyTraps(
|
|
[this](const AreaEffectSimulation::BoobyTrap &data)
|
|
{
|
|
if (!data.isCentral())
|
|
return;
|
|
|
|
m_allCentralAesItems.insert(data.id(), AreaEffectSimulation::AesType::AtBoobyTrap);
|
|
});
|
|
|
|
m_aesDtc->offRouteMines(
|
|
[this](const AreaEffectSimulation::OffRouteMine &data)
|
|
{
|
|
if (!data.isCentral())
|
|
return;
|
|
|
|
m_allCentralAesItems.insert(data.id(), AreaEffectSimulation::AesType::AtOffRouteMine);
|
|
});
|
|
|
|
m_aesDtc->explosionClusters(
|
|
[this](const AreaEffectSimulation::ExplosionCluster &data)
|
|
{
|
|
if (!data.isCentral())
|
|
return;
|
|
|
|
m_allCentralAesItems.insert(data.id(), AreaEffectSimulation::AesType::AtExplosionCluster);
|
|
});
|
|
|
|
connect(m_aesDtc.get(), &AreaEffectSimulation::Interface::Dtc::nContaminationChanged, this, &HandlerOcCentralAesData::onNContaminationChanged);
|
|
connect(m_aesDtc.get(), &AreaEffectSimulation::Interface::Dtc::bCContaminationChanged, this, &HandlerOcCentralAesData::onBCContaminationChanged);
|
|
connect(m_aesDtc.get(), &AreaEffectSimulation::Interface::Dtc::explosionAreaChanged, this, &HandlerOcCentralAesData::onExplosionAreaChanged);
|
|
connect(m_aesDtc.get(), &AreaEffectSimulation::Interface::Dtc::explosionSingleChanged, this, &HandlerOcCentralAesData::onExplosionSingleChanged);
|
|
connect(m_aesDtc.get(), &AreaEffectSimulation::Interface::Dtc::mineAreaChanged, this, &HandlerOcCentralAesData::onMineAreaChanged);
|
|
connect(m_aesDtc.get(), &AreaEffectSimulation::Interface::Dtc::functionalAreaChanged, this, &HandlerOcCentralAesData::onFunctionalAreaChanged);
|
|
connect(m_aesDtc.get(), &AreaEffectSimulation::Interface::Dtc::boobyTrapChanged, this, &HandlerOcCentralAesData::onBoobyTrapChanged);
|
|
connect(m_aesDtc.get(), &AreaEffectSimulation::Interface::Dtc::offRouteMineChanged, this, &HandlerOcCentralAesData::onOffRouteMineChanged);
|
|
connect(m_aesDtc.get(), &AreaEffectSimulation::Interface::Dtc::explosionClusterChanged, this, &HandlerOcCentralAesData::onExplosionClusterChanged);
|
|
|
|
DEBUG_LOG(m_logger) << "Initialisation HandlerOcCentralAesData succesful.";
|
|
|
|
return true;
|
|
}
|
|
|
|
void HandlerOcCentralAesData::process(const QByteArray &data, bool bIsInitial)
|
|
{
|
|
DEBUG_LOG(m_logger) << "Starting to parse central aes data.";
|
|
|
|
if (bIsInitial)
|
|
{
|
|
DEBUG_LOG(m_logger) << "Data is initial --> removing central aes items.";
|
|
removeAllCentralAesItems();
|
|
|
|
if (!m_allCentralAesItems.isEmpty())
|
|
{
|
|
QTimer::singleShot(500, this, [this, data, bIsInitial]() { process(data, bIsInitial); });
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (data.isEmpty())
|
|
{
|
|
ERROR_LOG(m_logger) << "Got an empty QByteArray to decode.";
|
|
return;
|
|
}
|
|
|
|
bool centralAesItemsOverloaded = false;
|
|
|
|
LtsUtils::get1Byte(data, centralAesItemsOverloaded);
|
|
|
|
TrainingAreaBaseOC::CentralAesOverload centralAesOverload;
|
|
centralAesOverload.id(1);
|
|
centralAesOverload.hasOverload(centralAesItemsOverloaded);
|
|
m_tabocDts->publish(centralAesOverload);
|
|
|
|
DEBUG_LOG(m_logger) << "Central AesItems overloaded: " << centralAesItemsOverloaded;
|
|
// TODO: Further processing of overloaded info
|
|
|
|
QByteArray data2 = data;
|
|
|
|
data2.remove(0, 1);
|
|
|
|
QByteArray uncompressed = MainHandler::tryUncompress(data2, m_bWithCompression);
|
|
if (uncompressed.isEmpty())
|
|
{
|
|
INFO_LOG(m_logger) << "Got an empty QByteArray after uncompression.";
|
|
return;
|
|
}
|
|
|
|
CentralAesByteReader reader(uncompressed);
|
|
|
|
TRACE_LOG(m_logger) << "Uncompressed Data: " << uncompressed.toHex(' ');
|
|
|
|
size_t pos = 0;
|
|
AreaEffectSimulation::AesType aesType;
|
|
OcSituation::CentralAesChangeType changeType;
|
|
|
|
while (pos < static_cast<size_t>(uncompressed.size()))
|
|
{
|
|
if (!reader.getCentralAesChangeType(pos, changeType))
|
|
{
|
|
FATAL_LOG(m_logger) << "Coul not read CentralAesChangeType --> aborting.";
|
|
return;
|
|
}
|
|
|
|
DEBUG_LOG(m_logger) << "Got AesChangeType " << changeType;
|
|
|
|
switch (changeType)
|
|
{
|
|
case OcSituation::AddMod:
|
|
if (!reader.getAesType(pos, aesType))
|
|
{
|
|
FATAL_LOG(m_logger) << "Coul not read AesType --> aborting.";
|
|
return;
|
|
}
|
|
|
|
DEBUG_LOG(m_logger) << "Got AesType " << aesType;
|
|
|
|
switch (aesType.underlying())
|
|
{
|
|
case AreaEffectSimulation::AesType::AtUnknown:
|
|
case AreaEffectSimulation::AesType::AtDangerArea:
|
|
case AreaEffectSimulation::AesType::AtMineCorridor:
|
|
case AreaEffectSimulation::AesType::AtBorderline:
|
|
case AreaEffectSimulation::AesType::AtTechnicalArea:
|
|
case AreaEffectSimulation::AesType::AtExplosionSingleCentral:
|
|
case AreaEffectSimulation::AesType::AtReconArea:
|
|
case AreaEffectSimulation::AesType::AtDusSingleMine:
|
|
case AreaEffectSimulation::AesType::AtExplosionAreaSingleExplosions:
|
|
case AreaEffectSimulation::AesType::AtMineAreaSingleMines:
|
|
case AreaEffectSimulation::AesType::AtGasPipe:
|
|
case AreaEffectSimulation::AesType::AtAirSupportImpact:
|
|
case AreaEffectSimulation::AesType::AtExplosionSingleCentralTrajectory:
|
|
case AreaEffectSimulation::AesType::AtBoobyTrapSecondary:
|
|
case AreaEffectSimulation::AesType::AtOffRouteMineSecondary:
|
|
FATAL_LOG(m_logger) << "Got false AesType: " << aesType.underlying() << " --> aborting.";
|
|
return;
|
|
case AreaEffectSimulation::AesType::AtNContamination:
|
|
{
|
|
AreaEffectSimulation::NContaminationModifyRequest nContamination;
|
|
|
|
if (!reader.getNContamination(pos, nContamination))
|
|
{
|
|
FATAL_LOG(m_logger) << "Could not read NContamination --> aborting.";
|
|
return;
|
|
}
|
|
else
|
|
DEBUG_LOG(m_logger) << "NContamination added/modified.";
|
|
|
|
checkId(nContamination);
|
|
|
|
m_aesFtc->nContaminationModifyRequest(nContamination, this);
|
|
|
|
break;
|
|
}
|
|
case AreaEffectSimulation::AesType::AtBCContamination:
|
|
{
|
|
AreaEffectSimulation::BCContaminationModifyRequest bCContamination;
|
|
|
|
if (!reader.getBCContamination(pos, bCContamination))
|
|
{
|
|
FATAL_LOG(m_logger) << "Could not read BCContamination --> aborting.";
|
|
return;
|
|
}
|
|
else
|
|
DEBUG_LOG(m_logger) << "BCContamination added/modified.";
|
|
|
|
checkId(bCContamination);
|
|
|
|
m_aesFtc->bCContaminationModifyRequest(bCContamination, this);
|
|
|
|
break;
|
|
}
|
|
case AreaEffectSimulation::AesType::AtExplosionArea:
|
|
{
|
|
AreaEffectSimulation::ExplosionAreaModifyRequest explosionArea;
|
|
|
|
if (!reader.getExplosionArea(pos, explosionArea))
|
|
{
|
|
FATAL_LOG(m_logger) << "Could not read ExplosionArea --> aborting.";
|
|
return;
|
|
}
|
|
else
|
|
DEBUG_LOG(m_logger) << "ExplosionArea added/modified.";
|
|
|
|
checkId(explosionArea);
|
|
|
|
m_aesFtc->explosionAreaModifyRequest(explosionArea, this);
|
|
|
|
break;
|
|
}
|
|
case AreaEffectSimulation::AesType::AtExplosionSingle:
|
|
{
|
|
AreaEffectSimulation::ExplosionSingleModifyRequest explosionSingle;
|
|
|
|
if (!reader.getExplosionSingle(pos, explosionSingle))
|
|
{
|
|
FATAL_LOG(m_logger) << "Could not read ExplosionSingle --> aborting.";
|
|
return;
|
|
}
|
|
else
|
|
DEBUG_LOG(m_logger) << "ExplosionSingle added/modified.";
|
|
|
|
checkId(explosionSingle);
|
|
|
|
m_aesFtc->explosionSingleModifyRequest(explosionSingle, this);
|
|
|
|
break;
|
|
}
|
|
case AreaEffectSimulation::AesType::AtMineArea:
|
|
{
|
|
AreaEffectSimulation::MineAreaModifyRequest mineArea;
|
|
|
|
if (!reader.getMineArea(pos, mineArea))
|
|
{
|
|
FATAL_LOG(m_logger) << "Could not read MineArea --> aborting.";
|
|
return;
|
|
}
|
|
else
|
|
DEBUG_LOG(m_logger) << "MineArea added/modified.";
|
|
|
|
mineArea.distance() = 0.5;
|
|
checkId(mineArea);
|
|
|
|
m_aesFtc->mineAreaModifyRequest(mineArea, this);
|
|
|
|
break;
|
|
}
|
|
case AreaEffectSimulation::AesType::AtFunctionalArea:
|
|
{
|
|
AreaEffectSimulation::FunctionalAreaModifyRequest functionalArea;
|
|
|
|
if (!reader.getFunctionalArea(pos, functionalArea))
|
|
{
|
|
FATAL_LOG(m_logger) << "Could not read FunctionalArea --> aborting.";
|
|
return;
|
|
}
|
|
else
|
|
DEBUG_LOG(m_logger) << "FunctionalArea added/modified.";
|
|
|
|
checkId(functionalArea);
|
|
|
|
m_aesFtc->functionalAreaModifyRequest(functionalArea, this);
|
|
|
|
break;
|
|
}
|
|
case AreaEffectSimulation::AesType::AtBoobyTrap:
|
|
{
|
|
AreaEffectSimulation::BoobyTrapModifyRequest boobyTrap;
|
|
|
|
if (!reader.getBoobyTrap(pos, boobyTrap))
|
|
{
|
|
FATAL_LOG(m_logger) << "Could not read BoobyTrap --> aborting.";
|
|
return;
|
|
}
|
|
else
|
|
DEBUG_LOG(m_logger) << "BoobyTrap added/modified.";
|
|
|
|
checkId(boobyTrap);
|
|
|
|
m_aesFtc->boobyTrapModifyRequest(boobyTrap, this);
|
|
|
|
break;
|
|
}
|
|
case AreaEffectSimulation::AesType::AtOffRouteMine:
|
|
{
|
|
AreaEffectSimulation::OffRouteMineModifyRequest offRouteMine;
|
|
|
|
if (!reader.getOffRouteMine(pos, offRouteMine))
|
|
{
|
|
FATAL_LOG(m_logger) << "Could not read OffRouteMine --> aborting.";
|
|
return;
|
|
}
|
|
else
|
|
DEBUG_LOG(m_logger) << "OffRouteMine added/modified.";
|
|
|
|
checkId(offRouteMine);
|
|
|
|
m_aesFtc->offRouteMineModifyRequest(offRouteMine, this);
|
|
|
|
break;
|
|
}
|
|
case AreaEffectSimulation::AesType::AtExplosionCluster:
|
|
{
|
|
AreaEffectSimulation::ExplosionClusterOcModifyRequest explosionCluster;
|
|
|
|
if (!reader.getExplosionCluster(pos, explosionCluster))
|
|
{
|
|
FATAL_LOG(m_logger) << "Could not read ExplosionCluster --> aborting.";
|
|
return;
|
|
}
|
|
else
|
|
DEBUG_LOG(m_logger) << "ExplosionCluster added/modified.";
|
|
|
|
checkId(explosionCluster);
|
|
|
|
m_aesFtc->explosionClusterOcModifyRequest(explosionCluster, this);
|
|
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
case OcSituation::Remove:
|
|
{
|
|
CentralAesByteReader::RemoveMessage removeMessage;
|
|
|
|
if (!reader.getRemoveMessage(pos, removeMessage))
|
|
{
|
|
FATAL_LOG(m_logger) << "Could not read RemoveMessage --> aborting.";
|
|
|
|
return;
|
|
}
|
|
|
|
if (!m_allCentralAesItems.contains(removeMessage.aesItemId))
|
|
{
|
|
INFO_LOG(m_logger) << "Got remove message for unknown aesItemId " << removeMessage.aesItemId;
|
|
|
|
break;
|
|
}
|
|
|
|
DEBUG_LOG(m_logger) << "Sending remove request: aesItemId = " << removeMessage.aesItemId << " ,aesType = " << removeMessage.aesType;
|
|
|
|
tryRemoveAesItem(removeMessage.aesItemId, removeMessage.aesType);
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
DEBUG_LOG(m_logger) << "All central aes data parsed.";
|
|
}
|
|
|
|
void HandlerOcCentralAesData::removeAllCentralAesItems()
|
|
{
|
|
using namespace AreaEffectSimulation;
|
|
|
|
for (auto it = m_allCentralAesItems.constBegin(); it != m_allCentralAesItems.constEnd(); ++it)
|
|
tryRemoveAesItem(it.key(), it.value());
|
|
}
|
|
|
|
void HandlerOcCentralAesData::onNContaminationChanged(const AreaEffectSimulation::NContamination &data, DataModification modType)
|
|
{
|
|
onAesItemChanged(data, modType, AreaEffectSimulation::AesType::AtNContamination);
|
|
}
|
|
|
|
void HandlerOcCentralAesData::onBCContaminationChanged(const AreaEffectSimulation::BCContamination &data, DataModification modType)
|
|
{
|
|
onAesItemChanged(data, modType, AreaEffectSimulation::AesType::AtBCContamination);
|
|
}
|
|
|
|
void HandlerOcCentralAesData::onExplosionAreaChanged(const AreaEffectSimulation::ExplosionArea &data, DataModification modType)
|
|
{
|
|
onAesItemChanged(data, modType, AreaEffectSimulation::AesType::AtExplosionArea);
|
|
}
|
|
|
|
void HandlerOcCentralAesData::onExplosionSingleChanged(const AreaEffectSimulation::ExplosionSingle &data, DataModification modType)
|
|
{
|
|
onAesItemChanged(data, modType, AreaEffectSimulation::AesType::AtExplosionSingle);
|
|
}
|
|
|
|
void HandlerOcCentralAesData::onMineAreaChanged(const AreaEffectSimulation::MineArea &data, DataModification modType)
|
|
{
|
|
onAesItemChanged(data, modType, AreaEffectSimulation::AesType::AtMineArea);
|
|
}
|
|
|
|
void HandlerOcCentralAesData::onFunctionalAreaChanged(const AreaEffectSimulation::FunctionalArea &data, DataModification modType)
|
|
{
|
|
onAesItemChanged(data, modType, AreaEffectSimulation::AesType::AtFunctionalArea);
|
|
}
|
|
|
|
void HandlerOcCentralAesData::onBoobyTrapChanged(const AreaEffectSimulation::BoobyTrap &data, DataModification modType)
|
|
{
|
|
onAesItemChanged(data, modType, AreaEffectSimulation::AesType::AtBoobyTrap);
|
|
}
|
|
|
|
void HandlerOcCentralAesData::onOffRouteMineChanged(const AreaEffectSimulation::OffRouteMine &data, DataModification modType)
|
|
{
|
|
onAesItemChanged(data, modType, AreaEffectSimulation::AesType::AtOffRouteMine);
|
|
}
|
|
|
|
void HandlerOcCentralAesData::onExplosionClusterChanged(const AreaEffectSimulation::ExplosionCluster &data, DataModification modType)
|
|
{
|
|
onAesItemChanged(data, modType, AreaEffectSimulation::AesType::AtExplosionCluster);
|
|
}
|
|
|
|
void HandlerOcCentralAesData::tryRemoveAesItem(qint32 aesItemId, AreaEffectSimulation::AesType aesType)
|
|
{
|
|
using namespace AreaEffectSimulation;
|
|
|
|
switch (aesType.underlying())
|
|
{
|
|
case AesType::AtUnknown:
|
|
case AesType::AtDangerArea:
|
|
case AesType::AtMineCorridor:
|
|
case AesType::AtBorderline:
|
|
case AesType::AtTechnicalArea:
|
|
case AesType::AtExplosionSingleCentral:
|
|
case AesType::AtReconArea:
|
|
case AesType::AtDusSingleMine:
|
|
case AesType::AtExplosionAreaSingleExplosions:
|
|
case AesType::AtMineAreaSingleMines:
|
|
case AesType::AtGasPipe:
|
|
case AesType::AtAirSupportImpact:
|
|
case AesType::AtExplosionSingleCentralTrajectory:
|
|
case AesType::AtBoobyTrapSecondary:
|
|
case AesType::AtOffRouteMineSecondary:
|
|
WARNING_LOG(m_logger) << "Got false AesType: " << aesType.underlying() << " --> aborting.";
|
|
break;
|
|
case AesType::AtNContamination:
|
|
removeAesItem(aesItemId, &AreaEffectSimulation::Interface::Ftc::nContaminationRemoveRequest);
|
|
break;
|
|
case AesType::AtBCContamination:
|
|
removeAesItem(aesItemId, &AreaEffectSimulation::Interface::Ftc::bCContaminationRemoveRequest);
|
|
break;
|
|
case AesType::AtExplosionArea:
|
|
removeAesItem(aesItemId, &AreaEffectSimulation::Interface::Ftc::explosionAreaRemoveRequest);
|
|
break;
|
|
case AesType::AtExplosionSingle:
|
|
removeAesItem(aesItemId, &AreaEffectSimulation::Interface::Ftc::explosionSingleRemoveRequest);
|
|
break;
|
|
case AesType::AtMineArea:
|
|
removeAesItem(aesItemId, &AreaEffectSimulation::Interface::Ftc::mineAreaRemoveRequest);
|
|
break;
|
|
case AesType::AtFunctionalArea:
|
|
removeAesItem(aesItemId, &AreaEffectSimulation::Interface::Ftc::functionalAreaRemoveRequest);
|
|
break;
|
|
case AesType::AtBoobyTrap:
|
|
removeAesItem(aesItemId, &AreaEffectSimulation::Interface::Ftc::boobyTrapRemoveRequest);
|
|
break;
|
|
case AesType::AtOffRouteMine:
|
|
removeAesItem(aesItemId, &AreaEffectSimulation::Interface::Ftc::offRouteMineRemoveRequest);
|
|
break;
|
|
case AesType::AtExplosionCluster:
|
|
removeAesItem(aesItemId, &AreaEffectSimulation::Interface::Ftc::explosionClusterRemoveRequest);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void HandlerOcCentralAesData::onOffRouteMineModifyReply(const Core::FunctionReplyObject &reply) { onReply(reply); }
|
|
|
|
void HandlerOcCentralAesData::onBoobyTrapModifyReply(const Core::FunctionReplyObject &reply) { onReply(reply); }
|
|
|
|
void HandlerOcCentralAesData::onFunctionalAreaModifyReply(const Core::FunctionReplyObject &reply) { onReply(reply); }
|
|
|
|
void HandlerOcCentralAesData::onMineAreaModifyReply(const Core::FunctionReplyObject &reply) { onReply(reply); }
|
|
|
|
void HandlerOcCentralAesData::onExplosionSingleModifyReply(const Core::FunctionReplyObject &reply) { onReply(reply); }
|
|
|
|
void HandlerOcCentralAesData::onExplosionAreaModifyReply(const Core::FunctionReplyObject &reply) { onReply(reply); }
|
|
|
|
void HandlerOcCentralAesData::onBCContaminationModifyReply(const Core::FunctionReplyObject &reply) { onReply(reply); }
|
|
|
|
void HandlerOcCentralAesData::onNContaminationModifyReply(const Core::FunctionReplyObject &reply) { onReply(reply); }
|
|
|
|
void HandlerOcCentralAesData::onExplosionClusterOcModifyReply(const Core::FunctionReplyObject &reply) { onReply(reply); }
|
|
|
|
void HandlerOcCentralAesData::onReply(const Core::FunctionReplyObject &reply) const
|
|
{
|
|
if (reply.error())
|
|
ERROR_LOG(m_logger) << reply.str();
|
|
}
|
|
|
|
template <typename T> void HandlerOcCentralAesData::onAesItemChanged(const T &aesItem, DataModification modType, AreaEffectSimulation::AesType aesType)
|
|
{
|
|
if (!aesItem.isCentral())
|
|
return;
|
|
|
|
switch (modType)
|
|
{
|
|
case DataModification::eAdded:
|
|
m_allCentralAesItems[aesItem.id()] = aesType;
|
|
DEBUG_LOG(m_logger) << "Added new AES Item: id=" << aesItem.id() << ", type=" << aesType;
|
|
break;
|
|
case DataModification::eRemoved:
|
|
m_allCentralAesItems.remove(aesItem.id());
|
|
DEBUG_LOG(m_logger) << "Removed AES Item with id=" << aesItem.id();
|
|
break;
|
|
case DataModification::eModified:
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
template <typename T> void HandlerOcCentralAesData::checkId(T &aesItem) const
|
|
{
|
|
if (!m_allCentralAesItems.contains(aesItem.id()))
|
|
aesItem.id(aesItem.id() * -1);
|
|
}
|
|
|
|
void HandlerOcCentralAesData::removeAesItem(
|
|
qint32 aesItemId,
|
|
int64_t (AreaEffectSimulation::Interface::Ftc::*removeFunction)(const Core::RemoveElementRequest &, const std::function<void(const Core::FunctionReplyObject &)> &))
|
|
{
|
|
(*m_aesFtc.get().*removeFunction)(Core::RemoveElementRequest(aesItemId * -1),
|
|
[this](const Core::FunctionReplyObject &replyObject)
|
|
{
|
|
if (replyObject.error())
|
|
ERROR_LOG(m_logger) << replyObject.str();
|
|
});
|
|
}
|
|
|
|
} // namespace OcSituationClient
|