Complete Qt6 migration: full clean build green across groups G1-G12 incl. runtime plugin set

new_docker_build.sh gains Group 12 (212 GUI/Data plugins); fixes LtsUtilsGuiDds visibility (LTO-stripped exports), LtsProjectionWorkstation unity name shadow, 6 unity-off dirs (dup file-scope statics, ddsftc INTERFACE sources) and reconfigures BUILD_FILTERMANAGEMENT/BUILD_PLUGINS_SERVICEMONITOR=ON
This commit is contained in:
berrux-dev committed 2026-10-20 09:36:57 +02:00
1 parent eb1d949edc
commit 815e16368e
1718 files changed
+126739 -18495

No files matched your search

@@ -66,13 +66,13 @@ Core::FunctionReplyObject BiteHandler::callBiteRequest(const rti::core::SampleId
const CallBiteRequest &request)
{
TrainingAreaBase::DemandBiteRequest req;
req.equipmentNumbers().reserve(request.participantIds().size());
req.withSelfTest(request.withSelfTest());
req.equipmentNumbers.reserve(request.participantIds.size());
req.withSelfTest = request.withSelfTest;
bool bOneFound = false;
bool bAlreadyDemandedFound = false;
QSet<int> currentDemandedParticipants;
for (const int participantId : request.participantIds())
for (const int participantId : request.participantIds)
{
if (m_demandedBiteParticipants.contains(participantId))
{
@@ -98,25 +98,25 @@ Core::FunctionReplyObject BiteHandler::callBiteRequest(const rti::core::SampleId
m_demandedBiteParticipants.insert(participant->id());
currentDemandedParticipants.insert(participant->id());
req.equipmentNumbers().push_back(participant->equipmentNumber());
req.equipmentNumbers.push_back(participant->equipmentNumber());
}
if (req.equipmentNumbers().size() == 0 && bAlreadyDemandedFound)
return Core::FunctionReplyObject(req.requestId());
if (req.equipmentNumbers.size() == 0 && bAlreadyDemandedFound)
return Core::FunctionReplyObject(req.requestId);
if (req.equipmentNumbers().size() != 0)
if (req.equipmentNumbers.size() != 0)
{
static int s_requestId = 1;
req.requestId(s_requestId++);
req.requestId = s_requestId++;
if (!m_mainHandler->tabFtc()->demandBiteRequest(req, this))
return Core::FunctionReplyObject(req.requestId(),
return Core::FunctionReplyObject(req.requestId,
tr_lts("dds", "Error passing the BITE request to the proxy"));
QTimer *timeoutTimer = new QTimer(this);
timeoutTimer->setSingleShot(true);
timeoutTimer->setInterval(5000);
const int requestId = req.requestId();
const int requestId = req.requestId;
m_demandedBiteParticipantRequests.insert(requestId, {currentDemandedParticipants, cookie, timeoutTimer});
auto cb = [this, requestId]()
@@ -129,7 +129,7 @@ Core::FunctionReplyObject BiteHandler::callBiteRequest(const rti::core::SampleId
// at least one found but this was already requested and we're waiting for answer -> don't answer with error
if (bOneFound)
return Core::FunctionReplyObject();
return Core::FunctionReplyObject(req.requestId(),
return Core::FunctionReplyObject(req.requestId,
tr_lts("dds", "Got no valid participants for BITE request"));
}
@@ -50,14 +50,14 @@ void ParticipantManagement::EquipmentEventHandling::EquipmentEventHandler::onEqu
QString stmt = QStringLiteral(" SELECT rec_id, equipment_number, sample_time, position_lon, position_lat, position_z, equipment_function_id, sub_device_id,"
" unique_device_id, device_specific_event_code, event_data"
" FROM rec_equipment_system_event WHERE sample_time > ") + QString::number(request.startTime()) + QStringLiteral(" AND "
" sample_time <= ") + QString::number(request.endTime());
if (request.equipmentFunctionId() > -1)
stmt += QStringLiteral(" AND equipment_function_id=") + QString::number(request.equipmentFunctionId());
if (request.subDeviceId() > -1)
stmt += QStringLiteral(" AND sub_device_id=") + QString::number(request.subDeviceId());
if (request.deviceSpecificEventCode() > -1)
stmt += QStringLiteral(" AND device_specific_event_code=") + QString::number(request.deviceSpecificEventCode());
" FROM rec_equipment_system_event WHERE sample_time > ") + QString::number(request.startTime) + QStringLiteral(" AND "
" sample_time <= ") + QString::number(request.endTime);
if (request.equipmentFunctionId > -1)
stmt += QStringLiteral(" AND equipment_function_id=") + QString::number(request.equipmentFunctionId);
if (request.subDeviceId > -1)
stmt += QStringLiteral(" AND sub_device_id=") + QString::number(request.subDeviceId);
if (request.deviceSpecificEventCode > -1)
stmt += QStringLiteral(" AND device_specific_event_code=") + QString::number(request.deviceSpecificEventCode);
INFO_LOG(m_logger) << "stmt: " << stmt;
@@ -87,22 +87,22 @@ void ParticipantManagement::EquipmentEventHandling::EquipmentEventHandler::onEqu
id |= q.value(i++).toInt();
keys += id;
data.id(id);
data.id = id;
data.equipmentNumber(q.value(i++).toInt());
data.timeStamp(q.value(i++).toLongLong());
data.equipmentNumber = q.value(i++).toInt();
data.timeStamp = q.value(i++).toLongLong();
double pos_lon = q.value(i++).toDouble();
double pos_lat = q.value(i++).toDouble();
double pos_z = q.value(i++).toDouble();
data.position(Core::GeoPosition(pos_lon, pos_lat, pos_z));
data.equipmentFunctionId(q.value(i++).toInt());
data.subDeviceId(q.value(i++).toInt());
data.uniqueDeviceId(q.value(i++).toInt());
data.deviceSpecificEventCode(q.value(i++).toInt());
data.position = Core::GeoPosition(pos_lon, pos_lat, pos_z);
data.equipmentFunctionId = q.value(i++).toInt();
data.subDeviceId = q.value(i++).toInt();
data.uniqueDeviceId = q.value(i++).toInt();
data.deviceSpecificEventCode = q.value(i++).toInt();
QByteArray evtData(q.value(i++).toByteArray());
if (evtData.size() != 0)
data.eventData(LtsUtils::convert<std::vector<uint8_t>>(evtData));
data.filterId(m_filterId);
data.eventData = LtsUtils::convert<std::vector<uint8_t>>(evtData);
data.filterId = m_filterId;
m_mainHandler->dts()->publish(data);
}
@@ -118,22 +118,22 @@ void ParticipantManagement::EquipmentEventHandling::EquipmentEventHandler::onEqu
ParticipantManagement::EquipmentSystemEvent event;
event.id(data.equipmentNumber());
event.equipmentNumber(data.equipmentNumber());
event.sampleTime(data.sampleTime());
if (!std::isnan(event.position().lon()) && !std::isnan(event.position().lat()))
event.position(Core::GeoPosition(data.position().lon(), data.position().lat(), 0.0));
event.id = data.equipmentNumber;
event.equipmentNumber = data.equipmentNumber;
event.sampleTime = data.sampleTime;
if (!std::isnan(event.position.lon) && !std::isnan(event.position.lat))
event.position = Core::GeoPosition(data.position.lon, data.position.lat, 0.0);
else
event.position(m_mainHandler->participantHandler()->participantByEquipmentNumber(data.equipmentNumber())->position().pos());
event.equipmentFunctionId(data.source().equipmentFunctionId());
event.subDeviceId(data.source().subDeviceId());
event.uniqueDeviceId(data.source().unqiueId());
event.deviceSpecificEventCode(data.code());
event.eventData(data.data());
event.position = m_mainHandler->participantHandler()->participantByEquipmentNumber(data.equipmentNumber)->position().pos;
event.equipmentFunctionId = data.source.equipmentFunctionId;
event.subDeviceId = data.source.subDeviceId;
event.uniqueDeviceId = data.source.unqiueId;
event.deviceSpecificEventCode = data.code;
event.eventData = data.data;
if (!m_mainHandler->dts()->publish(event))
{
ERROR_LOG(m_logger) << "Error publishing equipment event to dds from eqnr: " << event.equipmentNumber() ;
ERROR_LOG(m_logger) << "Error publishing equipment event to dds from eqnr: " << event.equipmentNumber ;
}
}
@@ -36,10 +36,10 @@ Core::FunctionReplyObject FiringUnitValidator::firingUnitError(const QHash<int,
for (const ParticipantData &currentData : participantData)
{
if (!m_typeHandler->isFiringUnitType(currentData.typeId()))
if (!m_typeHandler->isFiringUnitType(currentData.typeId))
continue;
int unitModId = currentData.modId();
int unitModId = currentData.modId;
error = getError(modIdToParticipantId, participantData, unitModId);
@@ -61,7 +61,7 @@ QString FiringUnitValidator::getError(const QHash<int, int> &modIdToParticipantI
for (const ParticipantData &currentData : participantData)
{
if (currentData.superiorModId() != unitModId)
if (currentData.superiorModId != unitModId)
continue;
// capacity error
@@ -71,16 +71,16 @@ QString FiringUnitValidator::getError(const QHash<int, int> &modIdToParticipantI
return tr("There are only %1 participants allowed per firing unit.").arg(maxParticipantsPerFiringUnit);
// false type error
hasFalseTypeError = !m_typeHandler->isArtilleryParticipantType(currentData.typeId());
hasFalseTypeError = !m_typeHandler->isArtilleryParticipantType(currentData.typeId);
if (hasFalseTypeError)
return tr("There are only artillery participants allowed in firing units.");
// mixed type error
if (typeId == -1)
typeId = currentData.typeId();
typeId = currentData.typeId;
hasMixedTypeError = currentData.typeId() != typeId;
hasMixedTypeError = currentData.typeId != typeId;
if (hasMixedTypeError)
return tr("There are no mixed types allowed in firing units.");
@@ -39,7 +39,7 @@ void GetParticipants::onGetParticipantsRequest(const rti::core::SampleIdentity &
recordReplay.initDtc(nullptr, m_mainHandler->exerciseId());
NSqlQuery q(m_mainHandler->db()->database());
recordReplay.readParticipantAt(q, request.timeStamp());
recordReplay.readParticipantAt(q, request.timeStamp);
// key is sampleTime -> multiMap
auto participantsMmap = recordReplay.getParticipantMap();
@@ -49,23 +49,23 @@ void GetParticipants::onGetParticipantsRequest(const rti::core::SampleIdentity &
for (auto it = participantsMmap.begin(); it != participantsMmap.end(); ++it)
{
Participant &p = it.value();
if (p.isDeleted())
participants.remove(p.id());
if (p.isDeleted)
participants.remove(p.id);
else
participants[p.id()] = std::move(p);
participants[p.id] = std::move(p);
}
DEBUG_LOG(m_logger) << "Starting to read participant from record replay. Size: "
<< participants.size();
GetParticipantsReply reply;
reply.requestId(request.requestId());
reply.requestId = request.requestId;
auto &vecPart = reply.participants();
auto &vecPart = reply.participants;
vecPart.reserve(participants.size());
for (auto it = participants.begin(); it != participants.end(); ++it)
{
if (request.partyId() >= 0 && it.value().partyId() != request.partyId())
if (request.partyId >= 0 && it.value().partyId != request.partyId)
continue;
vecPart.push_back(it.value());
}
@@ -35,15 +35,15 @@ public:
virtual ~Participant();
int32_t id() const { return m_participantData.id(); }
int32_t typeId() const { return m_participantData.typeId(); }
int32_t superiorId() const { return m_participantData.superiorId(); }
int32_t id() const { return m_participantData.id; }
int32_t typeId() const { return m_participantData.typeId; }
int32_t superiorId() const { return m_participantData.superiorId; }
// return optional?
int32_t equipmentNumber() const { return m_participantData.equipmentNumber.is_set() ? m_participantData.equipmentNumber.get() : 0; }
int32_t partyId() const { return m_participantData.partyId(); }
bool isDeleted() const { return m_participantData.isDeleted(); }
ParticipantAssignState assignState() const { return m_participantData.assignState(); }
const std::vector<int32_t> &inferiors() const { return m_participantData.inferiorIds(); }
int32_t equipmentNumber() const { return m_participantData.equipmentNumber.has_value() ? m_participantData.equipmentNumber.get() : 0; }
int32_t partyId() const { return m_participantData.partyId; }
bool isDeleted() const { return m_participantData.isDeleted; }
ParticipantAssignState assignState() const { return m_participantData.assignState; }
const std::vector<int32_t> &inferiors() const { return m_participantData.inferiorIds; }
ParticipantPosition position() const { return m_positionPublished; }
const DynamicParticipantData &dynamicParticipantData() const { return m_dynamicData; }
const ParticipantManagement::Participant &participantData() const { return m_participantData; }
@@ -52,8 +52,8 @@ bool ParticipantForExercise::applyEquipmentExerciseMapping(int newEqId)
<< ", " << dbEem.exerciseId;
if (!m_mainHandler->dbEx0()->insert(dbEem))
{
m_participantData.equipmentNumber().reset();
m_participantData.assignState(ParticipantAssignState::NotAssigned);
m_participantData.equipmentNumber.reset();
m_participantData.assignState = ParticipantAssignState::NotAssigned;
publishParticipant();
return false;
}
@@ -104,15 +104,15 @@ void ParticipantForExercise::removeFromDds() // only called on shutdown
void ParticipantForExercise::registerInfoFromFt(const RegisterParticipantRequest &request)
{
m_participantData.info(request.info());
m_participantData.identification(request.identification());
m_participantData.info = request.info;
m_participantData.identification = request.identification;
}
bool ParticipantForExercise::registerFromFt(const RegisterParticipantRequest &request)
{
int newEquipmentNumber = request.equipmentNumber();
int newEquipmentNumber = request.equipmentNumber;
// just to be sure ...
if (request.assignState() == ParticipantAssignState::NotAssigned)
if (request.assignState == ParticipantAssignState::NotAssigned)
newEquipmentNumber = 0;
if (!updateEquipmentExerciseMapping(equipmentNumber(), newEquipmentNumber))
@@ -122,17 +122,17 @@ bool ParticipantForExercise::registerFromFt(const RegisterParticipantRequest &re
id());
INFO_LOG(m_logger) << "Set assign state for participant " << id() << " from "
<< assignState() << " to " << request.assignState()
<< assignState() << " to " << request.assignState
<< ", old eqid: " << equipmentNumber() << ", new eqid: "
<< newEquipmentNumber;
if (newEquipmentNumber)
m_participantData.equipmentNumber(newEquipmentNumber);
m_participantData.equipmentNumber = newEquipmentNumber;
else
m_participantData.equipmentNumber().reset();
m_participantData.assignState(request.assignState());
m_participantData.info(request.info());
m_participantData.identification(request.identification());
m_participantData.equipmentNumber.reset();
m_participantData.assignState = request.assignState;
m_participantData.info = request.info;
m_participantData.identification = request.identification;
return true;
}
@@ -41,7 +41,7 @@ void ParticipantHandler::clearParticipants()
{
// clear maps
for (auto it = m_hitLineInfoMap.cbegin(); it != m_hitLineInfoMap.cend(); ++it)
dts()->removeHitLineInfoByKey(it.value().id());
dts()->removeHitLineInfoByKey(it.value().id);
m_hitLineInfoMap.clear();
for (auto p : std::as_const(m_participants))
@@ -97,49 +97,49 @@ void ParticipantHandler::onNewGearEvent(const TrainingAreaBase::EquipmentGearEve
{
if (isTelegramInFuture(gearEvent))
{
WARNING_LOG(m_logger) << "Got an EquipmentGearEvent which has a timestamp in the future: " << gearEvent.sampleTime();
WARNING_LOG(m_logger) << "Got an EquipmentGearEvent which has a timestamp in the future: " << gearEvent.sampleTime;
return;
}
// NOTE: gearEvent.chargeAmount() is not used because there is no usecase for this value ... atm
Participant *participantToBeChanged = participantByEquipmentNumber(gearEvent.equipmentNumber());
Participant *participantToBeChanged = participantByEquipmentNumber(gearEvent.equipmentNumber);
if (!participantToBeChanged)
{
WARNING_LOG(m_logger) << "Got gear charge state for unknown equipment number " << gearEvent.equipmentNumber();
WARNING_LOG(m_logger) << "Got gear charge state for unknown equipment number " << gearEvent.equipmentNumber;
return;
}
participantToBeChanged->setGearCharge(gearEvent.charge(), gearEvent.sampleTime());
participantToBeChanged->setGearCharge(gearEvent.charge, gearEvent.sampleTime);
participantToBeChanged->publishDynamicData();
// publish gear event
dts()->publish(
ParticipantGearEvent(participantToBeChanged->id(),
gearEvent.sampleTime(),
gearEvent.chargeAmount(),
GearCharge(gearEvent.charge().gearId(), gearEvent.charge().gearTypeId(), gearEvent.charge().chargeTypeId(), gearEvent.charge().remain())));
gearEvent.sampleTime,
gearEvent.chargeAmount,
GearCharge(gearEvent.charge.gearId, gearEvent.charge.gearTypeId, gearEvent.charge.chargeTypeId, gearEvent.charge.remain)));
}
void ParticipantHandler::onNewGearChargeStateFromProxy(const TrainingAreaBase::EquipmentGearChargeState &chargeState)
{
if (isTelegramInFuture(chargeState))
{
WARNING_LOG(m_logger) << "Got an EquipmentGearChargeState which has a timestamp in the future: " << chargeState.sampleTime();
WARNING_LOG(m_logger) << "Got an EquipmentGearChargeState which has a timestamp in the future: " << chargeState.sampleTime;
return;
}
const int equipNo = chargeState.equipmentNumber();
const int equipNo = chargeState.equipmentNumber;
Participant *participantToBeChanged = equipNo < 0 ? participantById(-equipNo) : participantByEquipmentNumber(equipNo);
if (!participantToBeChanged)
{
WARNING_LOG(m_logger) << "Got gear charge state for unknown equipment number " << chargeState.equipmentNumber();
WARNING_LOG(m_logger) << "Got gear charge state for unknown equipment number " << chargeState.equipmentNumber;
return;
}
for (const TrainingAreaBase::GearCharge &charge : chargeState.charge())
participantToBeChanged->setGearCharge(charge, chargeState.sampleTime());
for (const TrainingAreaBase::GearCharge &charge : chargeState.charge)
participantToBeChanged->setGearCharge(charge, chargeState.sampleTime);
participantToBeChanged->publishDynamicData();
emit gearChargeChanged(participantToBeChanged->id(), participantToBeChanged->partyId());
@@ -149,13 +149,13 @@ void ParticipantHandler::onNewGearAssignmentFromProxy(const TrainingAreaBase::Eq
{
if (isTelegramInFuture(gearAssignment))
{
WARNING_LOG(m_logger) << "Got an EquipmentGearAssignment which has a timestamp in the future: " << gearAssignment.sampleTime();
WARNING_LOG(m_logger) << "Got an EquipmentGearAssignment which has a timestamp in the future: " << gearAssignment.sampleTime;
return;
}
Participant *participantToBeChanged = participantByEquipmentNumber(gearAssignment.equipmentNumber());
Participant *participantToBeChanged = participantByEquipmentNumber(gearAssignment.equipmentNumber);
if (!participantToBeChanged)
{
WARNING_LOG(m_logger) << "Got gear assignment for unknown equipment number " << gearAssignment.equipmentNumber();
WARNING_LOG(m_logger) << "Got gear assignment for unknown equipment number " << gearAssignment.equipmentNumber;
return;
}
@@ -167,34 +167,34 @@ void ParticipantHandler::onNewStateFromProxy(const TrainingAreaBase::EquipmentSt
{
if (isTelegramInFuture(data))
{
WARNING_LOG(m_logger) << "Got an EquipmentState which has a timestamp in the future: " << data.sampleTime();
WARNING_LOG(m_logger) << "Got an EquipmentState which has a timestamp in the future: " << data.sampleTime;
return;
}
// 1. handle included EquipmentPosition:
TrainingAreaBase::EquipmentPosition pos;
pos.equipmentNumber(data.equipmentNumber());
pos.sampleTime(data.sampleTime());
if (data.position.is_set())
pos.equipmentNumber = data.equipmentNumber;
pos.sampleTime = data.sampleTime;
if (data.position.has_value())
{
pos.position(data.position.get());
pos.position = data.position.get();
onNewPositionFromProxy(pos);
}
// 2. handle EquipmentState
Participant *participantToBeChanged = participantByEquipmentNumber(data.equipmentNumber());
Participant *participantToBeChanged = participantByEquipmentNumber(data.equipmentNumber);
if (!participantToBeChanged)
{
WARNING_LOG(m_logger) << "Got equipment state for unknown equipment number " << data.equipmentNumber();
WARNING_LOG(m_logger) << "Got equipment state for unknown equipment number " << data.equipmentNumber;
return;
}
// convert eqNo to participantId if originator was a participant and data.originatorId() is an equipment number
int originatorId = data.originatorId();
int originatorId = data.originatorId;
Participant *originParticipant = nullptr;
if (data.originatorType() == ProjectDataManagement::StateChangeOriginator::Participant)
if (data.originatorType == ProjectDataManagement::StateChangeOriginator::StateChangeOriginator_Participant)
{
originParticipant = participantByEquipmentNumber(data.originatorId());
originParticipant = participantByEquipmentNumber(data.originatorId);
if (originParticipant)
originatorId = originParticipant->id();
else
@@ -203,20 +203,20 @@ void ParticipantHandler::onNewStateFromProxy(const TrainingAreaBase::EquipmentSt
// Make Laser Designations to Laser Designations
auto dtcPdm = m_bdp->pdmDtc();
if (dtcPdm && dtcPdm->getChargeTypeSpecialProperty(data.originatorChargeTypeId(), 0, 0) == ProjectDataManagement::ChargeTypeProperty::LTD && originParticipant)
if (dtcPdm && dtcPdm->getChargeTypeSpecialProperty(data.originatorChargeTypeId, 0, 0) == ProjectDataManagement::ChargeTypeProperty::LTD && originParticipant)
{
QSet<int> ldGearTypes{1043}; // Need Property for LTD...
DynamicParticipantData dpd = originParticipant->dynamicParticipantData();
auto it = std::find_if(dpd.gear().cbegin(), dpd.gear().cend(), [ldGearTypes](const GearInformation &gi) { return ldGearTypes.contains(gi.gearTypeId()); });
if (it != dpd.gear().cend())
auto it = std::find_if(dpd.gear.cbegin(), dpd.gear.cend(), [ldGearTypes](const GearInformation &gi) { return ldGearTypes.contains(gi.gearTypeId); });
if (it != dpd.gear.cend())
{
for (auto &ld : dpd.designations())
for (auto &ld : dpd.designations)
{
if (ld.gearId() != it->gearId())
if (ld.gearId != it->gearId)
continue;
ld.spotLocation() = pos.position().position();
ld.outputPower() = 1.0;
ld.spotLocation = pos.position.position;
ld.outputPower = 1.0;
originParticipant->setDynamicData(dpd);
originParticipant->publishDynamicData();
break;
@@ -229,7 +229,7 @@ void ParticipantHandler::onNewStateFromProxy(const TrainingAreaBase::EquipmentSt
participantToBeChanged->publishDynamicData();
createHitlineInfo(originatorId, originParticipant, participantToBeChanged, pos, data.originatorChargeTypeId(), data.sampleTime());
createHitlineInfo(originatorId, originParticipant, participantToBeChanged, pos, data.originatorChargeTypeId, data.sampleTime);
}
void ParticipantHandler::createHitlineInfo(int, Participant *, Participant *, const TrainingAreaBase::EquipmentPosition &, int, qint64)
@@ -242,17 +242,17 @@ void ParticipantHandler::onNewPositionFromProxy(const TrainingAreaBase::Equipmen
{
if (isTelegramInFuture(position))
{
WARNING_LOG(m_logger) << "Got an EquipmentPosition which has a timestamp in the future: " << position.sampleTime();
WARNING_LOG(m_logger) << "Got an EquipmentPosition which has a timestamp in the future: " << position.sampleTime;
return;
}
if (isTelegramOutdated(position) && position.position().reportingSource() != Core::PositionReportingSource::SetByOperator)
if (isTelegramOutdated(position) && position.position.reportingSource != Core::PositionReportingSource::SetByOperator)
{
INFO_LOG(m_logger) << "position is outdated: " << position;
return;
}
DEBUG_LOG(m_logger) << "Got new position from proxy: " << position;
const int equipNo = position.equipmentNumber();
const int equipNo = position.equipmentNumber;
// negative - treat as participantId
Participant *participantWithNewPosition = equipNo < 0 ? participantById(-equipNo) : participantByEquipmentNumber(equipNo);
@@ -270,11 +270,11 @@ void ParticipantHandler::onNewEquipmentOperationalStateFromProxy(const TrainingA
{
if (isTelegramInFuture(operationalState))
{
WARNING_LOG(m_logger) << "Got an EquipmentOperationalState which has a timestamp in the future: " << operationalState.sampleTime();
WARNING_LOG(m_logger) << "Got an EquipmentOperationalState which has a timestamp in the future: " << operationalState.sampleTime;
return;
}
Participant *participantToUpdate = participantByEquipmentNumber(operationalState.equipmentNumber());
Participant *participantToUpdate = participantByEquipmentNumber(operationalState.equipmentNumber);
if (!participantToUpdate)
{
WARNING_LOG(m_logger) << "Got EquipmentOperationalState for unknown equipment number: " << operationalState;
@@ -289,30 +289,30 @@ void ParticipantHandler::onNewBiteFromProxy(const TrainingAreaBase::EquipmentBit
{
if (isTelegramInFuture(bite))
{
WARNING_LOG(m_logger) << "Got an EquipmentBite which has a timestamp in the future: " << bite.sampleTime();
WARNING_LOG(m_logger) << "Got an EquipmentBite which has a timestamp in the future: " << bite.sampleTime;
return;
}
if (isTelegramOutdated(bite))
{
WARNING_LOG(m_logger) << "Got an EquipmentBite which has a timestamp in the past: " << bite.sampleTime();
WARNING_LOG(m_logger) << "Got an EquipmentBite which has a timestamp in the past: " << bite.sampleTime;
return;
}
Bite biteData;
Participant *p = participantByEquipmentNumber(bite.equipmentNumber());
biteData.participantId(p ? p->id() : -1);
biteData.equipmentNumber(bite.equipmentNumber());
biteData.sampleTime(bite.sampleTime());
biteData.registerType(bite.registerType());
biteData.biteState(bite.biteState());
biteData.configState(bite.configState());
biteData.batteryState(bite.batteryState());
biteData.configError(bite.configError());
Participant *p = participantByEquipmentNumber(bite.equipmentNumber);
biteData.participantId = p ? p->id() : -1;
biteData.equipmentNumber = bite.equipmentNumber;
biteData.sampleTime = bite.sampleTime;
biteData.registerType = bite.registerType;
biteData.biteState = bite.biteState;
biteData.configState = bite.configState;
biteData.batteryState = bite.batteryState;
biteData.configError = bite.configError;
biteData.biteErrors().reserve(bite.biteErrors().size());
for (const TrainingAreaBase::EquipmentBiteError &error : bite.biteErrors())
biteData.biteErrors().emplace_back(error.errorNumber(), error.canDeviceNumber(), error.subdeviceNumber(), error.uniqueId());
biteData.biteErrors.reserve(bite.biteErrors.size());
for (const TrainingAreaBase::EquipmentBiteError &error : bite.biteErrors)
biteData.biteErrors.emplace_back(error.errorNumber, error.canDeviceNumber, error.subdeviceNumber, error.uniqueId);
dts()->publish(biteData);
}
@@ -321,11 +321,11 @@ void ParticipantHandler::onNewCtaDataErrorFromProxy(const TrainingAreaBase::CtaD
{
CtaError ctasErrorData;
ctasErrorData.equipmentNumber(error.equipmentNumber());
ctasErrorData.timeReceipt(currentTimeMSec());
ctasErrorData.timePlayerUnit(error.sampleTime());
ctasErrorData.errorReason(error.reason());
ctasErrorData.telegramId(error.originTelegramId());
ctasErrorData.equipmentNumber = error.equipmentNumber;
ctasErrorData.timeReceipt = currentTimeMSec();
ctasErrorData.timePlayerUnit = error.sampleTime;
ctasErrorData.errorReason = error.reason;
ctasErrorData.telegramId = error.originTelegramId;
dts()->publish(ctasErrorData);
}
@@ -334,39 +334,39 @@ void ParticipantHandler::onNewParticipantModeReport(const TrainingAreaBase::Part
{
if (isTelegramInFuture(report))
{
WARNING_LOG(m_logger) << "Got a ParticipantModeReport which has a timestamp in the future: " << report.sampleTime();
WARNING_LOG(m_logger) << "Got a ParticipantModeReport which has a timestamp in the future: " << report.sampleTime;
return;
}
if (isTelegramOutdated(report))
{
WARNING_LOG(m_logger) << "Got a ParticipantModeReport which has a timestamp in the past: " << report.sampleTime();
WARNING_LOG(m_logger) << "Got a ParticipantModeReport which has a timestamp in the past: " << report.sampleTime;
return;
}
Participant *participant = participantByEquipmentNumber(report.equipmentNumber());
Participant *participant = participantByEquipmentNumber(report.equipmentNumber);
if (!participant)
{
ERROR_LOG(m_logger) << LOGFUNCTION << "Could not find participant with equipment number " << report.equipmentNumber();
ERROR_LOG(m_logger) << LOGFUNCTION << "Could not find participant with equipment number " << report.equipmentNumber;
return;
}
ParticipantMode ddsData;
ddsData.participantId(participant->id());
ddsData.language(report.language());
ddsData.opMode(report.operationMode());
ddsData.reactivationDecontamination(report.reactivationDetoxication());
ddsData.reactivationMaintenance(report.reactivationMaintenance());
ddsData.reactivationMedic(report.reactivationMedic());
ddsData.modeVest(report.protectionModeVest());
ddsData.modeHelmet(report.protectionModeHelmet());
ddsData.modePersonalProtection(report.personellProtectionMode());
ddsData.protectionLevel(report.protectionLevel());
ddsData.handgrenadeSearchMode(report.handgrenadeSearchMode());
ddsData.internationalMode(report.internationalMode());
ddsData.abcProtectionMode(report.abcProtectionMode());
ddsData.participantId = participant->id();
ddsData.language = report.language;
ddsData.opMode = report.operationMode;
ddsData.reactivationDecontamination = report.reactivationDetoxication;
ddsData.reactivationMaintenance = report.reactivationMaintenance;
ddsData.reactivationMedic = report.reactivationMedic;
ddsData.modeVest = report.protectionModeVest;
ddsData.modeHelmet = report.protectionModeHelmet;
ddsData.modePersonalProtection = report.personellProtectionMode;
ddsData.protectionLevel = report.protectionLevel;
ddsData.handgrenadeSearchMode = report.handgrenadeSearchMode;
ddsData.internationalMode = report.internationalMode;
ddsData.abcProtectionMode = report.abcProtectionMode;
ddsData.sampleTime(report.sampleTime());
ddsData.sampleTime = report.sampleTime;
participant->setMode(ddsData);
participant->publishMode();
}
@@ -375,30 +375,30 @@ void ParticipantHandler::onNewSpecialSensorData(const TrainingAreaBase::SpecialS
{
if (isTelegramInFuture(data))
{
WARNING_LOG(m_logger) << "Got a SpecialSensorData which has a timestamp in the future: " << data.sampleTime();
WARNING_LOG(m_logger) << "Got a SpecialSensorData which has a timestamp in the future: " << data.sampleTime;
return;
}
if (isTelegramOutdated(data))
{
WARNING_LOG(m_logger) << "Got a SpecialSensorData which has a timestamp in the past: " << data.sampleTime();
WARNING_LOG(m_logger) << "Got a SpecialSensorData which has a timestamp in the past: " << data.sampleTime;
return;
}
Participant *participant = data.equipmentNumber() < 0 ? participantById(-data.equipmentNumber()) : participantByEquipmentNumber(data.equipmentNumber());
Participant *participant = data.equipmentNumber < 0 ? participantById(-data.equipmentNumber) : participantByEquipmentNumber(data.equipmentNumber);
if (!participant)
{
ERROR_LOG(m_logger) << LOGFUNCTION << "Could not find participant with equipment number " << data.equipmentNumber();
ERROR_LOG(m_logger) << LOGFUNCTION << "Could not find participant with equipment number " << data.equipmentNumber;
return;
}
TrainingAreaBase::EquipmentPosition pos;
pos.equipmentNumber(data.equipmentNumber());
pos.sampleTime(data.sampleTime());
if (data.position.is_set())
pos.equipmentNumber = data.equipmentNumber;
pos.sampleTime = data.sampleTime;
if (data.position.has_value())
{
Core::GeoPosition geoPos(data.position.get().lon(), data.position.get().lat(), 0);
pos.position().position(geoPos);
Core::GeoPosition geoPos(data.position.get().lon, data.position.get().lat, 0);
pos.position.position = geoPos;
if (participant->setPosition(pos))
participant->publishPosition();
}
@@ -410,13 +410,13 @@ void ParticipantHandler::onNewSpecialSensorData(const TrainingAreaBase::SpecialS
void ParticipantHandler::onNewLaserDesignation(const TrainingAreaBase::LaserDesignation &data)
{
DEBUG_LOG(m_logger) << "New Laser Designation: "
<< "Code: " << data.code() << ", GearID: " << data.gearId() << ", EqNo: " << data.equipmentNumber() << ", Lon: " << data.spotLocation().lon()
<< ", Lat: " << data.spotLocation().lat() << ", Power: " << data.outputPower();
Participant *participant = participantByEquipmentNumber(data.equipmentNumber());
<< "Code: " << data.code << ", GearID: " << data.gearId << ", EqNo: " << data.equipmentNumber << ", Lon: " << data.spotLocation.lon
<< ", Lat: " << data.spotLocation.lat << ", Power: " << data.outputPower;
Participant *participant = participantByEquipmentNumber(data.equipmentNumber);
if (!participant)
{
ERROR_LOG(m_logger) << LOGFUNCTION << "Could not find participant with equipment number " << data.equipmentNumber();
ERROR_LOG(m_logger) << LOGFUNCTION << "Could not find participant with equipment number " << data.equipmentNumber;
return;
}
@@ -457,17 +457,17 @@ void ParticipantHandler::onLaserDesignationRemoved(int equipmentNumber, int gear
void ParticipantHandler::onBuildingHitLineInfo(const Buildings::BuildingHitLineInfo &data)
{
DEBUG_LOG(m_logger) << "onBuildingHitLineInfo "
<< "BuildingId=" << data.buildingId() << " originatorParticipantId=" << data.originatorParticipantId();
<< "BuildingId=" << data.buildingId << " originatorParticipantId=" << data.originatorParticipantId;
auto dtcPdm = m_bdp->pdmDtc();
// NOTE: igniterTypeId/IgniterFunction = 0 as long as BuildingHitLineInfo does not contain values
if (dtcPdm->getChargeTypeSpecialProperty(data.chargeTypeId(), 0, 0) != ProjectDataManagement::ChargeTypeProperty::LTD)
if (dtcPdm->getChargeTypeSpecialProperty(data.chargeTypeId, 0, 0) != ProjectDataManagement::ChargeTypeProperty::LTD)
return;
Participant *participant = participantById(data.originatorParticipantId());
Participant *participant = participantById(data.originatorParticipantId);
if (!participant)
{
ERROR_LOG(m_logger) << LOGFUNCTION << "Could not find participant with participantId: " << data.originatorParticipantId();
ERROR_LOG(m_logger) << LOGFUNCTION << "Could not find participant with participantId: " << data.originatorParticipantId;
return;
}
@@ -480,68 +480,68 @@ void ParticipantHandler::onBuildingHitLineInfo(const Buildings::BuildingHitLineI
DEBUG_LOG(m_logger) << "setDynamicData";
participant->setDynamicData(dpd);
DEBUG_LOG(m_logger) << "publishDynamicData"
<< " dpd.designations().size()=" << dpd.designations().size();
<< " dpd.designations().size()=" << dpd.designations.size();
participant->publishDynamicData();
}
void ParticipantHandler::onSanitaryMaterialStockReport(const TrainingAreaBase::ParticipantSanitaryMaterialStockReport &data)
{
DEBUG_LOG(m_logger) << "onSanitaryMaterialStockReport";
Participant *participant = participantByEquipmentNumber(data.equipmentNumber());
Participant *participant = participantByEquipmentNumber(data.equipmentNumber);
if (!participant)
{
ERROR_LOG(m_logger) << LOGFUNCTION << "Could not find participant with equipment number " << data.equipmentNumber();
ERROR_LOG(m_logger) << LOGFUNCTION << "Could not find participant with equipment number " << data.equipmentNumber;
return;
}
if (data.qualification() == TrainingAreaBase::Qualification::NotDefined)
if (data.qualification == TrainingAreaBase::Qualification::NotDefined)
{
DEBUG_LOG(m_logger) << "!!! Clear Materials : equipment number " << data.equipmentNumber();
DEBUG_LOG(m_logger) << "!!! Clear Materials : sample time " << data.sampleTime();
DEBUG_LOG(m_logger) << "!!! Clear Materials : equipment number " << data.equipmentNumber;
DEBUG_LOG(m_logger) << "!!! Clear Materials : sample time " << data.sampleTime;
participant->setSanitationMaterial(0,
std::vector<int>(),
data.uniqueId(),
data.sampleTime(),
data.uniqueId,
data.sampleTime,
Qualification::NotAssigned,
data.originatorEquipmentNumber()); // this is a deassociation so clear material
data.originatorEquipmentNumber); // this is a deassociation so clear material
}
else
{
DEBUG_LOG(m_logger) << "!!! Set Materials : equipment number " << data.equipmentNumber();
DEBUG_LOG(m_logger) << "!!! Set Materials : sample time " << data.sampleTime();
participant->setSanitationMaterial(data.sanitaryMaterialCount(),
data.sanitaryMaterialStock(),
data.uniqueId(),
data.sampleTime(),
static_cast<ParticipantManagement::Qualification>(data.qualification().underlying()),
data.originatorEquipmentNumber());
DEBUG_LOG(m_logger) << "!!! Set Materials : equipment number " << data.equipmentNumber;
DEBUG_LOG(m_logger) << "!!! Set Materials : sample time " << data.sampleTime;
participant->setSanitationMaterial(data.sanitaryMaterialCount,
data.sanitaryMaterialStock,
data.uniqueId,
data.sampleTime,
static_cast<ParticipantManagement::Qualification>(data.qualification),
data.originatorEquipmentNumber);
}
participant->publishDynamicData();
}
void ParticipantHandler::onParticipantSanitation(const TrainingAreaBase::ParticipantSanitation &data)
{
Participant *participant = participantByEquipmentNumber(data.equipmentNumber());
Participant *participantOrig = participantByEquipmentNumber(data.originatorEquipmentNumber());
Participant *participant = participantByEquipmentNumber(data.equipmentNumber);
Participant *participantOrig = participantByEquipmentNumber(data.originatorEquipmentNumber);
if (!participant)
{
ERROR_LOG(m_logger) << LOGFUNCTION << "Could not find participant with equipment number " << data.equipmentNumber();
ERROR_LOG(m_logger) << LOGFUNCTION << "Could not find participant with equipment number " << data.equipmentNumber;
return;
}
int participantOrigId = data.originatorEquipmentNumber();
int participantOrigId = data.originatorEquipmentNumber;
if (participantOrig)
participantOrigId = participantOrig->id();
if (data.qualification() == TrainingAreaBase::Qualification::NotDefined && data.proceduresTaken() == 0)
if (data.qualification == TrainingAreaBase::Qualification::NotDefined && data.proceduresTaken == 0)
{
DEBUG_LOG(m_logger) << "!!! Clear Sanitation = " << data.sampleTime();
DEBUG_LOG(m_logger) << "!!! Clear Sanitation: equipNo = " << data.equipmentNumber();
participant->setSanitationMaterial(0, std::vector<int>(), 0, data.sampleTime(), Qualification::NotAssigned, 0); // this is a deassociation so clear material
DEBUG_LOG(m_logger) << "!!! Clear Sanitation = " << data.sampleTime;
DEBUG_LOG(m_logger) << "!!! Clear Sanitation: equipNo = " << data.equipmentNumber;
participant->setSanitationMaterial(0, std::vector<int>(), 0, data.sampleTime, Qualification::NotAssigned, 0); // this is a deassociation so clear material
}
else
{
DEBUG_LOG(m_logger) << "!!! SetSanitation: sample time = " << data.sampleTime();
DEBUG_LOG(m_logger) << "!!! SetSanitation: equipNo = " << data.equipmentNumber();
participant->setSanitation(data.proceduresTaken(), data.sanitationResult(), data.sanitationEvaluation(), participantOrigId, data.qualification(), data.sampleTime());
DEBUG_LOG(m_logger) << "!!! SetSanitation: sample time = " << data.sampleTime;
DEBUG_LOG(m_logger) << "!!! SetSanitation: equipNo = " << data.equipmentNumber;
participant->setSanitation(data.proceduresTaken, data.sanitationResult, data.sanitationEvaluation, participantOrigId, data.qualification, data.sampleTime);
}
participant->publishDynamicData();
}
@@ -549,67 +549,67 @@ void ParticipantHandler::onParticipantSanitation(const TrainingAreaBase::Partici
void ParticipantHandler::onOperatorAction(const TrainingAreaBase::OperatorAction &data)
{
// maybe use other commands later?!
if (data.action() != 8 && data.action() != 35)
if (data.action != 8 && data.action != 35)
return;
Participant *participant = participantByEquipmentNumber(data.equipmentNumber());
Participant *participant = participantByEquipmentNumber(data.equipmentNumber);
if (!participant)
{
ERROR_LOG(m_logger) << LOGFUNCTION << "Could not find participant with equipment number " << data.equipmentNumber();
ERROR_LOG(m_logger) << LOGFUNCTION << "Could not find participant with equipment number " << data.equipmentNumber;
return;
}
if (participant->setOperatorAction(data.action(), data.operatorId(), data.sampleTime()))
if (participant->setOperatorAction(data.action, data.operatorId, data.sampleTime))
participant->publishDynamicData();
}
void ParticipantHandler::onEquipmentEvent(const TrainingAreaBase::EquipmentEvent &data)
{
// maybe use other commands later?!
if (data.source().subDeviceId() != 14 || data.source().equipmentFunctionId() != 5)
if (data.source.subDeviceId != 14 || data.source.equipmentFunctionId != 5)
return;
if (data.code() == 1 || data.code() == 2) // 1: 9Liner 2: Transport
if (data.code == 1 || data.code == 2) // 1: 9Liner 2: Transport
{
Participant *participant = participantByEquipmentNumber(data.equipmentNumber());
Participant *participant = participantByEquipmentNumber(data.equipmentNumber);
if (!participant)
return;
if (participant->setEquipmentEvent(data.code(), data.sampleTime()))
if (participant->setEquipmentEvent(data.code, data.sampleTime))
participant->publishDynamicData();
}
}
void ParticipantHandler::onNewFunctionalAreaEntryChanged(const TrainingAreaBase::FunctionalAreaEntry &data)
{
Participant *participant = participantByEquipmentNumber(data.equipmentNumber());
Participant *participant = participantByEquipmentNumber(data.equipmentNumber);
if (!participant)
{
ERROR_LOG(m_logger) << LOGFUNCTION << "Could not find participant with equipment number " << data.equipmentNumber();
ERROR_LOG(m_logger) << LOGFUNCTION << "Could not find participant with equipment number " << data.equipmentNumber;
return;
}
TrainingAreaBase::EquipmentPosition pos;
pos.equipmentNumber(data.equipmentNumber());
pos.sampleTime(data.sampleTime());
Core::GeoPosition geoPos(data.position().lon(), data.position().lat(), 0);
pos.position().position(geoPos);
pos.equipmentNumber = data.equipmentNumber;
pos.sampleTime = data.sampleTime;
Core::GeoPosition geoPos(data.position.lon, data.position.lat, 0);
pos.position.position = geoPos;
if (participant->setPosition(pos))
participant->publishPosition();
StateInformation oldState = youngestStateInformation(participant->dynamicParticipantData().stateHistory(), false);
StateInformation oldState = youngestStateInformation(participant->dynamicParticipantData().stateHistory, false);
TrainingAreaBase::EquipmentState state;
state.equipmentNumber(data.equipmentNumber());
state.originatorId(data.aesItemId());
state.originatorType(ProjectDataManagement::StateChangeOriginator::FunctionalArea);
state.sampleTime(data.sampleTime());
state.vulnerabilityState(ProjectDataManagement::VulnerabilityState::VulnerabilityState_HitWithNoEffect); // no effect - it's an entry into a functional area
state.vulnerabilityBits(oldState.vulnerabilityBits());
state.vulnerabilityKindId(oldState.vulnerabilityKindId());
state.vitality(oldState.vitality());
state.equipmentNumber = data.equipmentNumber;
state.originatorId = data.aesItemId;
state.originatorType = ProjectDataManagement::StateChangeOriginator::StateChangeOriginator_FunctionalArea;
state.sampleTime = data.sampleTime;
state.vulnerabilityState = ProjectDataManagement::VulnerabilityState::VulnerabilityState_HitWithNoEffect; // no effect - it's an entry into a functional area
state.vulnerabilityBits = oldState.vulnerabilityBits;
state.vulnerabilityKindId = oldState.vulnerabilityKindId;
state.vitality = oldState.vitality;
participant->setState(state, data.aesItemId());
participant->setState(state, data.aesItemId);
participant->publishDynamicData();
}
@@ -626,9 +626,9 @@ void ParticipantHandler::onHitLineInfoTimeout()
auto it = m_hitLineInfoMap.begin();
while (it != m_hitLineInfoMap.end())
{
if (!isOutdated(tNow, it.value().sampleTime()))
if (!isOutdated(tNow, it.value().sampleTime))
break;
dts()->removeHitLineInfoByKey(it.value().id());
dts()->removeHitLineInfoByKey(it.value().id);
it = m_hitLineInfoMap.erase(it);
}
@@ -636,11 +636,11 @@ void ParticipantHandler::onHitLineInfoTimeout()
void ParticipantHandler::setPosition(const ParticipantManagement::ParticipantPosition &data)
{
Participant *participant = participantById(data.participantId());
Participant *participant = participantById(data.participantId);
if (!participant)
{
ERROR_LOG(m_logger) << LOGFUNCTION << "Could not find participant with id " << data.participantId();
ERROR_LOG(m_logger) << LOGFUNCTION << "Could not find participant with id " << data.participantId;
return;
}
@@ -651,7 +651,7 @@ void ParticipantHandler::setHitlineInfoFromReplay(const HitLineInfo &data)
{
if (!dts()->publish(data))
return;
m_hitLineInfoMap.insert(data.id(), data);
m_hitLineInfoMap.insert(data.id, data);
}
void ParticipantHandler::setUASFromReplay(const UAS &data)
@@ -687,43 +687,43 @@ void ParticipantHandler::updateLaserDesignation(DynamicParticipantData &data, co
LOGGER_T m_logger = getLogger("ParticipantHandler.Laser");
DEBUG_LOG(m_logger) << "-Update Laser Designation - Start ";
for (LaserDesignation &laserDesignation : data.designations())
for (LaserDesignation &laserDesignation : data.designations)
{
if (laserDesignation.gearId() != newLaserDesignation.gearId())
if (laserDesignation.gearId != newLaserDesignation.gearId)
continue;
DEBUG_LOG(m_logger) << "-Update Laser Designation - Gear with id " << laserDesignation.gearId() << " found in designations";
laserDesignation.code(newLaserDesignation.code());
DEBUG_LOG(m_logger) << "-Update Laser Designation - Gear with id " << laserDesignation.gearId << " found in designations";
laserDesignation.code = newLaserDesignation.code;
if (!qFuzzyIsNull(laserDesignation.outputPower()) && !qFuzzyIsNull(newLaserDesignation.spotLocation().lat())
&& !qFuzzyIsNull(newLaserDesignation.spotLocation().lon()))
laserDesignation.spotLocation(Core::GeoPosition(newLaserDesignation.spotLocation().lon(), newLaserDesignation.spotLocation().lat(), 0.0));
if (!qFuzzyIsNull(laserDesignation.outputPower) && !qFuzzyIsNull(newLaserDesignation.spotLocation.lat)
&& !qFuzzyIsNull(newLaserDesignation.spotLocation.lon))
laserDesignation.spotLocation = Core::GeoPosition(newLaserDesignation.spotLocation.lon, newLaserDesignation.spotLocation.lat, 0.0);
// If Laser was on before and now is turned off, we have to reset spot Location
if (!qFuzzyIsNull(laserDesignation.outputPower()) && qFuzzyIsNull(newLaserDesignation.outputPower()))
laserDesignation.spotLocation(Core::GeoPosition(0.0, 0.0, 0.0));
if (!qFuzzyIsNull(laserDesignation.outputPower) && qFuzzyIsNull(newLaserDesignation.outputPower))
laserDesignation.spotLocation = Core::GeoPosition(0.0, 0.0, 0.0);
laserDesignation.outputPower(newLaserDesignation.outputPower());
laserDesignation.outputPower = newLaserDesignation.outputPower;
DEBUG_LOG(m_logger) << "-Update Laser Designation - Data updated, returning";
return;
}
DEBUG_LOG(m_logger) << "-Update Laser Designation - Gear with id " << newLaserDesignation.gearId() << " NOT found in designations";
DEBUG_LOG(m_logger) << "-Update Laser Designation - Gear with id " << newLaserDesignation.gearId << " NOT found in designations";
int gearId = newLaserDesignation.gearId();
auto it = std::find_if(data.gear().cbegin(), data.gear().cend(), [gearId](const GearInformation &gi) { return gearId == gi.gearId(); });
if (it == data.gear().cend()) // No gear, no designation...
int gearId = newLaserDesignation.gearId;
auto it = std::find_if(data.gear.cbegin(), data.gear.cend(), [gearId](const GearInformation &gi) { return gearId == gi.gearId; });
if (it == data.gear.cend()) // No gear, no designation...
{
DEBUG_LOG(m_logger) << "-Update Laser Designation - Gear with id " << newLaserDesignation.gearId() << " NOT found in Gears";
DEBUG_LOG(m_logger) << "-Update Laser Designation - Gear with id " << newLaserDesignation.gearId << " NOT found in Gears";
return;
}
DEBUG_LOG(m_logger) << "-Update Laser Designation - Gear with id " << newLaserDesignation.gearId() << " found in Gears";
DEBUG_LOG(m_logger) << "-Update Laser Designation - Gear with id " << newLaserDesignation.gearId << " found in Gears";
DEBUG_LOG(m_logger) << "-Update Laser Designation - Adding new designation";
data.designations().emplace_back(newLaserDesignation.gearId(),
Core::GeoPosition(newLaserDesignation.spotLocation().lon(), newLaserDesignation.spotLocation().lat(), 0.0),
newLaserDesignation.code(),
newLaserDesignation.outputPower());
data.designations.emplace_back(newLaserDesignation.gearId,
Core::GeoPosition(newLaserDesignation.spotLocation.lon, newLaserDesignation.spotLocation.lat, 0.0),
newLaserDesignation.code,
newLaserDesignation.outputPower);
}
void ParticipantHandler::updateLaserDesignation(DynamicParticipantData &dataInOut, const Buildings::BuildingHitLineInfo &newLaserDesignation)
@@ -733,28 +733,28 @@ void ParticipantHandler::updateLaserDesignation(DynamicParticipantData &dataInOu
// Mehrere Designatoren pro Teilnehmer werden nicht unterstützt.
DEBUG_LOG(m_logger) << "-Update Laser Designation by Building Hitline Info";
for (LaserDesignation &laserDesignation : dataInOut.designations())
for (LaserDesignation &laserDesignation : dataInOut.designations)
{
DEBUG_LOG(m_logger) << "-Update Laser Designation by Building Hitline Info - Updating (first) Designation with GearId " << laserDesignation.gearId();
laserDesignation.outputPower(1.0);
laserDesignation.spotLocation(newLaserDesignation.buildingPos());
DEBUG_LOG(m_logger) << "-Update Laser Designation by Building Hitline Info - Updating (first) Designation with GearId " << laserDesignation.gearId;
laserDesignation.outputPower = 1.0;
laserDesignation.spotLocation = newLaserDesignation.buildingPos;
return;
}
QSet<int> ldGearTypes{1043}; // Need Property for LTD...
auto it = std::find_if(dataInOut.gear().cbegin(), dataInOut.gear().cend(), [ldGearTypes](const GearInformation &gi) { return ldGearTypes.contains(gi.gearTypeId()); });
if (it != dataInOut.gear().cend())
auto it = std::find_if(dataInOut.gear.cbegin(), dataInOut.gear.cend(), [ldGearTypes](const GearInformation &gi) { return ldGearTypes.contains(gi.gearTypeId); });
if (it != dataInOut.gear.cend())
{
LaserDesignation ld;
ld.gearId() = it->gearId();
ld.code() = 0;
ld.spotLocation() = newLaserDesignation.buildingPos();
ld.outputPower(1.0);
dataInOut.designations().emplace_back(ld);
ld.gearId = it->gearId;
ld.code = 0;
ld.spotLocation = newLaserDesignation.buildingPos;
ld.outputPower = 1.0;
dataInOut.designations.emplace_back(ld);
ERROR_LOG(m_logger) << "-Update Laser Designation by Building Hitline Info - Added Designation";
}
ERROR_LOG(m_logger) << "-Update Laser Designation by Building Hitline Info - No laserDesignation available participantId="
<< newLaserDesignation.originatorParticipantId();
<< newLaserDesignation.originatorParticipantId;
}
void ParticipantHandler::removeLaserDesignation(DynamicParticipantData &data, qint32 gearId)
@@ -762,17 +762,17 @@ void ParticipantHandler::removeLaserDesignation(DynamicParticipantData &data, qi
LOGGER_T m_logger = getLogger("ParticipantHandler.Laser");
DEBUG_LOG(m_logger) << "-Remove Laser Designation: Start";
auto validationFunction = [gearId](ParticipantManagement::LaserDesignation laserDesignation) { return laserDesignation.gearId() == gearId; };
auto eraseIterator = std::find_if(data.designations().begin(), data.designations().end(), validationFunction);
auto validationFunction = [gearId](ParticipantManagement::LaserDesignation laserDesignation) { return laserDesignation.gearId == gearId; };
auto eraseIterator = std::find_if(data.designations.begin(), data.designations.end(), validationFunction);
if (eraseIterator == data.designations().end())
if (eraseIterator == data.designations.end())
{
DEBUG_LOG(m_logger) << "-Remove Laser Designation: GearId NOT found";
return;
}
DEBUG_LOG(m_logger) << "-Remove Laser Designation: Removing Designation";
data.designations().erase(eraseIterator);
data.designations.erase(eraseIterator);
}
} // namespace ParticipantHandling
@@ -151,10 +151,10 @@ class ParticipantHandler
static bool isSupportTypeClass(const TypeClass &typeClass);
// t - 11min <= sampleTime
template <typename T> inline bool isTelegramOutdated(const T &tele) const { return isSampleTimeOutdated(tele.sampleTime()); }
template <typename T> inline bool isTelegramOutdated(const T &tele) const { return isSampleTimeOutdated(tele.sampleTime); }
virtual bool isSampleTimeOutdated(qint64 sampleTime) const;
// sampleTime > t + 1min
template <typename T> inline bool isTelegramInFuture(const T &tele) const { return isSampleTimeInFuture(tele.sampleTime()); }
template <typename T> inline bool isTelegramInFuture(const T &tele) const { return isSampleTimeInFuture(tele.sampleTime); }
virtual bool isSampleTimeInFuture(qint64 sampleTime) const;
protected:
@@ -217,7 +217,7 @@ void ProxyListener::onLaserDesignationChanged(const TrainingAreaBase::LaserDesig
if (modType == DataModification::eRemoved)
{
DEBUG_LOG(m_logger) << "Got no laser designation data: " << data;
emit laserDesignationRemoved(data.equipmentNumber(), data.gearId());
emit laserDesignationRemoved(data.equipmentNumber, data.gearId);
return;
}
@@ -264,25 +264,25 @@ void ProxyListener::onUASStatusChanged(const TrainingAreaBase::UASStatus &data,
m_mainHandler->ddsHandler()->dtc()->waitForHistoricalDataParticipant(3000);
int participantId = m_mainHandler->ddsHandler()->dtc()->participantIdByEquipmentNumber(data.equipmentNumber());
int participantId = m_mainHandler->ddsHandler()->dtc()->participantIdByEquipmentNumber(data.equipmentNumber);
if (participantId <= 0)
return;
const auto uas = m_mainHandler->ddsHandler()->dtc()->getUasByParticipantId(participantId, m_mainHandler->exerciseId());
if (uas.id() <= 0)
if (uas.id <= 0)
return;
//new PPM Telegram
UASRadioLinkConnectionStatus newState;
newState.id(uas.id());
newState.uasState(data.uasState());
newState.id = uas.id;
newState.uasState = data.uasState;
DEBUG_LOG(m_logger) << "Publish new UAS State " << newState;
m_mainHandler->ddsHandler()->exAnyDts()->publish(newState);
}
void ProxyListener::onUASMissionStatusChanged(const TrainingAreaBase::UASMissionStatus &data, DataModification modType)
{
DEBUG_LOG(m_logger) << "currentTask = " << (int)data.currentTask().underlying() << ", currentMissionName = " << data.currentMissionName() << ", name of ended mission: " << data.missionEnded();
DEBUG_LOG(m_logger) << "currentTask = " << (int)data.currentTask << ", currentMissionName = " << data.currentMissionName << ", name of ended mission: " << data.missionEnded;
/*
was wenn random mehrfach hintereinander loiter gesendet wird??
dann überspringt er eine action! der tab darf also nur senden wenn wirklich ein state change kam
@@ -295,25 +295,25 @@ void ProxyListener::onUASMissionStatusChanged(const TrainingAreaBase::UASMission
return;
}
if (!data.currentMissionName().empty() || data.currentTask().underlying() != ProjectDataManagement::UasActionTask::Loiter || data.missionEnded().empty())
if (!data.currentMissionName.empty() || data.currentTask != ProjectDataManagement::UasActionTask::Loiter || data.missionEnded.empty())
{
//DEBUG As this will happen a lot
DEBUG_LOG(m_logger) << "not fulfilling current mission ("<<data.currentMissionName()<<") action because either a mission is still active or current task ("<<(int)data.currentTask().underlying()<<") is not Loiter or mission not ended ("<< data.missionEnded() << (data.missionEnded().empty() ? " [NOT ENDED]" : " [ ENDED ]")<<")";
DEBUG_LOG(m_logger) << "not fulfilling current mission ("<<data.currentMissionName<<") action because either a mission is still active or current task ("<<(int)data.currentTask<<") is not Loiter or mission not ended ("<< data.missionEnded << (data.missionEnded.empty() ? " [NOT ENDED]" : " [ ENDED ]")<<")";
return;
}
m_mainHandler->ddsHandler()->dtc()->waitForHistoricalDataParticipant(3000);
const int participantId = m_mainHandler->ddsHandler()->dtc()->participantIdByEquipmentNumber(data.equipmentNumber());
const int participantId = m_mainHandler->ddsHandler()->dtc()->participantIdByEquipmentNumber(data.equipmentNumber);
if (participantId <= 0)
{
ERROR_LOG(m_logger) << "participant for eqid " << data.equipmentNumber() << " not found - unable to fulfill current mission action";
ERROR_LOG(m_logger) << "participant for eqid " << data.equipmentNumber << " not found - unable to fulfill current mission action";
return;
}
QTimer::singleShot(1000, [this, participantId, data]() // give tab plugin time to clean stuff up before sending new missions (by marking an action as fulfilled)
{
// mission empty & task = loiter? mission done, run next mission (by setting current mission's current action as fulfilled, which will trigger the next action automatically (see ces))
if (!m_mainHandler->missionPlanHandler()->setCurrentMissionActionFulfilled(participantId, QString::fromStdString(data.missionEnded())))
if (!m_mainHandler->missionPlanHandler()->setCurrentMissionActionFulfilled(participantId, QString::fromStdString(data.missionEnded)))
{
ERROR_LOG(m_logger) << "setCurrentMissionActionFulfilled didn't work out";
return;
@@ -351,13 +351,13 @@ Core::FunctionReplyObject ProxyListener::demandVulnerabilityStateChange(const rt
if (!m_mainHandler->tabFtc()->demandVulnerabilityStateChangeRequest(req, this))
return Core::FunctionReplyObject(tr_lts("dds", "Error passing the Vulnerability state change request to the proxy"));
const int requestId = req.requestId();
const int requestId = req.requestId;
auto cb = [this, requestId]()
{
INFO_LOG(m_logger) << "VulnerabilityStateChange timeout for " << requestId;
onDemandVulnerabilityStateChangeReply(Core::FunctionReplyObject(requestId, tr_lts("dds", "Timeout while waiting for the proxy")));
};
addToTrainingAreaRequests(cb, req.requestId(), cookie);
addToTrainingAreaRequests(cb, req.requestId, cookie);
return Core::FunctionReplyObject();
}
@@ -374,17 +374,17 @@ void ProxyListener::onDemandVulnerabilityStateChangeReply(const Core::FunctionRe
Core::FunctionReplyObject ProxyListener::sendModifyUasStateRequest(const rti::core::SampleIdentity &cookie,
const TrainingAreaBase::SendModifyUasStateRequest &req)
{
DEBUG_LOG(m_logger) << " -- [ProxyListener] sendModifyUasStateRequest uasId: " << req.uasId();
DEBUG_LOG(m_logger) << " -- [ProxyListener] sendModifyUasStateRequest uasId: " << req.uasId;
if (!m_mainHandler->tabFtc()->sendModifyUasStateRequest(req, this))
return Core::FunctionReplyObject(tr_lts("dds", "Error passing the UAS state change request to the proxy"));
const int requestId = req.requestId();
const int requestId = req.requestId;
auto cb = [this, requestId]()
{
INFO_LOG(m_logger) << "ModifyUasState timeout for " << requestId;
onSendModifyUasStateReply(Core::FunctionReplyObject(requestId, tr_lts("dds", "Timeout while waiting for the proxy")));
};
addToTrainingAreaRequests(cb, req.requestId(), cookie);
addToTrainingAreaRequests(cb, req.requestId, cookie);
return Core::FunctionReplyObject();
}
@@ -404,13 +404,13 @@ Core::FunctionReplyObject ProxyListener::demandInitRequest(const rti::core::Samp
if (!m_mainHandler->tabFtc()->demandInitRequest(req, this))
return Core::FunctionReplyObject(tr_lts("dds", "Error passing the INIT request to the proxy"));
const int requestId = req.requestId();
const int requestId = req.requestId;
auto cb = [this, requestId]()
{
INFO_LOG(m_logger) << "DemandInit timeout for " << requestId;
onDemandInitReply(Core::FunctionReplyObject(requestId, tr_lts("dds", "Timeout while waiting for the proxy")));
};
addToTrainingAreaRequests(cb, req.requestId(), cookie);
addToTrainingAreaRequests(cb, req.requestId, cookie);
return Core::FunctionReplyObject();
}
@@ -431,13 +431,13 @@ Core::FunctionReplyObject ProxyListener::sendEquipmentMessage(const rti::core::S
if (!m_mainHandler->tabFtc()->sendEquipmentMessageRequest(req, this))
return Core::FunctionReplyObject(tr_lts("dds", "Error passing SendMessage request to the proxy"));
const int requestId = req.requestId();
const int requestId = req.requestId;
auto cb = [this, requestId]()
{
INFO_LOG(m_logger) << "SendMessage timeout for " << requestId;
onSendEquipmentMessageReply(Core::FunctionReplyObject(requestId, tr_lts("dds", "Timeout while waiting for the proxy")));
};
addToTrainingAreaRequests(cb, req.requestId(), cookie);
addToTrainingAreaRequests(cb, req.requestId, cookie);
return Core::FunctionReplyObject();
}
@@ -456,17 +456,17 @@ Core::FunctionReplyObject ProxyListener::sendParticipantModeRequest(const rti::c
const TrainingAreaBase::SendParticipantModeRequest &req)
{
if (!m_mainHandler->tabFtc()->sendParticipantModeRequest(req, this))
return Core::FunctionReplyObject(req.participantId(), tr_lts("dds", "Error passing the INIT request to the proxy"));
return Core::FunctionReplyObject(req.participantId, tr_lts("dds", "Error passing the INIT request to the proxy"));
const int requestId = req.requestId();
const int requestId = req.requestId;
auto cb = [this, requestId]()
{
INFO_LOG(m_logger) << "SendParticipantMode timeout for " << requestId;
onSendParticipantModeReply(Core::FunctionReplyObject(requestId, tr_lts("dds", "Timeout while waiting for the proxy")));
};
addToTrainingAreaRequests(cb, req.requestId(), cookie);
addToTrainingAreaRequests(cb, req.requestId, cookie);
return Core::FunctionReplyObject(req.participantId());
return Core::FunctionReplyObject(req.participantId);
}
void ProxyListener::onSendParticipantModeReply(const Core::FunctionReplyObject &replyObject)
@@ -481,15 +481,15 @@ void ProxyListener::onSendParticipantModeReply(const Core::FunctionReplyObject &
Core::FunctionReplyObject ProxyListener::sendSetSanitationRequest(const rti::core::SampleIdentity &cookie, const TrainingAreaBase::SendSetSanitationRequest &req)
{
if (!m_mainHandler->tabFtc()->sendSetSanitationRequest(req, this))
return Core::FunctionReplyObject(req.participantId(), tr_lts("dds", "Error passing the SetSanitation request to the proxy"));
const int requestId = req.requestId();
return Core::FunctionReplyObject(req.participantId, tr_lts("dds", "Error passing the SetSanitation request to the proxy"));
const int requestId = req.requestId;
auto cb = [this, requestId]()
{
INFO_LOG(m_logger) << "sendSetSanitationRequest timeout for " << requestId;
onSendSetSanitationReply(Core::FunctionReplyObject(requestId, tr_lts("dds", "Timeout while waiting for the proxy")));
};
addToTrainingAreaRequests(cb, req.requestId(), cookie);
return Core::FunctionReplyObject(req.participantId());
addToTrainingAreaRequests(cb, req.requestId, cookie);
return Core::FunctionReplyObject(req.participantId);
}
void ProxyListener::onSendSetSanitationReply(const Core::FunctionReplyObject &replyObject)
@@ -504,15 +504,15 @@ void ProxyListener::onSendSetSanitationReply(const Core::FunctionReplyObject &re
Core::FunctionReplyObject ProxyListener::selectiveReammunitionRequest(const rti::core::SampleIdentity &cookie, const TrainingAreaBase::SendSelectiveReammunitionRequest &req)
{
if (!m_mainHandler->tabFtc()->sendSelectiveReammunitionRequest(req, this))
return Core::FunctionReplyObject(req.participantId(), tr_lts("dds", "Error passing the SendSelectiveReammunition request to the proxy"));
const int requestId = req.requestId();
return Core::FunctionReplyObject(req.participantId, tr_lts("dds", "Error passing the SendSelectiveReammunition request to the proxy"));
const int requestId = req.requestId;
auto cb = [this, requestId]()
{
INFO_LOG(m_logger) << "selectiveReammunitionRequest timeout for " << requestId;
onSendSelectiveReammunitionReply(Core::FunctionReplyObject(requestId, tr_lts("dds", "Timeout while waiting for the proxy")));
};
addToTrainingAreaRequests(cb, req.requestId(), cookie);
return Core::FunctionReplyObject(req.participantId());
addToTrainingAreaRequests(cb, req.requestId, cookie);
return Core::FunctionReplyObject(req.participantId);
}
void ProxyListener::onSendSelectiveReammunitionReply(const Core::FunctionReplyObject &replyObject)
@@ -531,13 +531,13 @@ Core::FunctionReplyObject ProxyListener::sendOcCommandRequest(const rti::core::S
if (!m_mainHandler->tabFtc()->sendOcCommandRequest(req, this))
return Core::FunctionReplyObject(tr_lts("dds", "Error passing the OcCommand request to the proxy"));
const int requestId = req.requestId();
const int requestId = req.requestId;
auto cb = [this, requestId]()
{
INFO_LOG(m_logger) << "SendOcCommand timeout for " << requestId;
onSendOcCommandReply(Core::FunctionReplyObject(requestId, tr_lts("dds", "Timeout while waiting for the proxy")));
};
addToTrainingAreaRequests(cb, req.requestId(), cookie);
addToTrainingAreaRequests(cb, req.requestId, cookie);
return Core::FunctionReplyObject();
}
@@ -80,13 +80,13 @@ void UnitPositionCalculator::onPositionChanged(int participantId, int64_t positi
DEBUG_LOG(m_logger) << "Position for participant " << participantId << " changed to "
<< pos << " (" << positionTime / 1000 << "s)";
CalculatedUnitPosition &data = getParticipant(participantId);
if (data.sampleTimeLeader() >= positionTime)
if (data.sampleTimeLeader >= positionTime)
return;
data.sampleTimeCenter(positionTime);
data.sampleTimeLeader(positionTime);
data.positionCenter(pos);
data.positionLeader(pos);
data.sampleTimeCenter = positionTime;
data.sampleTimeLeader = positionTime;
data.positionCenter = pos;
data.positionLeader = pos;
m_bSomethingChangedSinceLastCalculation = true;
}
@@ -122,10 +122,10 @@ UnitPositionCalculator::CalculatedUnitPosition &UnitPositionCalculator::getParti
DEBUG_LOG(m_logger) << "No information for participant " << participantId << " - creating dummy data";
CalculatedUnitPosition data;
data.participantId(participantId);
data.participantId = participantId;
static const Core::GeoPosition s_invalidPos(std::nan(""), std::nan(""), std::nan(""));
data.positionCenter(s_invalidPos);
data.positionLeader(s_invalidPos);
data.positionCenter = s_invalidPos;
data.positionLeader = s_invalidPos;
it = m_participantData.insert({participantId, std::move(data)}).first;
}
return it->second;
@@ -174,12 +174,12 @@ UnitPositionCalculator::Result UnitPositionCalculator::doCalculation(std::unorde
for (const auto &data : participantData)
{
const int superiorId = data.second.superiorId;
const int participantId = data.second.participantId();
const int participantId = data.second.participantId;
DEBUG_LOG(logger) << "Participant " << participantId << " has superior " << superiorId;
if (superiorId == 0 || participantData.find(superiorId) == participantData.end())
{
DEBUG_LOG(logger) << "Participant " << participantId << " is a toplevel participant";
topLevelIds.push_back(data.second.participantId());
topLevelIds.push_back(data.second.participantId);
}
}
// TODO: check for correct (non-cyclic) hierarchy?
@@ -214,13 +214,13 @@ void UnitPositionCalculator::calculatePosition(int participantId,
if (data.inferiorIds.size() == 0)
{
DEBUG_LOG(logger) << dbgLvlSpaces << "Participant " << participantId
<< " is a leaf: " << data.positionCenter()
<< " (" << data.sampleTimeCenter() / 1000 << "s)";
<< " is a leaf: " << data.positionCenter
<< " (" << data.sampleTimeCenter / 1000 << "s)";
return;
}
data.positionCenter(s_invalidPos);
data.positionLeader(s_invalidPos);
data.positionCenter = s_invalidPos;
data.positionLeader = s_invalidPos;
// calculate position for inferiors
DEBUG_LOG(logger) << dbgLvlSpaces << "Participant " << participantId << ": Start calculating child positions";
@@ -249,15 +249,15 @@ void UnitPositionCalculator::calculatePosition(int participantId,
const CalculatedUnitPosition &child = itChild->second;
// older than 10 minutes -> ignore
if (LtsUtils::isPositionTimeOutdated(currentTime, child.sampleTimeCenter()))
if (LtsUtils::isPositionTimeOutdated(currentTime, child.sampleTimeCenter))
{
DEBUG_LOG(logger) << dbgLvlSpaces << "Child " << inferiorId << ": position out-of-date - ignoring";
continue;
}
// invalid position -> ignore
if (std::isnan(child.positionCenter().lon()) ||
std::isnan(child.positionCenter().lat()))
if (std::isnan(child.positionCenter.lon) ||
std::isnan(child.positionCenter.lat))
{
DEBUG_LOG(logger) << dbgLvlSpaces << "Child " << inferiorId << ": has invalid position - ignoring";
continue;
@@ -266,36 +266,36 @@ void UnitPositionCalculator::calculatePosition(int participantId,
if (bFirst)
{
bFirst = false;
data.positionLeader(child.positionLeader());
data.sampleTimeLeader(child.sampleTimeLeader());
data.positionLeader = child.positionLeader;
data.sampleTimeLeader = child.sampleTimeLeader;
}
const auto utm = LtsCoordTrans::UtmCoordinate::fromGeographic(child.positionCenter().lon(),
child.positionCenter().lat(),
const auto utm = LtsCoordTrans::UtmCoordinate::fromGeographic(child.positionCenter.lon,
child.positionCenter.lat,
utmZone);
if (utmZone == -1)
utmZone = utm.zone;
pos += LtsUtils::QPoint3D(utm.x, utm.y, child.positionCenter().z());
if (child.sampleTimeCenter() > childPositionTime)
childPositionTime = child.sampleTimeCenter();
pos += LtsUtils::QPoint3D(utm.x, utm.y, child.positionCenter.z);
if (child.sampleTimeCenter > childPositionTime)
childPositionTime = child.sampleTimeCenter;
++childCount;
}
data.sampleTimeCenter(childPositionTime);
data.sampleTimeCenter = childPositionTime;
if (childCount > 0)
{
pos /= childCount;
const LtsCoordTrans::UtmCoordinate utm(utmZone, pos.x(), pos.y(),true);
const QPointF lonLat = utm.geographic();
data.positionCenter(Core::GeoPosition(lonLat.x(), lonLat.y(), pos.z()));
data.positionCenter = Core::GeoPosition(lonLat.x(), lonLat.y(), pos.z());
}
DEBUG_LOG(logger) << dbgLvlSpaces
<< "Participant " << participantId
<< ": Mean position: " << data.positionCenter()
<< ": Mean position: " << data.positionCenter
<< " #relavant children: " << childCount
<< " (" << data.sampleTimeCenter() / 1000 << "s)";
<< " (" << data.sampleTimeCenter / 1000 << "s)";
result.push_back(std::move(data));
}
@@ -307,7 +307,7 @@ void UnitPositionCalculator::onCalculationDone()
auto dts = m_participantHandler->dts();
for (const auto &pos : calculatedPositions)
{
auto it = m_publishedPositionData.find(pos.participantId());
auto it = m_publishedPositionData.find(pos.participantId);
if (it != m_publishedPositionData.end())
{
ParticipantManagement::UnitPosition &up = it->second;
@@ -315,13 +315,13 @@ void UnitPositionCalculator::onCalculationDone()
if (up == pos)
continue;
// nan == nan is always false, have to check it on our own
if (std::isnan(up.positionCenter().lat()) && std::isnan(pos.positionCenter().lat()))
if (std::isnan(up.positionCenter.lat) && std::isnan(pos.positionCenter.lat))
continue;
up = pos;
}
else
{
m_publishedPositionData.insert(std::make_pair(pos.participantId(), pos));
m_publishedPositionData.insert(std::make_pair(pos.participantId, pos));
}
dts->publish(pos);
}
@@ -11,26 +11,26 @@
bool ParticipantManagement::PartyHandling::Party::hasChanges(const ParticipantManagement::Party &request,
const bool bIgnoreIsUsedBy)
{
const QString requestProperties = QString::fromStdString(request.properties());
bool hasChanges = request.color() != m_data.color
|| request.fadingColor() != m_data.fadingColor
|| request.name() != m_data.name.toStdString()
|| request.hlaForceIdentifier().underlying() != m_data.hlaForceIdentifier
|| request.role() != m_data.roleId
const QString requestProperties = QString::fromStdString(request.properties);
bool hasChanges = request.color != m_data.color
|| request.fadingColor != m_data.fadingColor
|| request.name != m_data.name.toStdString()
|| static_cast<int>(request.hlaForceIdentifier) != m_data.hlaForceIdentifier
|| request.role != m_data.roleId
|| requestProperties != m_data.properties;
if (!bIgnoreIsUsedBy && !hasChanges)
hasChanges = request.isUsedBy() != m_data.isUsedBy;
hasChanges = request.isUsedBy != m_data.isUsedBy;
if (hasChanges)
{
m_data.color = request.color();
m_data.fadingColor = request.fadingColor();
m_data.name = QString::fromStdString(request.name());
m_data.roleId = request.role();
m_data.hlaForceIdentifier = request.hlaForceIdentifier().underlying();
m_data.color = request.color;
m_data.fadingColor = request.fadingColor;
m_data.name = QString::fromStdString(request.name);
m_data.roleId = request.role;
m_data.hlaForceIdentifier = static_cast<int>(request.hlaForceIdentifier);
m_data.properties = requestProperties;
if (!bIgnoreIsUsedBy)
m_data.isUsedBy = request.isUsedBy();
m_data.isUsedBy = request.isUsedBy;
}
return hasChanges;
@@ -45,15 +45,15 @@ ParticipantManagement::Party ParticipantManagement::PartyHandling::Party::toDdsP
{
ParticipantManagement::Party result;
result.id(id());
result.color(m_data.color);
result.fadingColor(m_data.fadingColor);
result.name(m_data.name.toStdString());
result.role(m_data.roleId);
result.hlaForceIdentifier(static_cast<HlaForceIdentifierEnum>(m_data.hlaForceIdentifier));
result.isUsedBy(m_data.isUsedBy);
result.sampleTime(QDateTime::currentMSecsSinceEpoch());
result.properties(m_data.properties.toStdString());
result.id = id();
result.color = m_data.color;
result.fadingColor = m_data.fadingColor;
result.name = m_data.name.toStdString();
result.role = m_data.roleId;
result.hlaForceIdentifier = static_cast<HlaForceIdentifierEnum>(m_data.hlaForceIdentifier);
result.isUsedBy = m_data.isUsedBy;
result.sampleTime = QDateTime::currentMSecsSinceEpoch();
result.properties = m_data.properties.toStdString();
return result;
}
@@ -93,7 +93,7 @@ void PartyHandling::PartyHandler::resetAdlerProperties( QString &properties, con
if (connectState != ParticipantManagement::ConnectState::Disconnected)
{
QJsonObject propAdler = obj[QStringLiteral("Adler")].toObject();
propAdler[QStringLiteral("saaConnectedState")] = ParticipantManagement::ConnectState::Disconnected;
propAdler[QStringLiteral("saaConnectedState")] = static_cast<int>(ParticipantManagement::ConnectState::Disconnected);
obj[QStringLiteral("Adler")] = propAdler;
const QByteArray propertiesStr = QJsonDocument(obj).toJson(QJsonDocument::Compact);
properties = QString::fromStdString(propertiesStr.data());
@@ -149,11 +149,11 @@ void PartyHandling::PartyHandler::onModifyPartyDataRequest(const rti::core::Samp
Core::FunctionReplyObject PartyHandling::PartyHandler::modifyPartyDataRequest(const ParticipantManagement::Party &request)
{
DEBUG_LOG(m_logger) << "onModifyPartyDataRequest: " << request;
Party *partyToPublish = m_parties.value(request.id());
Party *partyToPublish = m_parties.value(request.id);
if (!partyToPublish && request.id() >= 0)
return Core::FunctionReplyObject(request.id(), tr_lts("dds", "Could not modify party with id %1, because no party with that id exists"))
.arg(request.id());
if (!partyToPublish && request.id >= 0)
return Core::FunctionReplyObject(request.id, tr_lts("dds", "Could not modify party with id %1, because no party with that id exists"))
.arg(request.id);
if (!partyToPublish) // create new party
{
@@ -162,19 +162,19 @@ Core::FunctionReplyObject PartyHandling::PartyHandler::modifyPartyDataRequest(co
// insert into database
Database::PpmParty newDbParty;
newDbParty.color = request.color();
newDbParty.fadingColor = request.fadingColor();
newDbParty.name = QString::fromStdString(request.name());
newDbParty.roleId = request.role();
newDbParty.isUsedBy = request.isUsedBy();
newDbParty.hlaForceIdentifier = request.hlaForceIdentifier().underlying();
newDbParty.properties = QString::fromStdString(request.properties());
newDbParty.color = request.color;
newDbParty.fadingColor = request.fadingColor;
newDbParty.name = QString::fromStdString(request.name);
newDbParty.roleId = request.role;
newDbParty.isUsedBy = request.isUsedBy;
newDbParty.hlaForceIdentifier = static_cast<int>(request.hlaForceIdentifier);
newDbParty.properties = QString::fromStdString(request.properties);
if (!m_mainHandler->db()->insert(newDbParty))
{
QString errText = m_mainHandler->db()->getLastError().databaseText();
ERROR_LOG(m_logger) << "Error inserting Party into database: " << errText;
return Core::FunctionReplyObject(request.id(), tr_lts("dds", "Error inserting new party to database: %1")).arg(errText);
return Core::FunctionReplyObject(request.id, tr_lts("dds", "Error inserting new party to database: %1")).arg(errText);
}
partyToPublish = new Party(newDbParty);
@@ -189,7 +189,7 @@ Core::FunctionReplyObject PartyHandling::PartyHandler::modifyPartyDataRequest(co
else // update in database
{
if (!m_mainHandler->db()->update(partyToPublish->toDbParty()))
return Core::FunctionReplyObject(request.id(), tr_lts("dds", "Error updating party in database"));
return Core::FunctionReplyObject(request.id, tr_lts("dds", "Error updating party in database"));
}
}
if (partyToPublish)
@@ -197,7 +197,7 @@ Core::FunctionReplyObject PartyHandling::PartyHandler::modifyPartyDataRequest(co
auto party = partyToPublish->toDdsParty();
m_mainHandler->dts()->publish(party);
}
return Core::FunctionReplyObject(request.id());
return Core::FunctionReplyObject(request.id);
}
//------------------------------------------------------------------------------------------
@@ -217,18 +217,18 @@ Core::FunctionReplyObject PartyHandling::PartyHandler::removePartyRequest(const
{
DEBUG_LOG(m_logger) << "onRemovePartyRequest " << request;
if (request.partyId() < 0)
if (request.partyId < 0)
return Core::FunctionReplyObject(tr_lts("dds", "Got request to delete a party, but no valid party id to delete"));
Party *partyToDelete = m_parties.value(request.partyId());
Party *partyToDelete = m_parties.value(request.partyId);
if (!partyToDelete)
return Core::FunctionReplyObject(tr_lts("dds", "Could not delete party with id %1, because no party with that id exists"))
.arg(request.partyId());
.arg(request.partyId);
if (partyToDelete->isUsedBy() == true)
return Core::FunctionReplyObject(tr_lts("dds", "Not possible to delete a party in use"));
DEBUG_LOG(m_logger) << "Removing party with ID " << request.partyId();
DEBUG_LOG(m_logger) << "Removing party with ID " << request.partyId;
return removeParty(partyToDelete);
}
@@ -299,17 +299,17 @@ void PartyHandling::PartyHandler::onSyncPartiesRequest(const rti::core::SampleId
if (hasChanges)
{
ParticipantManagement::Party req;
req.id(partyId);
req.id = partyId;
// taking new properties from ex_0
req.color(partyEx0.color);
req.fadingColor(partyEx0.fadingColor);
req.name(partyEx0.name.toStdString());
req.role(partyEx0.roleId);
req.hlaForceIdentifier(static_cast<HlaForceIdentifierEnum>(partyEx0.hlaForceIdentifier));
req.color = partyEx0.color;
req.fadingColor = partyEx0.fadingColor;
req.name = partyEx0.name.toStdString();
req.role = partyEx0.roleId;
req.hlaForceIdentifier = static_cast<HlaForceIdentifierEnum>(partyEx0.hlaForceIdentifier);
// this remains as it is
req.isUsedBy(partyEx->isUsedBy());
req.isUsedBy = partyEx->isUsedBy();
auto ret = modifyPartyDataRequest(req);
if (ret.error())
@@ -363,22 +363,22 @@ void PartyHandling::PartyHandler::onChangePartyUsedStateRequest(const rti::core:
//------------------------------------------------------------------------------------------
Core::FunctionReplyObject PartyHandling::PartyHandler::changePartyUsedStateRequest(const ParticipantManagement::ChangePartyUsedStateRequest &request)
{
Party *party = m_parties.value(request.partyId());
Party *party = m_parties.value(request.partyId);
if (!party)
return Core::FunctionReplyObject(request.partyId(), tr_lts("dds", "Could not modify party with id %1, because no party with that id exists"))
.arg(request.partyId());
return Core::FunctionReplyObject(request.partyId, tr_lts("dds", "Could not modify party with id %1, because no party with that id exists"))
.arg(request.partyId);
ParticipantManagement::Party ddsParty = party->toDdsParty();
ddsParty.isUsedBy(request.isUsedBy());
ddsParty.isUsedBy = request.isUsedBy;
if (party->hasChanges(ddsParty, false))
{
if (!m_mainHandler->db()->update(party->toDbParty()))
return Core::FunctionReplyObject(request.partyId(), tr_lts("dds", "Error updating party used state in database"));
return Core::FunctionReplyObject(request.partyId, tr_lts("dds", "Error updating party used state in database"));
DEBUG_LOG(m_logger) << "Change used state for party " << party->id() << " to " << party->isUsedBy();
m_mainHandler->dts()->publish(party->toDdsParty());
}
return Core::FunctionReplyObject(request.partyId());
return Core::FunctionReplyObject(request.partyId);
}
@@ -27,36 +27,36 @@ ParticipantHandlerForReplay::ParticipantHandlerForReplay(RecordReplayPluginCusto
static inline Database::PpmParticipant toDb(const ParticipantManagement::Participant &ddsPart)
{
Database::PpmParticipant db;
db.id = ddsPart.id();
db.assignState = ddsPart.assignState();
db.partyId = ddsPart.partyId();
db.typeId = ddsPart.typeId();
db.externalId = ddsPart.externalId();
db.designator = QString::fromStdString(ddsPart.designator());
db.equipmentNumber = ddsPart.equipmentNumber.is_set() ? ddsPart.equipmentNumber.get() : 0;
db.hierarchyNumber = ddsPart.hierarchyNumber();
db.identification = QString::fromStdString(ddsPart.identification());
db.info = QString::fromStdString(ddsPart.info());
db.isDeleted = ddsPart.isDeleted();
db.isSimulated = ddsPart.isSimulated();
db.name = QString::fromStdString(ddsPart.name());
db.superiorId = ddsPart.superiorId();
db.symbol = QString::fromStdString(ddsPart.symbol());
db.tacticalIdentifier = QString::fromStdString(ddsPart.tacticalIdentifier());
db.properties = QString::fromStdString(ddsPart.properties());
db.id = ddsPart.id;
db.assignState = ddsPart.assignState;
db.partyId = ddsPart.partyId;
db.typeId = ddsPart.typeId;
db.externalId = ddsPart.externalId;
db.designator = QString::fromStdString(ddsPart.designator);
db.equipmentNumber = ddsPart.equipmentNumber.has_value() ? ddsPart.equipmentNumber.get() : 0;
db.hierarchyNumber = ddsPart.hierarchyNumber;
db.identification = QString::fromStdString(ddsPart.identification);
db.info = QString::fromStdString(ddsPart.info);
db.isDeleted = ddsPart.isDeleted;
db.isSimulated = ddsPart.isSimulated;
db.name = QString::fromStdString(ddsPart.name);
db.superiorId = ddsPart.superiorId;
db.symbol = QString::fromStdString(ddsPart.symbol);
db.tacticalIdentifier = QString::fromStdString(ddsPart.tacticalIdentifier);
db.properties = QString::fromStdString(ddsPart.properties);
return db;
}
void ParticipantHandlerForReplay::createUpdateParticipant(const ParticipantManagement::Participant &ddsPart)
{
auto *p = m_participants.value(ddsPart.id());
auto *p = m_participants.value(ddsPart.id);
if (!p)
{
p = new ParticipantForReplay(this,
m_unitPositionCalculator.get(),
toDb(ddsPart));
m_participants.insert(ddsPart.id(), p);
m_participants.insert(ddsPart.id, p);
}
else
{
@@ -68,7 +68,7 @@ void ParticipantHandlerForReplay::removeParticipant(const ParticipantManagement:
{
// maybe clear m_hitLineInfoMap for this participant also but is this a real-world problem?
auto *p = m_participants.take(ddsPart.id());
auto *p = m_participants.take(ddsPart.id);
if (p)
{
p->removeFromDds();
@@ -79,9 +79,9 @@ void ParticipantHandlerForReplay::removeParticipant(const ParticipantManagement:
void ParticipantHandlerForReplay::setDynamicParticipantData(const ParticipantManagement::DynamicParticipantData &dynPart)
{
auto *p = m_participants.value(dynPart.participantId());
auto *p = m_participants.value(dynPart.participantId);
if (!p) {
WARNING_LOG(m_logger) << "Got dynamic participant data for unknown participant with id " << dynPart.participantId();
WARNING_LOG(m_logger) << "Got dynamic participant data for unknown participant with id " << dynPart.participantId;
return;
}
p->setDynamicData(dynPart);
@@ -88,7 +88,7 @@ void RecordReplayPluginCustom::removeOld(QMultiMap<long long, T> &map, qint64 de
for (const auto &inner : map.values(item))
{
// Remove delted ones
if (inner.isDeleted())
if (inner.isDeleted)
{
map.remove(item, inner);
}
@@ -125,7 +125,7 @@ bool RecordReplayPluginCustom::setReplayStartTime(NSqlQuery &q, qint64 startTime
// {
// for (const auto &p : m_participantMap)
// {
// if (p.equipmentNumber.is_set())
// if (p.equipmentNumber.has_value())
// m_equipmentNumbers.insert(p.equipmentNumber.get());
// }
// DEBUG_LOG(m_logger) << "setReplayStartTime-m_equipmentNumbers after" << m_equipmentNumbers.count();
@@ -144,7 +144,7 @@ bool RecordReplayPluginCustom::setReplayStartTime(NSqlQuery &q, qint64 startTime
const auto &inner = backup.values(key);
for (const auto &value : inner)
{
if (m_participantKeys.find(value.participantId()) == m_participantKeys.end())
if (m_participantKeys.find(value.participantId) == m_participantKeys.end())
m_dynamicParticipantDataMap.remove(key, value);
}
}
@@ -334,7 +334,7 @@ QVector<QFuture<void>> RecordReplayPluginCustom::makeConcurrent(T &content, qint
for (auto it = contentIndex.begin(); it != contentIndex.end(); ++it)
{
// following is relavant to a) OPTIMZE = true; // GUEZE-3521 and b) E01562-183 "Prüfung Replay"
if (m_equipmentNumbers.isEmpty() || m_equipmentNumbers.contains(abs(it->equipmentNumber())))
if (m_equipmentNumbers.isEmpty() || m_equipmentNumbers.contains(abs(it->equipmentNumber)))
m_participantHandler->newData(*it);
}
}));
@@ -80,7 +80,7 @@ void HandlerTargetInformation::onModifyTargetInformationRequest(const rti::core:
Core::FunctionReplyObject HandlerTargetInformation::targetInformationModifyRequest(const ModifyTargetInformationRequest &request)
{
TRACE_LOG(m_logger) << LOGFUNCTION << " START";
const int requestId = request.targetInfo().id();
const int requestId = request.targetInfo.id;
// modify
if (requestId > 0)
{
@@ -88,12 +88,12 @@ Core::FunctionReplyObject HandlerTargetInformation::targetInformationModifyReque
if (!ifs)
return Core::FunctionReplyObject(requestId, tr_lts("dds", "TargetInformation with id %1 not found")).arg(requestId);
auto ret = ifs->updateObject(request.targetInfo());
auto ret = ifs->updateObject(request.targetInfo);
return ret;
}
// create
ObjectTargetInformation *ifs(new ObjectTargetInformation(m_mainHandler));
auto ret = ifs->createObject(request.targetInfo());
auto ret = ifs->createObject(request.targetInfo);
if (ret.error())
{
delete ifs;
@@ -112,11 +112,11 @@ void HandlerTargetInformation::onRemoveTargetInformationRequest(const rti::core:
TRACE_LOG(m_logger) << LOGFUNCTION << " request=" << request;
Core::FunctionReplyObject ret;
ObjectTargetInformation *ifs = m_objectMap.value(request.id());
ObjectTargetInformation *ifs = m_objectMap.value(request.id);
if (ifs == nullptr)
{
ret = Core::FunctionReplyObject(request.id(), tr_lts("dds", "ShootbackTarget with id %1 not found")).arg(request.id());
ret = Core::FunctionReplyObject(request.id, tr_lts("dds", "ShootbackTarget with id %1 not found")).arg(request.id);
m_mainHandler->fts()->removeTargetInformationReply(cookie, ret);
return;
}
@@ -128,7 +128,7 @@ void HandlerTargetInformation::onRemoveTargetInformationRequest(const rti::core:
{
// delete Object
delete ifs;
m_objectMap.remove(request.id());
m_objectMap.remove(request.id);
}
m_mainHandler->fts()->removeTargetInformationReply(cookie, ret);
@@ -25,19 +25,19 @@ Core::GeoPosition2D posFromJson(const QJsonValue &val)
Core::GeoPosition2D element;
{
const QJsonValue valLon(objElement.value(QStringLiteral("lon")));
element.lon(valLon.toDouble());
element.lon = valLon.toDouble();
}
{
const QJsonValue valLat(objElement.value(QStringLiteral("lat")));
element.lat(valLat.toDouble());
element.lat = valLat.toDouble();
}
return element;
}
QJsonObject toJson(const Core::GeoPosition2D &element)
{
QJsonObject obj;
obj[QStringLiteral("lon")] = element.lon();
obj[QStringLiteral("lat")] = element.lat();
obj[QStringLiteral("lon")] = element.lon;
obj[QStringLiteral("lat")] = element.lat;
return obj;
}
@@ -47,15 +47,15 @@ ShootbackArea areaFromJson(const QJsonValue &val)
{
ShootbackArea area;
// use val.toObject().value instead val[key] introduced with qt5.10
area.identifier(val.toObject().value(QStringLiteral("identifier")).toString().toStdString());
area.identifier = val.toObject().value(QStringLiteral("identifier")).toString().toStdString();
if (val.toObject().value(QStringLiteral("coords")).isArray())
{
const QJsonArray &arr = val.toObject().value(QStringLiteral("coords")).toArray();
if (arr.size() > 0) area.coord1( posFromJson(arr.at(0)) );
if (arr.size() > 1) area.coord2( posFromJson(arr.at(1)) );
if (arr.size() > 2) area.coord3( posFromJson(arr.at(2)) );
if (arr.size() > 3) area.coord4( posFromJson(arr.at(3)) );
if (arr.size() > 0) area.coord1 = posFromJson(arr.at(0));
if (arr.size() > 1) area.coord2 = posFromJson(arr.at(1));
if (arr.size() > 2) area.coord3 = posFromJson(arr.at(2));
if (arr.size() > 3) area.coord4 = posFromJson(arr.at(3));
}
return area;
}
@@ -63,13 +63,13 @@ ShootbackArea areaFromJson(const QJsonValue &val)
QJsonObject toJson(const ShootbackArea &area)
{
QJsonObject obj;
obj.insert(QStringLiteral("identifier"), QString::fromStdString(area.identifier()));
obj.insert(QStringLiteral("identifier"), QString::fromStdString(area.identifier));
QJsonArray arr;
arr.push_back(toJson(area.coord1()));
arr.push_back(toJson(area.coord2()));
arr.push_back(toJson(area.coord3()));
arr.push_back(toJson(area.coord4()));
arr.push_back(toJson(area.coord1));
arr.push_back(toJson(area.coord2));
arr.push_back(toJson(area.coord3));
arr.push_back(toJson(area.coord4));
obj.insert(QStringLiteral("coords"), arr);
return obj;
}
@@ -121,14 +121,14 @@ ObjectTargetInformation::~ObjectTargetInformation()
{
TRACE_LOG(m_logger) << LOGFUNCTION << " START";
if (isValid())
m_mainHandler->dts()->removeTargetInformationByKey(m_data.id());
m_mainHandler->dts()->removeTargetInformationByKey(m_data.id);
TRACE_LOG(m_logger) << LOGFUNCTION << " END";
}
//------------------------------------------------------------------------------
bool ObjectTargetInformation::isValid() const
{
return m_data.id() > 0;
return m_data.id > 0;
}
//------------------------------------------------------------------------------
@@ -137,14 +137,14 @@ Core::FunctionReplyObject ObjectTargetInformation::createObject(const TargetInfo
TRACE_LOG(m_logger) << LOGFUNCTION << " START";
m_data = data;
if (m_data.id() <= 0)
if (m_data.id <= 0)
{
Database::PpmTargetInformation dbData(toDbData(data));
if (!m_mainHandler->db()->insert(dbData))
return Core::FunctionReplyObject(0, tr_lts("dds", "Error inserting TargetInformation-data into database"));
m_data.id(dbData.id);
m_data.id = dbData.id;
DEBUG_LOG(m_logger) << "New PpmTargetInformation: " /*<< m_data.id()*/;
}
@@ -152,29 +152,29 @@ Core::FunctionReplyObject ObjectTargetInformation::createObject(const TargetInfo
onPublishData();
TRACE_LOG(m_logger) << LOGFUNCTION << " END";
return Core::FunctionReplyObject(m_data.id());
return Core::FunctionReplyObject(m_data.id);
}
//------------------------------------------------------------------------------
Core::FunctionReplyObject ObjectTargetInformation::updateObject(const TargetInformation &data)
{
TRACE_LOG(m_logger) << LOGFUNCTION << " START, participantId=" << data.participantId()
<< " size =" << data.shootbackAreas().size();
TRACE_LOG(m_logger) << LOGFUNCTION << " START, participantId=" << data.participantId
<< " size =" << data.shootbackAreas.size();
Database::PpmTargetInformation dbData;
dbData = toDbData(data);
if (!m_mainHandler->db()->update(dbData))
return Core::FunctionReplyObject(data.id(), tr_lts("dds", "Error updating TargetInformation-data into database"));
return Core::FunctionReplyObject(data.id, tr_lts("dds", "Error updating TargetInformation-data into database"));
m_data = data;
DEBUG_LOG(m_logger) << "Data changed for TargetInformation: " << m_data.participantId();
DEBUG_LOG(m_logger) << "Data changed for TargetInformation: " << m_data.participantId;
// Publish Data via DTS
onPublishData();
TRACE_LOG(m_logger) << LOGFUNCTION << " END, id=" << data.id()
<< " size =" << data.shootbackAreas().size();
return Core::FunctionReplyObject(m_data.id());
TRACE_LOG(m_logger) << LOGFUNCTION << " END, id=" << data.id
<< " size =" << data.shootbackAreas.size();
return Core::FunctionReplyObject(m_data.id);
}
//------------------------------------------------------------------------------
@@ -182,21 +182,21 @@ Core::FunctionReplyObject ObjectTargetInformation::removeObject()
{
TRACE_LOG(m_logger) << LOGFUNCTION << " START";
if (!m_mainHandler->db()->removePpmTargetInformation(m_data.id()))
return Core::FunctionReplyObject(m_data.id(), tr_lts("dds", "TargetInformation with id %1 can not be removed from DB")).arg(m_data.id());
if (!m_mainHandler->db()->removePpmTargetInformation(m_data.id))
return Core::FunctionReplyObject(m_data.id, tr_lts("dds", "TargetInformation with id %1 can not be removed from DB")).arg(m_data.id);
if (!m_mainHandler->dts()->removeTargetInformationByKey(m_data.id()))
return Core::FunctionReplyObject(m_data.id(), tr_lts("dds", "TargetInformation with id %1 can not be removed from DDS")).arg(m_data.id());
if (!m_mainHandler->dts()->removeTargetInformationByKey(m_data.id))
return Core::FunctionReplyObject(m_data.id, tr_lts("dds", "TargetInformation with id %1 can not be removed from DDS")).arg(m_data.id);
TRACE_LOG(m_logger) << LOGFUNCTION << " END";
return Core::FunctionReplyObject(m_data.id());
return Core::FunctionReplyObject(m_data.id);
}
//------------------------------------------------------------------------------
void ObjectTargetInformation::onPublishData()
{
TRACE_LOG(m_logger) << "Publish TargetInformation-data to dds (" << m_data.id() << ") ...";
TRACE_LOG(m_logger) << "Publish TargetInformation-data to dds (" << m_data.id << ") ...";
if (!m_mainHandler->dts()->publish(m_data))
ERROR_LOG(m_logger) << "Error publishing TargetInformation-data to dds";
@@ -211,15 +211,15 @@ Database::PpmTargetInformation ObjectTargetInformation::toDbData(const TargetInf
{
Database::PpmTargetInformation dbData;
dbData.id = ddsData.id();
dbData.participantId = ddsData.participantId();
dbData.id = ddsData.id;
dbData.participantId = ddsData.participantId;
dbData.preWarningInterval = ddsData.prewarningInterval();
dbData.preWarningEffect = static_cast<int>(ddsData.prewarningEffect().underlying());
dbData.takeDownInterval = ddsData.takedownInterval();
dbData.takeDownEffect = static_cast<int>(ddsData.takedownEffect().underlying());
dbData.preWarningInterval = ddsData.prewarningInterval;
dbData.preWarningEffect = static_cast<int>(ddsData.prewarningEffect);
dbData.takeDownInterval = ddsData.takedownInterval;
dbData.takeDownEffect = static_cast<int>(ddsData.takedownEffect);
const std::vector<ParticipantManagement::ShootbackArea>& shootback_areas = ddsData.shootbackAreas();
const std::vector<ParticipantManagement::ShootbackArea>& shootback_areas = ddsData.shootbackAreas;
const QJsonObject &obj = toJson(shootback_areas);
dbData.properties = QString::fromStdString( QJsonDocument(obj).toJson(QJsonDocument::Compact).toStdString() );
@@ -233,13 +233,13 @@ TargetInformation ObjectTargetInformation::toDdsData(const Database::PpmTargetIn
{
TargetInformation ddsData;
ddsData.id(dbData.id);
ddsData.participantId(dbData.participantId);
ddsData.id = dbData.id;
ddsData.participantId = dbData.participantId;
ddsData.prewarningInterval(dbData.preWarningInterval);
ddsData.prewarningEffect(static_cast<ProjectDataManagement::VulnerabilityState>(dbData.preWarningEffect));
ddsData.takedownInterval(dbData.takeDownInterval);
ddsData.takedownEffect(static_cast<ProjectDataManagement::VulnerabilityState>(dbData.takeDownEffect));
ddsData.prewarningInterval = dbData.preWarningInterval;
ddsData.prewarningEffect = static_cast<ProjectDataManagement::VulnerabilityState>(dbData.preWarningEffect);
ddsData.takedownInterval = dbData.takeDownInterval;
ddsData.takedownEffect = static_cast<ProjectDataManagement::VulnerabilityState>(dbData.takeDownEffect);
const QByteArray &propertiesBa = dbData.properties.toUtf8();
QJsonParseError parserError;
@@ -252,7 +252,7 @@ TargetInformation ObjectTargetInformation::toDdsData(const Database::PpmTargetIn
QJsonObject obj(doc.object());
const std::vector<ShootbackArea> &sbAreas = vecfromJson(obj);
ddsData.shootbackAreas(sbAreas);
ddsData.shootbackAreas = sbAreas;
return ddsData;
}
@@ -35,8 +35,8 @@ public:
Core::FunctionReplyObject updateObject(const TargetInformation &data);
Core::FunctionReplyObject removeObject();
qint32 getId() const { return m_data.id(); }
qint32 getParticipantId() const { return m_data.participantId(); }
qint32 getId() const { return m_data.id; }
qint32 getParticipantId() const { return m_data.participantId; }
const TargetInformation &getData() const { return m_data; }
bool isValid() const;
@@ -11,18 +11,18 @@ ParticipantManagement::TemplateParticipant ParticipantManagement::TemplateHandli
{
TemplateParticipant result;
result.templateId(id());
result.typeId(typeId());
result.name(m_data.name.toStdString());
result.designator(m_data.designator.toStdString());
result.info(m_data.info.toStdString());
result.symbol(m_data.symbol.toStdString());
result.tacticalIdentifier(m_data.tacticalIdentifier.toStdString());
result.hierarchyNumber(m_data.hierarchyNumber);
result.superiorTemplateId(superiorId());
result.equipmentNumber(m_data.equipmentNumber);
result.templateId = id();
result.typeId = typeId();
result.name = m_data.name.toStdString();
result.designator = m_data.designator.toStdString();
result.info = m_data.info.toStdString();
result.symbol = m_data.symbol.toStdString();
result.tacticalIdentifier = m_data.tacticalIdentifier.toStdString();
result.hierarchyNumber = m_data.hierarchyNumber;
result.superiorTemplateId = superiorId();
result.equipmentNumber = m_data.equipmentNumber;
if (!m_inferiorIds.empty())
result.inferiorIds().set(m_inferiorIds);
result.inferiorIds.set(m_inferiorIds);
return result;
}
@@ -30,25 +30,25 @@ ParticipantManagement::TemplateParticipant ParticipantManagement::TemplateHandli
bool ParticipantManagement::TemplateHandling::Template::hasToBeChanged(const ParticipantManagement::TemplateData &newData)
{
bool hasNoChanges =
m_data.typeId == newData.typeId() &&
m_data.hierarchyNumber == newData.hierarchyNumber() &&
m_data.equipmentNumber == newData.equipmentNumber() &&
m_data.name == QString::fromStdString(newData.name()) &&
m_data.symbol == QString::fromStdString(newData.symbol()) &&
m_data.info == QString::fromStdString(newData.info()) &&
m_data.designator == QString::fromStdString(newData.designator()) &&
m_data.tacticalIdentifier == QString::fromStdString(newData.tacticalIdentifier());
m_data.typeId == newData.typeId &&
m_data.hierarchyNumber == newData.hierarchyNumber &&
m_data.equipmentNumber == newData.equipmentNumber &&
m_data.name == QString::fromStdString(newData.name) &&
m_data.symbol == QString::fromStdString(newData.symbol) &&
m_data.info == QString::fromStdString(newData.info) &&
m_data.designator == QString::fromStdString(newData.designator) &&
m_data.tacticalIdentifier == QString::fromStdString(newData.tacticalIdentifier);
if (!hasNoChanges)
{
m_data.typeId = newData.typeId();
m_data.hierarchyNumber = newData.hierarchyNumber();
m_data.name = QString::fromStdString(newData.name());
m_data.symbol = QString::fromStdString(newData.symbol());
m_data.info = QString::fromStdString(newData.info());
m_data.designator = QString::fromStdString(newData.designator());
m_data.tacticalIdentifier = QString::fromStdString(newData.tacticalIdentifier());
m_data.equipmentNumber = newData.equipmentNumber();
m_data.typeId = newData.typeId;
m_data.hierarchyNumber = newData.hierarchyNumber;
m_data.name = QString::fromStdString(newData.name);
m_data.symbol = QString::fromStdString(newData.symbol);
m_data.info = QString::fromStdString(newData.info);
m_data.designator = QString::fromStdString(newData.designator);
m_data.tacticalIdentifier = QString::fromStdString(newData.tacticalIdentifier);
m_data.equipmentNumber = newData.equipmentNumber;
}
return !hasNoChanges;
@@ -72,19 +72,19 @@ Core::FunctionReplyObject TemplateHandler::modifyTemplateDataRequest(const Parti
QHash<int32_t, int32_t> modIdToTemplateId; // <modId, templateId>
QVector<ParticipantManagement::TemplateData> templatesToBeCreatedOrModified;
templatesToBeCreatedOrModified.reserve(request.data().size());
templatesToBeCreatedOrModified.reserve(request.data.size());
DBTransaction removeTransaction(m_mainHandler->db()->database());
// first remove templates which are marked to be removed
for (const TemplateData &currentTemplate : request.data())
for (const TemplateData &currentTemplate : request.data)
{
if (currentTemplate.isDeleted())
if (currentTemplate.isDeleted)
{
if (currentTemplate.templateId() <= 0)
if (currentTemplate.templateId <= 0)
return Core::FunctionReplyObject(tr_lts("dds",
"Internal error - Not possible to remove templateData with modId %1, because it does not have templateId set"))
.arg(currentTemplate.modId());
const auto ret = deleteTemplateById(currentTemplate.templateId(), true);
.arg(currentTemplate.modId);
const auto ret = deleteTemplateById(currentTemplate.templateId, true);
if (ret.error())
return ret;
}
@@ -106,12 +106,10 @@ Core::FunctionReplyObject TemplateHandler::modifyTemplateDataRequest(const Parti
futureVec.reserve(vecSize);
for (int startIndex = 0; startIndex < templatesToBeCreatedOrModified.size(); startIndex += range)
{
QFuture<Core::FunctionReplyObject> fut = QtConcurrent::run(this,
&TemplateHandler::validateTemplateData,
templatesToBeCreatedOrModified,
modIdToTemplateId,
startIndex,
range);
QFuture<Core::FunctionReplyObject> fut = QtConcurrent::run(
[this, templatesToBeCreatedOrModified, modIdToTemplateId, startIndex, range]() mutable -> Core::FunctionReplyObject {
return validateTemplateData(templatesToBeCreatedOrModified, modIdToTemplateId, startIndex, range);
});
futureVec += fut;
}
@@ -142,7 +140,7 @@ Core::FunctionReplyObject TemplateHandler::modifyTemplateDataRequest(const Parti
for (const TemplateData &currentData : std::as_const(templatesToBeCreatedOrModified))
{
Template *templateToUpdate = m_templates.value(modIdToTemplateId.value(currentData.modId()));
Template *templateToUpdate = m_templates.value(modIdToTemplateId.value(currentData.modId));
if (!templateToUpdate)
{
DEBUG_LOG(m_logger) << "Creating new template: " << currentData;
@@ -167,8 +165,8 @@ Core::FunctionReplyObject TemplateHandler::modifyTemplateDataRequest(const Parti
// build hierarchy
for (const TemplateData &currentData : std::as_const(templatesToBeCreatedOrModified)) // first set superiorIds
{
Template *templateToUpdate = m_templates.value(modIdToTemplateId.value(currentData.modId()), nullptr);
const int superiorId = modIdToTemplateId.value(currentData.superiorModId());
Template *templateToUpdate = m_templates.value(modIdToTemplateId.value(currentData.modId), nullptr);
const int superiorId = modIdToTemplateId.value(currentData.superiorModId);
if (!templateToUpdate->hasNewSuperiorId(superiorId) ||
templatesWithChanges.contains(templateToUpdate))
continue;
@@ -223,15 +221,15 @@ Core::FunctionReplyObject TemplateHandler::createNewTemplate(const ParticipantMa
// create new template
Database::PpmTemplate newDbTemplate;
newDbTemplate.typeId = currentData.typeId();
newDbTemplate.name = QString::fromStdString(currentData.name());
newDbTemplate.symbol = QString::fromStdString(currentData.symbol());
newDbTemplate.info = QString::fromStdString(currentData.info());
newDbTemplate.designator = QString::fromStdString(currentData.designator());
newDbTemplate.tacticalIdentifier = QString::fromStdString(currentData.tacticalIdentifier());
newDbTemplate.superiorId = modIdToTemplateId.value(currentData.superiorModId(), 0);
newDbTemplate.hierarchyNumber = currentData.hierarchyNumber();
newDbTemplate.equipmentNumber = currentData.equipmentNumber();
newDbTemplate.typeId = currentData.typeId;
newDbTemplate.name = QString::fromStdString(currentData.name);
newDbTemplate.symbol = QString::fromStdString(currentData.symbol);
newDbTemplate.info = QString::fromStdString(currentData.info);
newDbTemplate.designator = QString::fromStdString(currentData.designator);
newDbTemplate.tacticalIdentifier = QString::fromStdString(currentData.tacticalIdentifier);
newDbTemplate.superiorId = modIdToTemplateId.value(currentData.superiorModId, 0);
newDbTemplate.hierarchyNumber = currentData.hierarchyNumber;
newDbTemplate.equipmentNumber = currentData.equipmentNumber;
// creating db entry
if (!m_mainHandler->db()->insert(newDbTemplate))
@@ -242,7 +240,7 @@ Core::FunctionReplyObject TemplateHandler::createNewTemplate(const ParticipantMa
Template *newTemplate = new Template(newDbTemplate);
m_templates.insert(newTemplate->id(), newTemplate);
modIdToTemplateId.insert(currentData.modId(), newTemplate->id());
modIdToTemplateId.insert(currentData.modId, newTemplate->id());
if (!templatesWithChanges.contains(newTemplate))
templatesWithChanges.append(newTemplate);
@@ -253,32 +251,32 @@ Core::FunctionReplyObject TemplateHandler::validateTemplateData(const QVector<Te
QHash<int32_t, int32_t> &modIdToTemplateId,
const ParticipantManagement::TemplateData &templateToValidate)
{
if (templateToValidate.templateId() != 0)
if (templateToValidate.templateId != 0)
{
DEBUG_LOG(m_logger) << "Checking template id";
Template *existingTemplate = m_templates.value(templateToValidate.templateId(), nullptr);
Template *existingTemplate = m_templates.value(templateToValidate.templateId, nullptr);
if (existingTemplate == nullptr)
return Core::FunctionReplyObject(tr_lts("dds",
"Could not execute ModifyTemplateDataRequest, because an invalid template ID (%1) was given"))
.arg(templateToValidate.templateId());
.arg(templateToValidate.templateId);
DEBUG_LOG(m_logger) << "... ok";
{
QMutexLocker l(&m_mutex);
modIdToTemplateId.insert(templateToValidate.modId(), existingTemplate->id()); /* register template to indicate that this template
modIdToTemplateId.insert(templateToValidate.modId, existingTemplate->id()); /* register template to indicate that this template
should just be modified and not newly created */
}
}
// superior ids valid?
if (templateToValidate.superiorModId() > 0)
if (templateToValidate.superiorModId > 0)
{
DEBUG_LOG(m_logger) << "checking superiorIds";
// superior exists?
bool isExistingSuperiorId = false;
for (const TemplateData &dat : dataVec)
{
if (templateToValidate.superiorModId() == dat.modId())
if (templateToValidate.superiorModId == dat.modId)
{
isExistingSuperiorId = true;
break; // for (const TemplateData &dat : dataVec)
@@ -287,12 +285,12 @@ Core::FunctionReplyObject TemplateHandler::validateTemplateData(const QVector<Te
if (!isExistingSuperiorId)
return Core::FunctionReplyObject(tr_lts("dds",
"Could not execute ModifyTemplateDataRequest, the data set with modId %1 has an invalid superiorModId %2"))
.arg(templateToValidate.modId())
.arg(templateToValidate.superiorModId());
.arg(templateToValidate.modId)
.arg(templateToValidate.superiorModId);
DEBUG_LOG(m_logger) << "... ok";
if (templateToValidate.hierarchyNumber() <= 0)
if (templateToValidate.hierarchyNumber <= 0)
return Core::FunctionReplyObject(tr_lts("dds",
"Could not execute ModifyTemplateDataRequest, because a data set has a superior but no hierarchyNumber set"));
@@ -301,24 +299,24 @@ Core::FunctionReplyObject TemplateHandler::validateTemplateData(const QVector<Te
for (const TemplateData &dat : dataVec)
{
// operator==() on optionals returns false if not set ...
if (dat.modId() != templateToValidate.modId() &&
dat.superiorModId() == templateToValidate.superiorModId() &&
dat.hierarchyNumber() == templateToValidate.hierarchyNumber())
if (dat.modId != templateToValidate.modId &&
dat.superiorModId == templateToValidate.superiorModId &&
dat.hierarchyNumber == templateToValidate.hierarchyNumber)
return Core::FunctionReplyObject(tr_lts("dds",
"Could not execute ModifyTemplateDataRequest, because for superiorModId %1 hierarchyNumber %2 is not unique"))
.arg(dat.superiorModId())
.arg(dat.hierarchyNumber());
.arg(dat.superiorModId)
.arg(dat.hierarchyNumber);
}
DEBUG_LOG(m_logger) << "... ok";
}
// typeId valid?
DEBUG_LOG(m_logger) << "Checking typeId";
if (m_mainHandler->typeHandler()->typeById(templateToValidate.typeId()) == nullptr)
if (m_mainHandler->typeHandler()->typeById(templateToValidate.typeId) == nullptr)
return Core::FunctionReplyObject(tr_lts("dds",
"Could not execute ModifyTemplateDataRequest, because data set with modId %1 has invalid typeId %2"))
.arg(templateToValidate.modId())
.arg(templateToValidate.typeId());
.arg(templateToValidate.modId)
.arg(templateToValidate.typeId);
DEBUG_LOG(m_logger) << "... ok";
@@ -42,7 +42,7 @@ bool TypeHandler::isSupportType(int typeId) const
if (!type)
return false;
switch (type->typeClass().underlying())
switch (type->typeClass)
{
case TypeClass::SupportEntity:
case TypeClass::SupportUnit:
@@ -66,7 +66,7 @@ bool TypeHandler::isParticipantType(int typeId) const
if (!type)
return false;
switch (type->typeClass().underlying())
switch (type->typeClass)
{
case TypeClass::SupportEntity:
case TypeClass::SupportUnit:
@@ -90,7 +90,7 @@ bool TypeHandler::isUnitType(int typeId) const
if (!type)
return false;
switch (type->typeClass().underlying())
switch (type->typeClass)
{
case TypeClass::Unit:
case TypeClass::SupportUnit:
@@ -120,7 +120,7 @@ bool TypeHandler::isArtilleryParticipantType(int typeId) const
const ParticipantManagement::EquipmentType *TypeHandler::equipmentTypeByTypeId(int32_t typeId)
{
const Type *type = typeById(typeId);
return type ? m_equipmentTypes.value(type->equipmentTypeId()) : nullptr;
return type ? m_equipmentTypes.value(type->equipmentTypeId) : nullptr;
}
std::shared_ptr<TypeHandler> TypeHandler::createInstance(MainHandler *mainHandler, NGL::INGLLogger &logger)
@@ -143,7 +143,7 @@ bool TypeHandler::isArtilleryType(int typeId) const
if (!type)
return false;
QJsonDocument typeProperties = QJsonDocument::fromJson(QByteArray::fromStdString(type->properties()));
QJsonDocument typeProperties = QJsonDocument::fromJson(QByteArray::fromStdString(type->properties));
QJsonObject typePropertiesObject = typeProperties.object();
return typePropertiesObject.value(QStringLiteral("isArtillery")).toBool();
@@ -60,7 +60,7 @@ bool TypeHandling::TypeHandlerExercise::init()
void TypeHandling::TypeHandlerExercise::onTypeChanged(const ParticipantManagement::Type &data)
{
Type *changedType = m_types.value(data.id());
Type *changedType = m_types.value(data.id);
if (changedType)
{
*changedType = data;
@@ -68,13 +68,13 @@ void TypeHandling::TypeHandlerExercise::onTypeChanged(const ParticipantManagemen
else
{
changedType = new Type(data);
m_types.insert(changedType->id(), changedType);
m_types.insert(changedType->id, changedType);
}
}
void TypeHandling::TypeHandlerExercise::onEquipmentTypeChanged(const ParticipantManagement::EquipmentType &data)
{
EquipmentType *changedEquipmentType = m_equipmentTypes.value(data.id());
EquipmentType *changedEquipmentType = m_equipmentTypes.value(data.id);
if (changedEquipmentType)
{
*changedEquipmentType = data;
@@ -82,7 +82,7 @@ void TypeHandling::TypeHandlerExercise::onEquipmentTypeChanged(const Participant
else
{
changedEquipmentType = new EquipmentType(data);
m_equipmentTypes.insert(changedEquipmentType->id(), changedEquipmentType);
m_equipmentTypes.insert(changedEquipmentType->id, changedEquipmentType);
}
}
@@ -20,14 +20,14 @@ namespace ParticipantManagement
static Database::PpmEquipmentType toDb(const EquipmentType &et)
{
Database::PpmEquipmentType db;
db.id = et.id();
db.name = QString::fromStdString(et.name());
db.minEquipNo = et.minEquipNo();
db.maxEquipNo = et.maxEquipNo();
db.traVulnerabilityModelId = et.traVulnerabilityModelId();
db.traPlayerTypeId = et.traPlayerTypeId();
db.wmsTypeClassId = et.wmsTypeClass();
db.deletedInWms = et.deletedInWms();
db.id = et.id;
db.name = QString::fromStdString(et.name);
db.minEquipNo = et.minEquipNo;
db.maxEquipNo = et.maxEquipNo;
db.traVulnerabilityModelId = et.traVulnerabilityModelId;
db.traPlayerTypeId = et.traPlayerTypeId;
db.wmsTypeClassId = et.wmsTypeClass;
db.deletedInWms = et.deletedInWms;
return db;
}
@@ -36,21 +36,21 @@ Database::PpmType toDb(const ParticipantManagement::Type &data)
{
Database::PpmType ret;
ret.id = data.id();
ret.typeClassId = data.typeClass();
if (data.equipmentTypeId() != 0)
ret.equipmentTypeId = data.equipmentTypeId(); // QVariant
ret.name = QString::fromStdString(data.name());
ret.symbol = QString::fromStdString(data.symbol());
ret.radioCount = data.radioCount();
ret.hierarchyLevel = data.hierarchyLevel();
ret.isDeleted = data.isDeleted();
ret.id = data.id;
ret.typeClassId = data.typeClass;
if (data.equipmentTypeId != 0)
ret.equipmentTypeId = data.equipmentTypeId; // QVariant
ret.name = QString::fromStdString(data.name);
ret.symbol = QString::fromStdString(data.symbol);
ret.radioCount = data.radioCount;
ret.hierarchyLevel = data.hierarchyLevel;
ret.isDeleted = data.isDeleted;
#ifdef Q_OS_WIN
ret.disEntities = LtsUtils::BigintArray(data.disEntities());
#else
ret.disEntities = LtsUtils::BigintArray(LtsUtils::convert<std::vector<int64_t>>(data.disEntities()));
ret.disEntities = LtsUtils::BigintArray(data.disEntities);
#endif
ret.properties = QString::fromStdString(data.properties());
ret.properties = QString::fromStdString(data.properties);
return ret;
}
@@ -94,7 +94,7 @@ bool TypeHandling::TypeHandlerGlobal::init()
auto cbEt = [this] (const Database::PpmEquipmentType &dbEquipmentType)
{
EquipmentType *newEquipmentType = new EquipmentType(convert(dbEquipmentType));
m_equipmentTypes.insert(newEquipmentType->id(), newEquipmentType);
m_equipmentTypes.insert(newEquipmentType->id, newEquipmentType);
m_mainHandler->exAnyDts()->publish(*newEquipmentType);
};
m_mainHandler->db()->select(cbEt);
@@ -104,7 +104,7 @@ bool TypeHandling::TypeHandlerGlobal::init()
auto cbT = [this] (const Database::PpmType &dbType)
{
Type *newType = new Type(convert(dbType));
m_types.insert(newType->id(), newType);
m_types.insert(newType->id, newType);
m_mainHandler->exAnyDts()->publish(*newType);
};
m_mainHandler->db()->select(cbT);
@@ -116,7 +116,7 @@ void TypeHandling::TypeHandlerGlobal::onModifyTypeRequest(const rti::core::Sampl
const ParticipantManagement::Type &request)
{
DEBUG_LOG(m_logger) << "onModifyTypeRequest" << request;
auto ret = (request.id() > 0 ? modifyTypeRequest(request) : createTypeRequest(request));
auto ret = (request.id > 0 ? modifyTypeRequest(request) : createTypeRequest(request));
if (ret.error())
WARNING_LOG(m_logger) << ret();
m_mainHandler->exAnyFts()->modifyTypeReply(cookie, ret);
@@ -124,17 +124,17 @@ void TypeHandling::TypeHandlerGlobal::onModifyTypeRequest(const rti::core::Sampl
Core::FunctionReplyObject TypeHandling::TypeHandlerGlobal::createTypeRequest(const ParticipantManagement::Type &request)
{
if (request.equipmentTypeId() != 0 && !m_equipmentTypes.contains(request.equipmentTypeId()))
return Core::FunctionReplyObject(-1, tr_lts("dds", "Could not add new Type - equipmentTypeId %1 invalid")).arg(request.equipmentTypeId());
if (request.equipmentTypeId != 0 && !m_equipmentTypes.contains(request.equipmentTypeId))
return Core::FunctionReplyObject(-1, tr_lts("dds", "Could not add new Type - equipmentTypeId %1 invalid")).arg(request.equipmentTypeId);
Database::PpmType newPpmType(toDb(request));
if (!m_mainHandler->db()->insert(newPpmType))
return Core::FunctionReplyObject(-1, tr_lts("dds", "Could not add new Type - insert statement failed"));
Type *newType = new Type(request);
newType->id(newPpmType.id);
newType->id = newPpmType.id;
// insert into map
m_types.insert(newType->id(), newType);
m_types.insert(newType->id, newType);
// publish to dds
m_mainHandler->exAnyDts()->publish(*newType);
@@ -146,15 +146,15 @@ Core::FunctionReplyObject TypeHandling::TypeHandlerGlobal::createTypeRequest(con
Core::FunctionReplyObject TypeHandling::TypeHandlerGlobal::modifyTypeRequest(const ParticipantManagement::Type &request)
{
Type *typeToBeModified = m_types.value(request.id());
Type *typeToBeModified = m_types.value(request.id);
if (!typeToBeModified)
return Core::FunctionReplyObject(request.id(), tr_lts("dds", "Could not add new Type - Type with id %1 not available")).arg(request.id());
return Core::FunctionReplyObject(request.id, tr_lts("dds", "Could not add new Type - Type with id %1 not available")).arg(request.id);
if (typeToBeModified->equipmentTypeId() != request.equipmentTypeId())
return Core::FunctionReplyObject(request.id(), tr_lts("dds", "It is not allowed to modify the Equipment Type of a Type"));
if (typeToBeModified->equipmentTypeId != request.equipmentTypeId)
return Core::FunctionReplyObject(request.id, tr_lts("dds", "It is not allowed to modify the Equipment Type of a Type"));
if (!m_mainHandler->db()->update(toDb(request)))
return Core::FunctionReplyObject(request.id(), tr_lts("dds", "Could not modify Type in database"));
return Core::FunctionReplyObject(request.id, tr_lts("dds", "Could not modify Type in database"));
DEBUG_LOG(m_logger) << "Old Type data:\n"
<< *typeToBeModified
@@ -163,7 +163,7 @@ Core::FunctionReplyObject TypeHandling::TypeHandlerGlobal::modifyTypeRequest(con
*typeToBeModified = request;
m_mainHandler->exAnyDts()->publish(*typeToBeModified);
return Core::FunctionReplyObject(request.id());
return Core::FunctionReplyObject(request.id);
}
void TypeHandling::TypeHandlerGlobal::onRemoveTypeRequest(const rti::core::SampleIdentity &cookie,
@@ -171,24 +171,24 @@ void TypeHandling::TypeHandlerGlobal::onRemoveTypeRequest(const rti::core::Sampl
{
DEBUG_LOG(m_logger) << "onRemoveTypeRequest " << request;
Core::FunctionReplyObject rep(request.typeId());
Type *typeToBeRemoved = m_types.value(request.typeId());
Core::FunctionReplyObject rep(request.typeId);
Type *typeToBeRemoved = m_types.value(request.typeId);
if (typeToBeRemoved)
{
if (isTypeUsed(typeToBeRemoved->id()))
rep = Core::FunctionReplyObject(request.typeId(), tr_lts("dds", "Type '%1' with type id %2 cannot be removed, type is used")).arg(typeToBeRemoved->name()).arg(request.typeId());
if (isTypeUsed(typeToBeRemoved->id))
rep = Core::FunctionReplyObject(request.typeId, tr_lts("dds", "Type '%1' with type id %2 cannot be removed, type is used")).arg(typeToBeRemoved->name).arg(request.typeId);
else
{
typeToBeRemoved->isDeleted(true);
typeToBeRemoved->isDeleted = true;
if (!m_mainHandler->db()->update(toDb(*typeToBeRemoved)))
rep = Core::FunctionReplyObject(request.typeId(), tr_lts("dds", "Could not mark type with id %1 as deleted in database")).arg(request.typeId());
rep = Core::FunctionReplyObject(request.typeId, tr_lts("dds", "Could not mark type with id %1 as deleted in database")).arg(request.typeId);
m_mainHandler->exAnyDts()->publish(*typeToBeRemoved);
}
}
else
rep = Core::FunctionReplyObject(request.typeId(), tr_lts("dds", "RemoveTypeRequest for non existing type with id %1")).arg(request.typeId());
rep = Core::FunctionReplyObject(request.typeId, tr_lts("dds", "RemoveTypeRequest for non existing type with id %1")).arg(request.typeId);
if (rep.error())
WARNING_LOG(m_logger) << rep();
@@ -201,18 +201,18 @@ void TypeHandling::TypeHandlerGlobal::onModifyEquipmentTypeDataRequest(const rti
{
Core::FunctionReplyObject rep;
INFO_LOG(m_logger) << "Got " << request.data().size() << " equipment types to modify";
INFO_LOG(m_logger) << "Got " << request.data.size() << " equipment types to modify";
QSet<int> activeIds;
activeIds.reserve(request.data().size());
activeIds.reserve(request.data.size());
for (const EquipmentType &currentData : request.data())
for (const EquipmentType &currentData : request.data)
{
bool bPublishData = false;
EquipmentType *existingEquipmentType = m_equipmentTypes.value(currentData.id(), nullptr);
EquipmentType *existingEquipmentType = m_equipmentTypes.value(currentData.id, nullptr);
if (existingEquipmentType) // update existing equipment type
{
activeIds += currentData.id();
activeIds += currentData.id;
if (*existingEquipmentType != currentData)
{
@@ -220,7 +220,7 @@ void TypeHandling::TypeHandlerGlobal::onModifyEquipmentTypeDataRequest(const rti
*existingEquipmentType = currentData;
if (!m_mainHandler->db()->update(toDb(currentData)))
{
rep = Core::FunctionReplyObject(currentData.id(), tr_lts("dds", "Error updating equipment type with %1 data in database")).arg(currentData.id());
rep = Core::FunctionReplyObject(currentData.id, tr_lts("dds", "Error updating equipment type with %1 data in database")).arg(currentData.id);
break;
}
}
@@ -230,54 +230,54 @@ void TypeHandling::TypeHandlerGlobal::onModifyEquipmentTypeDataRequest(const rti
Database::PpmEquipmentType dbEquipmentType(toDb(currentData));
if (!m_mainHandler->db()->insert(dbEquipmentType))
{
rep = Core::FunctionReplyObject(currentData.id(), tr_lts("dds", "Error inserting equipment type with %1 data in database")).arg(currentData.id());
rep = Core::FunctionReplyObject(currentData.id, tr_lts("dds", "Error inserting equipment type with %1 data in database")).arg(currentData.id);
break;
}
existingEquipmentType = new EquipmentType(currentData);
existingEquipmentType->id(dbEquipmentType.id);
m_equipmentTypes.insert(existingEquipmentType->id(), existingEquipmentType);
activeIds += existingEquipmentType->id();
existingEquipmentType->id = dbEquipmentType.id;
m_equipmentTypes.insert(existingEquipmentType->id, existingEquipmentType);
activeIds += existingEquipmentType->id;
bPublishData = true;
}
INFO_LOG(m_logger) << "Modified EquipmentType with id " << existingEquipmentType->id() << " ?: " << bPublishData;
INFO_LOG(m_logger) << "Modified EquipmentType with id " << existingEquipmentType->id << " ?: " << bPublishData;
if (bPublishData)
{
if (!m_mainHandler->exAnyDts()->publish(*existingEquipmentType))
{
rep = Core::FunctionReplyObject(currentData.id(), tr_lts("dds", "Error publishing equipment type %1 to DDS")).arg(currentData.id());
rep = Core::FunctionReplyObject(currentData.id, tr_lts("dds", "Error publishing equipment type %1 to DDS")).arg(currentData.id);
break;
}
}
}
if (request.deleteAll())
if (request.deleteAll)
{
QHashIterator<int32_t,EquipmentType*> it(m_equipmentTypes);
while (it.hasNext())
{
EquipmentType* et = it.next().value();
if (activeIds.contains(et->id()))
if (activeIds.contains(et->id))
continue;
INFO_LOG(m_logger) << "Deleted in WHG " << et->id() << ", already marked as deleted?: " << et->deletedInWms();
INFO_LOG(m_logger) << "Deleted in WHG " << et->id << ", already marked as deleted?: " << et->deletedInWms;
// alle, die nicht behandelt wurden -> deletedInWms
// über alle iterieren
if (et->deletedInWms())
if (et->deletedInWms)
continue;
et->deletedInWms(true);
et->deletedInWms = true;
if (!m_mainHandler->db()->update(toDb(*et)))
{
rep = Core::FunctionReplyObject(et->id(), tr_lts("dds", "Error updating equipment type with %1 data in database")).arg(et->id());
rep = Core::FunctionReplyObject(et->id, tr_lts("dds", "Error updating equipment type with %1 data in database")).arg(et->id);
break;
}
if (!m_mainHandler->exAnyDts()->publish(*et))
{
rep = Core::FunctionReplyObject(et->id(), tr_lts("dds", "Error publishing equipment type %1 to DDS")).arg(et->id());
rep = Core::FunctionReplyObject(et->id, tr_lts("dds", "Error publishing equipment type %1 to DDS")).arg(et->id);
break;
}
}
@@ -301,7 +301,7 @@ bool TypeHandling::TypeHandlerGlobal::isTypeUsed(int typeId) const
const auto exercises = m_exmDtc->exercises();
for (const ExerciseManagement::Exercise &ex : exercises)
{
const QString tblName = DBCommon::getExerciseTableName(QStringLiteral("ppm_participant"), ex.id());
const QString tblName = DBCommon::getExerciseTableName(QStringLiteral("ppm_participant"), ex.id);
//const QString stmt(QStringLiteral("SELECT count(*) FROM %1 WHERE type_id = %2").arg(tblName, QString::number(typeId)));
// Error occured => same as if type exists
@@ -310,7 +310,7 @@ bool TypeHandling::TypeHandlerGlobal::isTypeUsed(int typeId) const
int count = q.value(0).toInt();
DEBUG_LOG(m_logger) << "exercise: " << ex.id() << ", count: " << count;
DEBUG_LOG(m_logger) << "exercise: " << ex.id << ", count: " << count;
if (count > 0)
return true;
}
@@ -46,14 +46,14 @@ bool MissionPlanHandler::init()
void MissionPlanHandler::onModifyMissionPlanRequest(const rti::core::SampleIdentity &cookie, const ModifyMissionPlanRequest &request)
{
Core::FunctionReplyObject reply = request.id() == 0 ? createMissionPlanRequest(request)
Core::FunctionReplyObject reply = request.id == 0 ? createMissionPlanRequest(request)
: modifyMissionPlanRequest(request);
m_mainHandler->fts()->modifyMissionPlanReply(cookie, reply);
}
void MissionPlanHandler::onRemoveMissionPlanRequest(const rti::core::SampleIdentity &cookie, const RemoveMissionPlanRequest &request)
{
Core::FunctionReplyObject reply = removeMissionPlanRequest(request.id());
Core::FunctionReplyObject reply = removeMissionPlanRequest(request.id);
m_mainHandler->ddsHandler()->fts()->removeMissionPlanReply(cookie, reply);
}
@@ -94,12 +94,12 @@ bool MissionPlanHandler::loadMissionPlansFromDb()
for (const ParticipantManagement::Database::PpmMissionPlan &data : std::as_const(missionPlanVec))
{
ParticipantManagement::MissionPlan missionPlan;
missionPlan.id(data.id);
missionPlan.name(data.name.toStdString());
missionPlan.participantId(data.participantId);
missionPlan.missionStart(data.missionStart.toMSecsSinceEpoch());
missionPlan.repeat(data.repeat);
missionPlan.jumpToStart(data.jumpToStart);
missionPlan.id = data.id;
missionPlan.name = data.name.toStdString();
missionPlan.participantId = data.participantId;
missionPlan.missionStart = data.missionStart.toMSecsSinceEpoch();
missionPlan.repeat = data.repeat;
missionPlan.jumpToStart = data.jumpToStart;
QMap <int, ParticipantManagement::Database::PpmMissionItem> itemsDbMap; // QMap to get it sorted
@@ -120,14 +120,14 @@ bool MissionPlanHandler::loadMissionPlansFromDb()
}
missionPlan.items().reserve(itemsDbMap.size());
missionPlan.items.reserve(itemsDbMap.size());
for (const ParticipantManagement::Database::PpmMissionItem &item : std::as_const(itemsDbMap))
{
ParticipantManagement::MissionItem msi;
msi.actions().reserve(actionsDbMap.size());
msi.name(item.name.toStdString());
msi.location(Core::GeoPosition(item.location.x(), item.location.y(), item.location.z()));
msi.itemNumber(item.elementNumber);
msi.actions.reserve(actionsDbMap.size());
msi.name = item.name.toStdString();
msi.location = Core::GeoPosition(item.location.x(), item.location.y(), item.location.z());
msi.itemNumber = item.elementNumber;
int actionsFulfilled = 0;
int64_t latestFulfilled = 0;
for (const auto &action : actionsDbMap)
@@ -135,36 +135,36 @@ bool MissionPlanHandler::loadMissionPlansFromDb()
if (action.missionItemId == item.id)
{
ParticipantManagement::MissionAction msa;
msa.planId(missionPlan.id());
msa.actionType(action.missionActionTypeId);
msa.duration(action.duration);
msa.fulfilled(action.fulfilled.toMSecsSinceEpoch());
msa.properties(action.properties.toStdString());
msa.name(action.name.toStdString());
msa.actionNumber(action.elementNumber);
msa.itemNumber(msi.itemNumber());
msi.actions().push_back(msa);
msa.planId = missionPlan.id;
msa.actionType = action.missionActionTypeId;
msa.duration = action.duration;
msa.fulfilled = action.fulfilled.toMSecsSinceEpoch();
msa.properties = action.properties.toStdString();
msa.name = action.name.toStdString();
msa.actionNumber = action.elementNumber;
msa.itemNumber = msi.itemNumber;
msi.actions.push_back(msa);
if (msa.fulfilled() > 0)
if (msa.fulfilled > 0)
actionsFulfilled++;
if (latestFulfilled < msa.fulfilled())
latestFulfilled = msa.fulfilled();
if (latestFulfilled < msa.fulfilled)
latestFulfilled = msa.fulfilled;
}
}
msi.actionsFulfilled(actionsFulfilled);
msi.fulfilled(latestFulfilled);
msi.actionsFulfilled = actionsFulfilled;
msi.fulfilled = latestFulfilled;
missionPlan.items().push_back(msi);
missionPlan.items.push_back(msi);
}
setLatestFulfilledItem(missionPlan); // update mission plan fulfillment count & fulfillemnt latest time
ObjectMissionPlan *obj = new ObjectMissionPlan(m_mainHandler->ddsHandler(), m_mainHandler->db(), missionPlan);
obj->setDbMissionItems(itemsDbMap, actionsDbMap);
m_objMissionPlans.insert(missionPlan.id(), obj);
m_objMissionPlans.insert(missionPlan.id, obj);
// publish mission plan data
m_mainHandler->ddsHandler()->dts()->publish(missionPlan);
@@ -179,15 +179,15 @@ bool MissionPlanHandler::isUasInAutoMode(int participantId)
m_mainHandler->ddsHandler()->dtc()->waitForHistoricalDataUAS(3000);
const auto uas = m_mainHandler->ddsHandler()->dtc()->getUasByParticipantId(participantId, m_mainHandler->exerciseId());
if (uas.id() < 1)
if (uas.id < 1)
{
ERROR_LOG(m_logger) << "no uas for pid " << participantId;
return false;
}
DEBUG_LOG(m_logger) << "uas with pid " << participantId << " is in mode: " << (int)uas.uasState().underlying();
DEBUG_LOG(m_logger) << "uas with pid " << participantId << " is in mode: " << (int)uas.uasState;
return (uas.uasState() == ProjectDataManagement::UasState::UasState_Auto);
return (uas.uasState == ProjectDataManagement::UasState::UasState_Auto);
}
// stolen from Lts/Plugins/ParticipantManagement/Gui/ParticipantInfo/participant_info_dialog.cpp
@@ -196,53 +196,53 @@ bool MissionPlanHandler::isUasCombatReady(int participantId)
m_mainHandler->ddsHandler()->dtc()->waitForHistoricalDataDynamicParticipantData(3000);
const auto data = m_mainHandler->ddsHandler()->dtc()->dynamicParticipantData(participantId);
if (data.participantId() == 0)
if (data.participantId == 0)
{
return false;
}
//Current State
if (data.stateHistory().empty())
if (data.stateHistory.empty())
{
return false;
}
const auto &history = data.stateHistory();
const auto &history = data.stateHistory;
//LasState is the last "real" state, that has a VBG <=8 (Castastrophic)
//It's not the last state received, as there can be other state changes like Sanitation, or NearMiss
auto lastState = m_mainHandler->ddsHandler()->dtc()->youngestStateInformation(history/*, true*/ /* debug */);
decltype(lastState) youngestState;
youngestState.stateTime(0);
youngestState.stateTime = 0;
for (const auto &si : history)
{
DEBUG_LOG(m_logger) << "StateInformation "
<< " time=" << si.stateTime()
<< " vulnerabilityBits=" << si.vulnerabilityBits()
<< " vulnerabilityKindId=" << si.vulnerabilityKindId();
if (youngestState.stateTime() < si.stateTime())
<< " time=" << si.stateTime
<< " vulnerabilityBits=" << si.vulnerabilityBits
<< " vulnerabilityKindId=" << si.vulnerabilityKindId;
if (youngestState.stateTime < si.stateTime)
youngestState = si;
}
return (youngestState.vulnerabilityState() == ProjectDataManagement::VulnerabilityState::VulnerabilityState_CombatReady);
return (youngestState.vulnerabilityState == ProjectDataManagement::VulnerabilityState::VulnerabilityState_CombatReady);
}
Core::FunctionReplyObject MissionPlanHandler::createMissionPlanRequest(const ModifyMissionPlanRequest &request)
{
DEBUG_LOG(m_logger) <<" >> -- createMissionPlanRequest -- ";
if (request.participantId() > 0 && !isUasParticipant(request.participantId()))
if (request.participantId > 0 && !isUasParticipant(request.participantId))
{
return Core::FunctionReplyObject(tr_lts("dds", "Participant with id %1 is not a Uas participant.")).arg(request.participantId());
return Core::FunctionReplyObject(tr_lts("dds", "Participant with id %1 is not a Uas participant.")).arg(request.participantId);
}
if (!isUasInAutoMode(request.participantId()))
if (!isUasInAutoMode(request.participantId))
{
return Core::FunctionReplyObject(tr_lts("dds", "Uas with participant id %1 is not in auto mode - maybe the safety tablet is currently engaged.")).arg(request.participantId());
return Core::FunctionReplyObject(tr_lts("dds", "Uas with participant id %1 is not in auto mode - maybe the safety tablet is currently engaged.")).arg(request.participantId);
}
if (!isUasCombatReady(request.participantId()))
if (!isUasCombatReady(request.participantId))
{
return Core::FunctionReplyObject(tr_lts("dds", "Uas with participant id %1 ------ not combat ready.")).arg(request.participantId());
return Core::FunctionReplyObject(tr_lts("dds", "Uas with participant id %1 ------ not combat ready.")).arg(request.participantId);
}
/// 1- insert in DB Mission plan
@@ -254,7 +254,7 @@ Core::FunctionReplyObject MissionPlanHandler::createMissionPlanRequest(const Mod
const MissionPlan missionPlan = ObjectMissionPlan::fillMissionPlanData(request);
ObjectMissionPlan *obj = new ObjectMissionPlan(m_mainHandler->ddsHandler(), m_mainHandler->db(), missionPlan);
Core::FunctionReplyObject ret = obj->createMissionPlan(dbMissionPlan, request.items());
Core::FunctionReplyObject ret = obj->createMissionPlan(dbMissionPlan, request.items);
if (ret.error())
{
delete obj;
@@ -273,13 +273,13 @@ Core::FunctionReplyObject MissionPlanHandler::modifyMissionPlanRequest(const Mod
/// 2- remove first all mission items and their actions
/// 3- add New mission items
/// 4- add new mission actions
ObjectMissionPlan *obj = m_objMissionPlans.value(request.id());
if (!obj || request.id() < 0)
return Core::FunctionReplyObject(request.id(), tr_lts("dds", "Couldn't remove Mission plan with id %1")).arg(request.id());
ObjectMissionPlan *obj = m_objMissionPlans.value(request.id);
if (!obj || request.id < 0)
return Core::FunctionReplyObject(request.id, tr_lts("dds", "Couldn't remove Mission plan with id %1")).arg(request.id);
const Database::PpmMissionPlan &dbMissionPlan = ObjectMissionPlan::toDbMissionPlan(request);
auto ret = obj->updateMissionPlan(dbMissionPlan, request.items());
auto ret = obj->updateMissionPlan(dbMissionPlan, request.items);
publishMissionPlan(obj->getMissionPlanData()); // publish mission plan
return ret;
}
@@ -308,19 +308,19 @@ bool MissionPlanHandler::setCurrentMissionActionFulfilled(int participantId, con
bool found = false;
for (const auto &missionPlan : m_objMissionPlans.values())
{
if (missionPlan->missionPlan().participantId() == participantId && missionPlan->missionPlan().missionStart() <= m_mainHandler->currentTimeMSec())
if (missionPlan->missionPlan().participantId == participantId && missionPlan->missionPlan().missionStart <= m_mainHandler->currentTimeMSec())
{
// get current action (stolen from Services/CentralEffectSimulation/Plugins/MissionPlan/ces_mission_plan_object.cpp)
const std::vector< ParticipantManagement::MissionItem > items = missionPlan->missionPlan().items(); // copy !!
const std::vector< ParticipantManagement::MissionItem > items = missionPlan->missionPlan().items; // copy !!
for (const auto &item : items)
{
for (auto &msa : item.actions())
for (auto &msa : item.actions)
{
const QString thisMissionName(QStringLiteral("%1_%2_%3").arg(missionPlan->missionPlan().id()).arg(QString::fromStdString(missionPlan->missionPlan().name()), QString::fromStdString(item.name())));
const QString thisMissionName(QStringLiteral("%1_%2_%3").arg(missionPlan->missionPlan().id).arg(QString::fromStdString(missionPlan->missionPlan().name), QString::fromStdString(item.name)));
INFO_LOG(m_logger) << ">> mission item: this mission name: " << thisMissionName << ", fulfilled: " << msa.fulfilled();
INFO_LOG(m_logger) << ">> mission item: this mission name: " << thisMissionName << ", fulfilled: " << msa.fulfilled;
if (msa.fulfilled() > 0)
if (msa.fulfilled > 0)
{
continue;
}
@@ -330,12 +330,12 @@ bool MissionPlanHandler::setCurrentMissionActionFulfilled(int participantId, con
continue;
}
DEBUG_LOG(m_logger) << ">> ######### setMissionActionFulfilledRequest !!! item = " << item.itemNumber() << ", name = " << item.name() << ", missionPlan = " << missionPlan->missionPlan().id();
DEBUG_LOG(m_logger) << ">> ######### setMissionActionFulfilledRequest !!! item = " << item.itemNumber << ", name = " << item.name << ", missionPlan = " << missionPlan->missionPlan().id;
SetMissionActionFulfilledRequest req;
req.actionNumber(msa.actionNumber());
req.fulfilled(true);
req.missionId(missionPlan->missionPlan().id());
req.itemNumber(item.itemNumber());
req.actionNumber = msa.actionNumber;
req.fulfilled = true;
req.missionId = missionPlan->missionPlan().id;
req.itemNumber = item.itemNumber;
const auto res = setMissionActionFulfilledRequest(req);
if (res.error())
{
@@ -371,9 +371,9 @@ bool MissionPlanHandler::setCurrentMissionActionFulfilled(int participantId, con
Core::FunctionReplyObject MissionPlanHandler::setMissionActionFulfilledRequest(const SetMissionActionFulfilledRequest &request)
{
DEBUG_LOG(m_logger)<<" -- [setMissionActionFulfilledRequest] req.missionId: "<<request.missionId();
DEBUG_LOG(m_logger)<<" -- [setMissionActionFulfilledRequest] req.missionId: "<<request.missionId;
Core::FunctionReplyObject ret;
ObjectMissionPlan *obj = m_objMissionPlans.value(request.missionId(), nullptr);
ObjectMissionPlan *obj = m_objMissionPlans.value(request.missionId, nullptr);
if (!obj)
return ret;
ret = obj->setMissionActionFulfilled(request, m_mainHandler->currentTimeMSec());
@@ -403,9 +403,9 @@ bool MissionPlanHandler::isUasParticipant(int participantId) const
int MissionPlanHandler::getNumberOfActionFulfilled(const MissionItem &msi) const
{
int count = 0;
for (auto action : msi.actions())
for (auto action : msi.actions)
{
if (action.fulfilled() > 0)
if (action.fulfilled > 0)
count++;
}
return count;
@@ -415,26 +415,26 @@ void MissionPlanHandler::setLatestFulfilledItem(MissionPlan &missionPlan)
{
int count = 0;
int64_t latestTime = 0;
for (auto item : missionPlan.items())
for (auto item : missionPlan.items)
{
if (item.actionsFulfilled() > 0)
if (item.actionsFulfilled > 0)
count++;
if (latestTime < item.fulfilled())
latestTime = item.fulfilled();
if (latestTime < item.fulfilled)
latestTime = item.fulfilled;
missionPlan.itemsFulfilled(count);
missionPlan.fulfilled(latestTime);
missionPlan.itemsFulfilled = count;
missionPlan.fulfilled = latestTime;
}
}
int64_t MissionPlanHandler::getLastestFulfilledAction(const MissionItem &msi) const
{
int64_t latestTime = 0;
for (auto action : msi.actions())
for (auto action : msi.actions)
{
if (action.fulfilled() > latestTime)
latestTime = action.fulfilled();
if (action.fulfilled > latestTime)
latestTime = action.fulfilled;
}
return latestTime;
@@ -25,29 +25,29 @@ ObjectMissionPlan::ObjectMissionPlan(const std::shared_ptr<DdsHandler> &ddsHandl
, m_missionplan(missionPlan)
, m_logger(getLogger("ObjectMissionPlan"))
{
DEBUG_LOG(m_logger)<<" - ctor ObjectMissionPlan: planId: "<<m_missionplan.id();
DEBUG_LOG(m_logger)<<" - ctor ObjectMissionPlan: planId: "<<m_missionplan.id;
}
int32_t ObjectMissionPlan::id() const
{
return m_missionplan.id();
return m_missionplan.id;
}
int32_t ObjectMissionPlan::participantId() const
{
return m_missionplan.participantId();
return m_missionplan.participantId;
}
Database::PpmMissionPlan ObjectMissionPlan::toDbMissionPlan(const ModifyMissionPlanRequest &mp)
{
Database::PpmMissionPlan result;
result.id = mp.id();
result.name = QString::fromStdString(mp.name());
result.missionStart = QDateTime::fromMSecsSinceEpoch(mp.missionStart());
result.repeat = mp.repeat();
result.jumpToStart = mp.jumpToStart();
result.participantId = mp.participantId();
result.id = mp.id;
result.name = QString::fromStdString(mp.name);
result.missionStart = QDateTime::fromMSecsSinceEpoch(mp.missionStart);
result.repeat = mp.repeat;
result.jumpToStart = mp.jumpToStart;
result.participantId = mp.participantId;
return result;
}
@@ -56,14 +56,14 @@ Database::PpmMissionPlan ObjectMissionPlan::toDbMissionPlan(const ModifyMissionP
MissionPlan ObjectMissionPlan::fillMissionPlanData(const ModifyMissionPlanRequest &in)
{
MissionPlan out;
out.id(in.id());
out.name(in.name());
out.missionStart(in.missionStart());
out.properties(in.properties());
out.items(in.items());
out.participantId(in.participantId());
out.jumpToStart(in.jumpToStart());
out.repeat(in.repeat());
out.id = in.id;
out.name = in.name;
out.missionStart = in.missionStart;
out.properties = in.properties;
out.items = in.items;
out.participantId = in.participantId;
out.jumpToStart = in.jumpToStart;
out.repeat = in.repeat;
return out;
}
@@ -74,7 +74,7 @@ MissionPlan ObjectMissionPlan::getMissionPlanData() const
}
void ObjectMissionPlan::setDbMissionItems(const QMap<int, ParticipantManagement::Database::PpmMissionItem> &dbItems,
const QMap<int, Database::PpmMissionAction> &dbActions)
const QMultiMap<int, Database::PpmMissionAction> &dbActions)
{
m_mapMissionItems.clear();
m_dbMissionActions.clear();
@@ -82,24 +82,24 @@ void ObjectMissionPlan::setDbMissionItems(const QMap<int, ParticipantManagement:
for (const ParticipantManagement::Database::PpmMissionItem &item : std::as_const(dbItems))
{
ParticipantManagement::MissionItem msi;
msi.actions().reserve(dbActions.size());
msi.name(item.name.toStdString());
msi.location(Core::GeoPosition(item.location.x(), item.location.y(), item.location.z()));
msi.itemNumber(item.elementNumber);
msi.actions.reserve(dbActions.size());
msi.name = item.name.toStdString();
msi.location = Core::GeoPosition(item.location.x(), item.location.y(), item.location.z());
msi.itemNumber = item.elementNumber;
std::vector<Database::PpmMissionAction> actionsVec;
for (const auto &action : dbActions)
{
if (action.missionItemId == item.id)
{
ParticipantManagement::MissionAction msa;
msa.actionType(action.missionActionTypeId);
msa.duration(action.duration);
msa.fulfilled(action.fulfilled.toMSecsSinceEpoch());
msa.properties(action.properties.toStdString());
msa.name(action.name.toStdString());
msa.actionNumber(action.elementNumber);
msa.planId(item.missionPlanId);
msi.actions().push_back(msa);
msa.actionType = action.missionActionTypeId;
msa.duration = action.duration;
msa.fulfilled = action.fulfilled.toMSecsSinceEpoch();
msa.properties = action.properties.toStdString();
msa.name = action.name.toStdString();
msa.actionNumber = action.elementNumber;
msa.planId = item.missionPlanId;
msi.actions.push_back(msa);
actionsVec.push_back(action);
}
}
@@ -140,26 +140,26 @@ Core::FunctionReplyObject ObjectMissionPlan::createMissionPlan(Database::PpmMiss
{
Database::PpmMissionItem dbItem;
dbItem.missionPlanId = newMissionPlan.id;
dbItem.name = QString::fromStdString(item.name());
dbItem.elementNumber = item.itemNumber();
dbItem.location = LtsUtils::QPoint3D(item.location().lon(),item.location().lat(), item.location().z());
dbItem.name = QString::fromStdString(item.name);
dbItem.elementNumber = item.itemNumber;
dbItem.location = LtsUtils::QPoint3D(item.location.lon,item.location.lat, item.location.z);
if (!m_db->insert(dbItem))
return Core::FunctionReplyObject(0, tr_lts("dds", "Error adding 'Mission Item' to database"));
std::vector<Database::PpmMissionAction> actionsVec;
actionsVec.reserve(item.actions().size());
for (auto &action : item.actions())
actionsVec.reserve(item.actions.size());
for (auto &action : item.actions)
{
action.planId(newMissionPlan.id);
action.planId = newMissionPlan.id;
Database::PpmMissionAction dbAction;
dbAction.missionActionTypeId = action.actionType();
dbAction.missionActionTypeId = action.actionType;
dbAction.missionItemId = dbItem.id;
dbAction.duration = action.duration();
dbAction.name = QString::fromStdString(action.name());
dbAction.properties = QString::fromStdString(action.properties());
dbAction.fulfilled = QDateTime::fromMSecsSinceEpoch(action.fulfilled());
dbAction.elementNumber = action.actionNumber();
dbAction.duration = action.duration;
dbAction.name = QString::fromStdString(action.name);
dbAction.properties = QString::fromStdString(action.properties);
dbAction.fulfilled = QDateTime::fromMSecsSinceEpoch(action.fulfilled);
dbAction.elementNumber = action.actionNumber;
if (!m_db->insert(dbAction))
return Core::FunctionReplyObject(0, tr_lts("dds", "Error adding 'Mission Action' to database"));
@@ -169,21 +169,21 @@ Core::FunctionReplyObject ObjectMissionPlan::createMissionPlan(Database::PpmMiss
m_dbMissionActions.push_back(actionsVec); // [elNumber][actionNumber]
}//loop mission items
m_missionplan.id(newMissionPlan.id);
m_missionplan.name(newMissionPlan.name.toStdString());
m_missionplan.missionStart(newMissionPlan.missionStart.toMSecsSinceEpoch());
m_missionplan.participantId(newMissionPlan.participantId);
m_missionplan.jumpToStart(newMissionPlan.jumpToStart);
m_missionplan.repeat(newMissionPlan.repeat);
m_missionplan.items(itemVec);
m_missionplan.fulfilled(0);
m_missionplan.itemsFulfilled(0);
m_missionplan.id = newMissionPlan.id;
m_missionplan.name = newMissionPlan.name.toStdString();
m_missionplan.missionStart = newMissionPlan.missionStart.toMSecsSinceEpoch();
m_missionplan.participantId = newMissionPlan.participantId;
m_missionplan.jumpToStart = newMissionPlan.jumpToStart;
m_missionplan.repeat = newMissionPlan.repeat;
m_missionplan.items = itemVec;
m_missionplan.fulfilled = 0;
m_missionplan.itemsFulfilled = 0;
for (auto &item : m_missionplan.items())
for (auto &item : m_missionplan.items)
{
for (auto &action : item.actions())
DEBUG_LOG(m_logger)<<"[CREATE] itemIdx: "<<item.itemNumber()
<<" act.Num: "<<action.actionNumber()<<" act.ItemNum: "<<action.itemNumber()<<" itemFul:"<<action.fulfilled();
for (auto &action : item.actions)
DEBUG_LOG(m_logger)<<"[CREATE] itemIdx: "<<item.itemNumber
<<" act.Num: "<<action.actionNumber<<" act.ItemNum: "<<action.itemNumber<<" itemFul:"<<action.fulfilled;
}
trans.commit();
DEBUG_LOG(m_logger)<< ">> [NEW] mission plan with id( "<<newMissionPlan.id<<" ) inserted !!";
@@ -231,25 +231,25 @@ Core::FunctionReplyObject ObjectMissionPlan::updateMissionPlan(Database::PpmMiss
{
Database::PpmMissionItem dbItem;
dbItem.missionPlanId = newMissionPlan.id;
dbItem.name = QString::fromStdString(item.name());
dbItem.elementNumber = item.itemNumber();
dbItem.location = LtsUtils::QPoint3D(item.location().lon(),item.location().lat(), item.location().z());
dbItem.name = QString::fromStdString(item.name);
dbItem.elementNumber = item.itemNumber;
dbItem.location = LtsUtils::QPoint3D(item.location.lon,item.location.lat, item.location.z);
if (!m_db->insert(dbItem))
return Core::FunctionReplyObject(0, tr_lts("dds", "Error adding 'Mission Item' to database"));
std::vector<Database::PpmMissionAction> actionsVec;
actionsVec.reserve(item.actions().size());
for (auto &action : item.actions())
actionsVec.reserve(item.actions.size());
for (auto &action : item.actions)
{
action.planId(newMissionPlan.id);
action.planId = newMissionPlan.id;
Database::PpmMissionAction dbAction;
dbAction.missionActionTypeId = action.actionType();
dbAction.missionActionTypeId = action.actionType;
dbAction.missionItemId = dbItem.id;
dbAction.duration = action.duration();
dbAction.name = QString::fromStdString(action.name());
dbAction.properties = QString::fromStdString(action.properties());
dbAction.fulfilled = QDateTime::fromMSecsSinceEpoch(action.fulfilled());
dbAction.elementNumber = action.actionNumber();
dbAction.duration = action.duration;
dbAction.name = QString::fromStdString(action.name);
dbAction.properties = QString::fromStdString(action.properties);
dbAction.fulfilled = QDateTime::fromMSecsSinceEpoch(action.fulfilled);
dbAction.elementNumber = action.actionNumber;
if (!m_db->insert(dbAction))
return Core::FunctionReplyObject(0, tr_lts("dds", "Error adding 'Mission Action' to database"));
@@ -260,19 +260,19 @@ Core::FunctionReplyObject ObjectMissionPlan::updateMissionPlan(Database::PpmMiss
}//loop mission items
trans.commit();
m_missionplan.id(newMissionPlan.id);
m_missionplan.name(newMissionPlan.name.toStdString());
m_missionplan.missionStart(newMissionPlan.missionStart.toMSecsSinceEpoch());
m_missionplan.participantId(newMissionPlan.participantId);
m_missionplan.jumpToStart(newMissionPlan.jumpToStart);
m_missionplan.repeat(newMissionPlan.repeat);
m_missionplan.items(itemVec);
m_missionplan.itemsFulfilled(0); // on update items and action entries will be cleared
m_missionplan.fulfilled(0);
m_missionplan.id = newMissionPlan.id;
m_missionplan.name = newMissionPlan.name.toStdString();
m_missionplan.missionStart = newMissionPlan.missionStart.toMSecsSinceEpoch();
m_missionplan.participantId = newMissionPlan.participantId;
m_missionplan.jumpToStart = newMissionPlan.jumpToStart;
m_missionplan.repeat = newMissionPlan.repeat;
m_missionplan.items = itemVec;
m_missionplan.itemsFulfilled = 0; // on update items and action entries will be cleared
m_missionplan.fulfilled = 0;
DEBUG_LOG(m_logger)<< ">> [UPDATE] mission plan with id( "<<m_missionplan.id()<<" ) Updated !!";
DEBUG_LOG(m_logger)<< ">> [UPDATE] mission plan with id( "<<m_missionplan.id<<" ) Updated !!";
return Core::FunctionReplyObject(m_missionplan.id());
return Core::FunctionReplyObject(m_missionplan.id);
}
Core::FunctionReplyObject ObjectMissionPlan::removeMissionPlan(int id)
@@ -305,33 +305,33 @@ Core::FunctionReplyObject ObjectMissionPlan::setMissionActionFulfilled(SetMissio
return Core::FunctionReplyObject("");
}
if (req.missionId() != m_missionplan.id())
if (req.missionId != m_missionplan.id)
{
QString error = QStringLiteral("Wrong missionPlan Object caught Request: %1 / currPlanId: %2").arg(req.missionId()).arg(m_missionplan.id());
QString error = QStringLiteral("Wrong missionPlan Object caught Request: %1 / currPlanId: %2").arg(req.missionId).arg(m_missionplan.id);
ERROR_LOG(m_logger)<< error;
return Core::FunctionReplyObject(error.toStdString().c_str());
}
// Abort in case itemNumb=-1 && actionNumb=-1
if (req.actionNumber() < 0 && req.itemNumber() < 0)
if (req.actionNumber < 0 && req.itemNumber < 0)
{
m_missionplan.aborted(true);
m_missionplan.aborted = true;
return setMissionPlanAborted(true);
}
auto &dbActions = m_dbMissionActions[req.itemNumber()]; //[elemNum][actionNum]
auto &dbActions = m_dbMissionActions[req.itemNumber]; //[elemNum][actionNum]
if (dbActions.empty()
|| req.actionNumber() >= static_cast<int>(dbActions.size())
|| req.actionNumber() < 0
|| req.itemNumber() < 0) // actionNumber start by 0
|| req.actionNumber >= static_cast<int>(dbActions.size())
|| req.actionNumber < 0
|| req.itemNumber < 0) // actionNumber start by 0
{
QString error = QStringLiteral("Could not set mission action with id: %1 ! ").arg(req.actionNumber());
QString error = QStringLiteral("Could not set mission action with id: %1 ! ").arg(req.actionNumber);
ERROR_LOG(m_logger)<< error;
return Core::FunctionReplyObject(error.toStdString().c_str());
}
Database::PpmMissionAction &dbAction = dbActions[req.actionNumber()];
Database::PpmMissionAction &dbAction = dbActions[req.actionNumber];
dbAction.fulfilled = QDateTime::fromMSecsSinceEpoch(currentTimeMSec);
if (!m_db->update(dbAction))
@@ -348,11 +348,11 @@ Core::FunctionReplyObject ObjectMissionPlan::setMissionActionFulfilled(SetMissio
//4- if yes update missioPlan & missionItem fulfilled
MissionItem &msi = m_mapMissionItems[dbAction.missionItemId];
msi.fulfilled(dbAction.fulfilled.toMSecsSinceEpoch());
msi.actionsFulfilled(msi.actionsFulfilled() + 1);
MissionAction &msa = m_mapMissionItems[dbAction.missionItemId].actions()[dbAction.elementNumber];
msa.fulfilled(dbAction.fulfilled.toMSecsSinceEpoch());
m_missionplan.items()[req.itemNumber()] = m_mapMissionItems[dbAction.missionItemId]; // item in MissionPlan updated through elementNumber
msi.fulfilled = dbAction.fulfilled.toMSecsSinceEpoch();
msi.actionsFulfilled = msi.actionsFulfilled + 1;
MissionAction &msa = m_mapMissionItems[dbAction.missionItemId].actions[dbAction.elementNumber];
msa.fulfilled = dbAction.fulfilled.toMSecsSinceEpoch();
m_missionplan.items[req.itemNumber] = m_mapMissionItems[dbAction.missionItemId]; // item in MissionPlan updated through elementNumber
/// update fulfilled time for items and mission plan
/// update fulfilled items count
@@ -360,27 +360,27 @@ Core::FunctionReplyObject ObjectMissionPlan::setMissionActionFulfilled(SetMissio
int numbItemFulfilled = 0;
for(const auto &item : m_mapMissionItems)
{
if (item.actionsFulfilled() == static_cast<int>(item.actions().size()))
if (item.actionsFulfilled == static_cast<int>(item.actions.size()))
numbItemFulfilled++;
}
m_missionplan.itemsFulfilled(numbItemFulfilled);
m_missionplan.fulfilled(dbAction.fulfilled.toMSecsSinceEpoch());
m_missionplan.itemsFulfilled = numbItemFulfilled;
m_missionplan.fulfilled = dbAction.fulfilled.toMSecsSinceEpoch();
return Core::FunctionReplyObject(m_missionplan.id());
return Core::FunctionReplyObject(m_missionplan.id);
}
Core::FunctionReplyObject ObjectMissionPlan::setMissionPlanAborted(bool state)
{
DEBUG_LOG(m_logger)<<" -- [setMissionPlanAborted] abort mission plan: "<<m_missionplan.id();
DEBUG_LOG(m_logger)<<" -- [setMissionPlanAborted] abort mission plan: "<<m_missionplan.id;
Database::PpmMissionPlan dbMissionPlan;
// m_db->selectPpmMissionPlan(m_missionplan.id(),dbMissionPlan);
dbMissionPlan.missionStart = QDateTime::fromMSecsSinceEpoch(m_missionplan.missionStart());
dbMissionPlan.jumpToStart = m_missionplan.jumpToStart();
dbMissionPlan.id = m_missionplan.id();
dbMissionPlan.name = QString::fromStdString(m_missionplan.name());
dbMissionPlan.participantId = m_missionplan.participantId();
dbMissionPlan.repeat = m_missionplan.repeat();
dbMissionPlan.missionStart = QDateTime::fromMSecsSinceEpoch(m_missionplan.missionStart);
dbMissionPlan.jumpToStart = m_missionplan.jumpToStart;
dbMissionPlan.id = m_missionplan.id;
dbMissionPlan.name = QString::fromStdString(m_missionplan.name);
dbMissionPlan.participantId = m_missionplan.participantId;
dbMissionPlan.repeat = m_missionplan.repeat;
dbMissionPlan.aborted = state;
@@ -392,7 +392,7 @@ Core::FunctionReplyObject ObjectMissionPlan::setMissionPlanAborted(bool state)
return Core::FunctionReplyObject(error.toStdString().c_str());
}
return Core::FunctionReplyObject(m_missionplan.id());
return Core::FunctionReplyObject(m_missionplan.id);
}
} // namespace UasHandling
@@ -36,7 +36,7 @@ public:
static MissionPlan fillMissionPlanData(const ModifyMissionPlanRequest &in);
MissionPlan getMissionPlanData() const;
void setDbMissionItems( const QMap <int, ParticipantManagement::Database::PpmMissionItem> &dbItems,
const QMap <int, ParticipantManagement::Database::PpmMissionAction> &dbActions);
const QMultiMap <int, ParticipantManagement::Database::PpmMissionAction> &dbActions);
const ParticipantManagement::MissionPlan &missionPlan() const;
Core::FunctionReplyObject createMissionPlan(Database::PpmMissionPlan newMissionPlan, const std::vector<MissionItem> &missionItems);
Core::FunctionReplyObject updateMissionPlan(Database::PpmMissionPlan newMissionPlan, const std::vector<MissionItem> &missionItems);
@@ -15,21 +15,21 @@ namespace UasHandling
bool Uas::hasChanges(const CreateModifyUasRequest &request)
{
bool hasChanges = request.deviceIdentifier() != m_data.deviceIdentifier.toStdString() ||
request.participantId() != m_data.participantId ||
request.exerciseId() != m_data.exerciseId ||
request.hostname() != m_data.hostname.toStdString() ||
request.hostport() != m_data.hostport ||
request.useTcp() != m_data.useTcp;
bool hasChanges = request.deviceIdentifier != m_data.deviceIdentifier.toStdString() ||
request.participantId != m_data.participantId ||
request.exerciseId != m_data.exerciseId ||
request.hostname != m_data.hostname.toStdString() ||
request.hostport != m_data.hostport ||
request.useTcp != m_data.useTcp;
if (hasChanges)
{
m_data.deviceIdentifier = QString::fromStdString(request.deviceIdentifier());
m_data.participantId = request.participantId();
m_data.exerciseId = request.exerciseId();
m_data.hostname = QString::fromStdString(request.hostname());
m_data.hostport = request.hostport();
m_data.useTcp = request.useTcp();
m_data.deviceIdentifier = QString::fromStdString(request.deviceIdentifier);
m_data.participantId = request.participantId;
m_data.exerciseId = request.exerciseId;
m_data.hostname = QString::fromStdString(request.hostname);
m_data.hostport = request.hostport;
m_data.useTcp = request.useTcp;
}
return hasChanges;
@@ -53,7 +53,7 @@ void Uas::unlinkUas()
void Uas::setState(const ProjectDataManagement::UasState &newState)
{
m_data.uasStateId = newState.underlying();
m_data.uasStateId = static_cast<int>(newState);
}
int32_t Uas::id() const
{
@@ -74,15 +74,15 @@ UAS Uas::toDdsUas() const
{
ParticipantManagement::UAS result;
result.id(m_data.id);
result.deviceIdentifier(m_data.deviceIdentifier.toStdString());
result.uasState(static_cast<ProjectDataManagement::UasState>(m_data.uasStateId));
result.participantId(m_data.participantId);
result.exerciseId(m_data.exerciseId);
result.hostname(m_data.hostname.toStdString());
result.hostport(m_data.hostport);
result.sampleTime(QDateTime::currentDateTimeUtc().toMSecsSinceEpoch());
result.useTcp(m_data.useTcp);
result.id = m_data.id;
result.deviceIdentifier = m_data.deviceIdentifier.toStdString();
result.uasState = static_cast<ProjectDataManagement::UasState>(m_data.uasStateId);
result.participantId = m_data.participantId;
result.exerciseId = m_data.exerciseId;
result.hostname = m_data.hostname.toStdString();
result.hostport = m_data.hostport;
result.sampleTime = QDateTime::currentDateTimeUtc().toMSecsSinceEpoch();
result.useTcp = m_data.useTcp;
return result;
}
@@ -83,7 +83,7 @@ bool UasHandler::init()
//------------------------------------------------------------------------------------------
void UasHandler::onCreateModifyUasRequest(const rti::core::SampleIdentity &cookie, const CreateModifyUasRequest &request)
{
Core::FunctionReplyObject reply = request.id() == 0 ? createUas(request) : modifyUas(request);
Core::FunctionReplyObject reply = request.id == 0 ? createUas(request) : modifyUas(request);
m_mainHandler->exAnyFts()->createModifyUasReply(cookie, reply);
}
@@ -101,18 +101,18 @@ Core::FunctionReplyObject UasHandler::removeUas(const RemoveUasRequest &request)
{
DEBUG_LOG(m_logger) << "onRemoveUasRequest " << request;
if (request.id() < 0)
if (request.id < 0)
return Core::FunctionReplyObject(tr_lts("dds", "Got request to delete an UAS, but no valid UAS id to delete"));
UasHandling::Uas *uasToDelete = m_uass.value(request.id());
UasHandling::Uas *uasToDelete = m_uass.value(request.id);
if (!uasToDelete)
return Core::FunctionReplyObject(tr_lts("dds", "Could not delete UAS with id %1, because no UAS with that id exists"))
.arg(request.id());
.arg(request.id);
if (uasToDelete->participantId() > 0)
return Core::FunctionReplyObject(tr_lts("dds", "Not possible to delete a UAS in use"));
DEBUG_LOG(m_logger) << "Removing UAS with ID " << request.id();
DEBUG_LOG(m_logger) << "Removing UAS with ID " << request.id;
return removeUas(uasToDelete);
}
@@ -153,13 +153,13 @@ Core::FunctionReplyObject UasHandler::createUas(const CreateModifyUasRequest &re
Database::PpmUas dbUas;
dbUas.deviceIdentifier = QString::fromStdString(request.deviceIdentifier());
dbUas.uasStateId = ProjectDataManagement::UasState::UasState_Undefined;
dbUas.participantId = request.participantId();
dbUas.exerciseId = request.exerciseId();
dbUas.hostname = QString::fromStdString(request.hostname());
dbUas.hostport = request.hostport();
dbUas.useTcp = request.useTcp();
dbUas.deviceIdentifier = QString::fromStdString(request.deviceIdentifier);
dbUas.uasStateId = static_cast<int>(ProjectDataManagement::UasState::UasState_Undefined);
dbUas.participantId = request.participantId;
dbUas.exerciseId = request.exerciseId;
dbUas.hostname = QString::fromStdString(request.hostname);
dbUas.hostport = request.hostport;
dbUas.useTcp = request.useTcp;
if (hostNameHostPortExists(dbUas.hostname, dbUas.hostport, -1))
return Core::FunctionReplyObject(tr_lts("dds", "Hostname with Port %1:%2 already exists"))
@@ -185,21 +185,21 @@ Core::FunctionReplyObject UasHandler::createUas(const CreateModifyUasRequest &re
//------------------------------------------------------------------------------------------
Core::FunctionReplyObject UasHandler::modifyUas(const CreateModifyUasRequest &request)
{
if (!m_uass.contains(request.id()))
if (!m_uass.contains(request.id))
{
QString error = QStringLiteral("Uas topic with id %1 not present. Not possible to modify it.").arg(request.id());
QString error = QStringLiteral("Uas topic with id %1 not present. Not possible to modify it.").arg(request.id);
ERROR_LOG(m_logger) << error;
return Core::FunctionReplyObject(error.toStdString().c_str());
}
Uas *uas = m_uass.value(request.id());
Uas *uas = m_uass.value(request.id);
// Check if Hostname and Hostport already existing
if (hostNameHostPortExists(QString::fromStdString(request.hostname()), request.hostport(), uas->id()))
if (hostNameHostPortExists(QString::fromStdString(request.hostname), request.hostport, uas->id()))
return Core::FunctionReplyObject(tr_lts("dds", "Hostname with Port %1:%2 already exists"))
.arg(request.hostname()).arg(request.hostport());
.arg(request.hostname).arg(request.hostport);
if (!uas->hasChanges(request))
{
@@ -248,16 +248,16 @@ void UasHandler::onExerciseChanged(const ExerciseManagement::Exercise &data, Dat
{
Q_UNUSED(mod)
if (data.state() != ExerciseManagement::ExerciseState::Stopped &&
data.state() != ExerciseManagement::ExerciseState::Terminated &&
data.state() != ExerciseManagement::ExerciseState::Unknown )
if (data.state != ExerciseManagement::ExerciseState::Stopped &&
data.state != ExerciseManagement::ExerciseState::Terminated &&
data.state != ExerciseManagement::ExerciseState::Unknown )
return;
//Unlink
for (auto uas : m_uass)
{
auto uasData = uas->toDdsUas();
if (uasData.exerciseId() != data.id())
if (uasData.exerciseId != data.id)
continue;
uas->unlinkUas();
@@ -268,16 +268,16 @@ void UasHandler::onExerciseChanged(const ExerciseManagement::Exercise &data, Dat
void UasHandler::onUASRadioLinkConnectionStatusChanged(const UASRadioLinkConnectionStatus &data, DataModification mod)
{
if (data.id() <= 0)
if (data.id <= 0)
return;
if (!m_uass.contains(data.id()))
if (!m_uass.contains(data.id))
return;
auto uas = m_uass.value(data.id());
auto uas = m_uass.value(data.id);
if (mod == DataModification::eRemoved)
uas->setState(ProjectDataManagement::UasState::UasState_Undefined);
else
uas->setState(data.uasState());
uas->setState(data.uasState);
m_mainHandler->exAnyDts()->publish(uas->toDdsUas());
m_mainHandler->db()->update(uas->toDbUas());
}
@@ -52,12 +52,12 @@ LtsWebSocket::ReplyMessage *DataManager::ocPositionData(int equipmentNr, const Q
}
ParticipantPosition pos = m_ppmDtc->participantPosition(m_ppmDtc->participantIdByEquipmentNumber(equipmentNr));
QJsonObject obj;
obj[QStringLiteral("participantId")] = pos.participantId();
obj[QStringLiteral("lat")] = pos.pos().lat();
obj[QStringLiteral("lon")] = pos.pos().lon();
obj[QStringLiteral("height")] = pos.pos().z();
obj[QStringLiteral("roomId")] = pos.roomId();
obj[QStringLiteral("buildingId")] = pos.buildingId();
obj[QStringLiteral("participantId")] = pos.participantId;
obj[QStringLiteral("lat")] = pos.pos.lat;
obj[QStringLiteral("lon")] = pos.pos.lon;
obj[QStringLiteral("height")] = pos.pos.z;
obj[QStringLiteral("roomId")] = pos.roomId;
obj[QStringLiteral("buildingId")] = pos.buildingId;
return new ParticipantManagement::WebSocketInterface::Messages::OcPositionData(obj, uuid);
}
@@ -20,36 +20,36 @@ inline Type convert(const PpmType &data)
{
Type ddsData;
ddsData.id(data.id);
ddsData.typeClass(data.typeClassId);
ddsData.equipmentTypeId(data.equipmentTypeId.isNull() ? 0 : data.equipmentTypeId.toInt());
ddsData.name(data.name.toStdString());
ddsData.symbol(data.symbol.toStdString());
ddsData.radioCount(data.radioCount);
ddsData.hierarchyLevel(data.hierarchyLevel);
ddsData.isDeleted(data.isDeleted);
ddsData.id = data.id;
ddsData.typeClass = data.typeClassId;
ddsData.equipmentTypeId = data.equipmentTypeId.isNull() ? 0 : data.equipmentTypeId.toInt();
ddsData.name = data.name.toStdString();
ddsData.symbol = data.symbol.toStdString();
ddsData.radioCount = data.radioCount;
ddsData.hierarchyLevel = data.hierarchyLevel;
ddsData.isDeleted = data.isDeleted;
#ifdef Q_OS_WIN
ddsData.disEntities(data.disEntities());
ddsData.disEntities = data.disEntities();
#else
ddsData.disEntities(LtsUtils::convert<std::vector<rti::core::int64>>(data.disEntities()));
ddsData.disEntities = data.disEntities();
#endif
ddsData.properties(data.properties.toStdString());
ddsData.properties = data.properties.toStdString();
return ddsData;
}
inline EquipmentType convert(const PpmEquipmentType &db)
{
EquipmentType et;
et.id(db.id);
et.name(db.name.toStdString());
et.id = db.id;
et.name = db.name.toStdString();
{ // equipment value are save in the db as int, but in dds unsigned short is used.
et.minEquipNo(db.minEquipNo < USHRT_MAX ? db.minEquipNo : USHRT_MAX);
et.maxEquipNo(db.maxEquipNo < USHRT_MAX ? db.maxEquipNo : USHRT_MAX);
et.minEquipNo = db.minEquipNo < USHRT_MAX ? db.minEquipNo : USHRT_MAX;
et.maxEquipNo = db.maxEquipNo < USHRT_MAX ? db.maxEquipNo : USHRT_MAX;
}
et.traVulnerabilityModelId(db.traVulnerabilityModelId);
et.traPlayerTypeId(db.traPlayerTypeId);
et.wmsTypeClass(db.wmsTypeClassId);
et.deletedInWms(db.deletedInWms);
et.traVulnerabilityModelId = db.traVulnerabilityModelId;
et.traPlayerTypeId = db.traPlayerTypeId;
et.wmsTypeClass = db.wmsTypeClassId;
et.deletedInWms = db.deletedInWms;
return et;
}
@@ -40,9 +40,9 @@ StateInformation youngestStateInformation(const std::vector<ParticipantManagemen
// for (const ParticipantManagement::StateInformation &si : std::as_const(stateList))
// {
// if (si.originatorId() == 0
// && si.originatorType() == ProjectDataManagement::StateChangeOriginator::ExerciseControl
// && (si.vulnerabilityState() == ProjectDataManagement::VulnerabilityState::CatastrophicKill
// || si.vulnerabilityState() == ProjectDataManagement::VulnerabilityState::CombatReady)
// && si.originatorType() == ProjectDataManagement::StateChangeOriginator::StateChangeOriginator_ExerciseControl
// && (si.vulnerabilityState() == ProjectDataManagement::VulnerabilityState::VulnerabilityState_CatastrophicKill
// || si.vulnerabilityState() == ProjectDataManagement::VulnerabilityState::VulnerabilityState_CombatReady)
// )
// readyToDebug = true;
// }
@@ -66,7 +66,7 @@ StateInformation youngestStateInformation(const std::vector<ParticipantManagemen
// if (readyToDebug)
// debug = true;
// qWarning() << "WARNING: StateInformation with state" << (int)left.vulnerabilityState().underlying() << "has the same stateTime as StateInformation with state" << (int)right.vulnerabilityState().underlying();
// qWarning() << "WARNING: StateInformation with state" << (int)left.vulnerabilityState() << "has the same stateTime as StateInformation with state" << (int)right.vulnerabilityState();
// sort by state if time is the same (higher state = winner)
return (left.vulnerabilityState > right.vulnerabilityState);
@@ -194,7 +194,7 @@ int DtcImplCustom::participantIdByEquipmentNumber(int equipmentNumber) const
for (const auto &sample : m_dtcParticipant->readAlive())
{
if (sample.data().equipmentNumber.is_set() && sample.data().equipmentNumber.get() == equipmentNumber)
if (sample.data().equipmentNumber.has_value() && sample.data().equipmentNumber.get() == equipmentNumber)
return sample.data().id;
}
@@ -210,7 +210,7 @@ int DtcImplCustom::equipmentNumberByParticipantId(int participantId) const
{
if (sample.data().id == participantId)
{
if (sample.data().equipmentNumber.is_set())
if (sample.data().equipmentNumber.has_value())
return sample.data().equipmentNumber.get();
}
}
@@ -477,7 +477,7 @@ QVector<TemplateParticipant> DtcImplCustom::inferiorTemplates(int templateId)
const TemplateParticipant participant = templateParticipant(templateId);
retVector.append(participant);
if (participant.inferiorIds.is_set())
if (participant.inferiorIds.has_value())
{
retVector.reserve(participant.inferiorIds.get().size() + retVector.size());
for (int inferiorId : participant.inferiorIds.get())
@@ -62,11 +62,11 @@ bool WebSocketHandler::init(const QPair<quint16, quint16> &portRange)
bool WebSocketHandler::sendTelegramInternal(const ParticipantPosition &pos, int eqNo) const
{
QJsonObject obj;
obj[QStringLiteral("participantId")] = pos.participantId();
obj[QStringLiteral("participantId")] = pos.participantId;
obj[QStringLiteral("equipmentNumber")] = eqNo;
obj[QStringLiteral("lat")] = pos.pos().lat();
obj[QStringLiteral("lon")] = pos.pos().lon();
obj[QStringLiteral("height")] = pos.pos().z();
obj[QStringLiteral("lat")] = pos.pos.lat;
obj[QStringLiteral("lon")] = pos.pos.lon;
obj[QStringLiteral("height")] = pos.pos.z;
const QString jsonStr = QString::fromUtf8(QJsonDocument(obj).toJson(QJsonDocument::Compact));