qt5-legatus-legacy/Lts/Services/OcSituationServer/central_aes_data_builder.cpp

/**
  * Manages central aes data to be sent
  * $Id: handler_oc_situation_data.h 57655 2022-07-20 11:38:28Z karwat $
  * $HeadURL: svn://192.168.133.21/TDS/branches/product/features/3dws_devel/Lts/Services/OcSituationServer/handler_oc_situation_data.h $
  * $Author: karwat $
  * Created by Hannes Fritsche, SLTE, 16-08-2022
  */

#include "central_aes_data_builder.h"
#include "LtsUtils/LtsUtilsCore/qbytearray_byteaccess.h"
#include "QLineF"

namespace OcSituationServer
{

namespace DataBuilder
{

QByteArray getByteStreamAesItem(const AreaEffectSimulation::EffectCluster &effectCluster, bool &isPrioritized)
{
  QByteArray byteStream;

  isPrioritized = false;

  addAesType(byteStream, AreaEffectSimulation::AesType::AtExplosionCluster); // we send EffectCluster as ExplosionCluster
  addAesItemId(byteStream, effectCluster.id());
  addName(byteStream, effectCluster.name());
  addEffectStart(byteStream, effectCluster.effectStart().is_set() ? effectCluster.effectStart().get() : -1);
  addEffectDuration(byteStream, effectCluster.effectDuration());
  addArea(byteStream, effectCluster.area());
  addMhpCount(byteStream, static_cast<int32_t>(effectCluster.effectors().size()));
  addMhpRotation(byteStream, effectCluster.effectors().size() ? effectCluster.effectors()[0].mhpRotation() : 1);
  addImpactCount(byteStream, static_cast<int32_t>(effectCluster.effectors().size()));
  addChargeTypeId(byteStream, effectCluster.chargeStruct().chargeTypeId());
  addPartyId(byteStream, effectCluster.partyId().is_set() ? effectCluster.partyId().get() : -1);

  return byteStream;
}

QByteArray getByteStreamAesItem(const AreaEffectSimulation::NContamination &nContamination, bool &isPrioritized)
{
  QByteArray byteStream;

  isPrioritized = false;

  addAesType(byteStream, AreaEffectSimulation::AesType::AtNContamination);
  addAesItemId(byteStream, nContamination.id());
  addName(byteStream, nContamination.name());
  addEffectStart(byteStream, nContamination.effectStart().is_set() ? nContamination.effectStart().get() : -1);
  addEffectDuration(byteStream, nContamination.effectDuration());
  addChargeTypeId(byteStream, nContamination.chargeStruct().chargeTypeId());
  addImpactPosition(byteStream, nContamination.impactPosition());
  addBorderLengthInner(byteStream, nContamination.borderLengthInner());
  addBorderLengthOuter(byteStream, nContamination.borderLengthOuter());
  addImpactRadius(byteStream, nContamination.impactRadius());
  addSpanAngle(byteStream, nContamination.spanAngle());
  addRotationAngle(byteStream, nContamination.rotationAngle());
  addDetonationValue(byteStream, nContamination.detonationValue());
  addPartyId(byteStream, nContamination.partyId().is_set() ? nContamination.partyId().get() : -1);

  return byteStream;
}

QByteArray getByteStreamAesItem(const AreaEffectSimulation::BCContamination &bCContamination, bool &isPrioritized)
{
  QByteArray byteStream;

  isPrioritized = false;

  addAesType(byteStream, AreaEffectSimulation::AesType::AtBCContamination);
  addAesItemId(byteStream, bCContamination.id());
  addName(byteStream, bCContamination.name());
  addEffectStart(byteStream, bCContamination.effectStart().is_set() ? bCContamination.effectStart().get() : -1);
  addEffectDuration(byteStream, bCContamination.effectDuration());
  addChargeTypeId(byteStream, bCContamination.chargeStruct().chargeTypeId());
  addImpactPosition(byteStream, bCContamination.impactPosition());
  addImpactRadius(byteStream, bCContamination.impactRadius());
  addPartyId(byteStream, bCContamination.partyId().is_set() ? bCContamination.partyId().get() : -1);
  addPropagationDirection(byteStream, bCContamination.propagationDirection());
  addWindSpeed(byteStream, bCContamination.windSpeed());

  return byteStream;
}

QByteArray getByteStreamAesItem(const AreaEffectSimulation::ExplosionArea &explosionArea, bool &isPrioritized)
{
  QByteArray byteStream;

  isPrioritized = false;

  addAesType(byteStream, AreaEffectSimulation::AesType::AtExplosionArea);
  addAesItemId(byteStream, explosionArea.id());
  addName(byteStream, explosionArea.name());
  addEffectStart(byteStream, explosionArea.effectStart().is_set() ? explosionArea.effectStart().get() : -1);
  addEffectDuration(byteStream, explosionArea.effectDuration());
  addChargeTypeId(byteStream, explosionArea.chargeStruct().chargeTypeId());
  addArea(byteStream, explosionArea.area());
  addPartyId(byteStream, explosionArea.partyId().is_set() ? explosionArea.partyId().get() : -1);
  addCannonCount(byteStream, explosionArea.cannonCount());
  addCannonRounds(byteStream, explosionArea.cannonRounds());
  addFireRequestTime(byteStream, explosionArea.fireRequestTime());
  addAltitude(byteStream, explosionArea.altitude());
  addPurpose(byteStream, explosionArea.purpose());

  return byteStream;
}

QByteArray getByteStreamAesItem(const AreaEffectSimulation::ExplosionSingle &explosionSingle, bool &isPrioritized)
{
  QByteArray byteStream;

  isPrioritized = false;

  addAesType(byteStream, AreaEffectSimulation::AesType::AtExplosionSingle);
  addAesItemId(byteStream, explosionSingle.id());
  addName(byteStream, explosionSingle.name());
  addEffectStart(byteStream, explosionSingle.effectStart().is_set() ? explosionSingle.effectStart().get() : -1);
  addChargeTypeId(byteStream, explosionSingle.chargeStruct().chargeTypeId());
  addImpactPosition(byteStream, explosionSingle.impactPosition());
  addPartyId(byteStream, explosionSingle.partyId().is_set() ? explosionSingle.partyId().get() : -1);
  addFireRequestTime(byteStream, explosionSingle.fireRequestTime());
  addAltitude(byteStream, explosionSingle.altitude());
  addPurpose(byteStream, explosionSingle.purpose());

  return byteStream;
}

QByteArray getByteStreamAesItem(const AreaEffectSimulation::MineArea &mineArea, bool &isPrioritized)
{
  QByteArray byteStream;

  isPrioritized = false;

  addAesType(byteStream, AreaEffectSimulation::AesType::AtMineArea);
  addAesItemId(byteStream, mineArea.id());
  addName(byteStream, mineArea.name());
  addEffectStart(byteStream, mineArea.effectStart().is_set() ? mineArea.effectStart().get() : -1);
  addEffectDuration(byteStream, mineArea.effectDuration());
  addDensity(byteStream, mineArea.density());
  addWidth(byteStream, mineArea.width());
  addChargeTypeId(byteStream, mineArea.chargeStruct().chargeTypeId());
  addPartyId(byteStream, mineArea.partyId().is_set() ? mineArea.partyId().get() : -1);
  addAesMaLayingProcedureType(byteStream, mineArea.layingProcedureType());
  addIsLayedHidden(byteStream, mineArea.isLaidHidden());
  addIsCenterLine(byteStream, mineArea.isCenterLine());
  addSegments(byteStream, mineArea.segments());

  return byteStream;
}

QByteArray getByteStreamAesItem(const AreaEffectSimulation::FunctionalArea &functionalArea, bool &isPrioritized)
{
  QByteArray byteStream;

  isPrioritized = false;

  addAesType(byteStream, AreaEffectSimulation::AesType::AtFunctionalArea);
  addAesItemId(byteStream, functionalArea.id());
  addName(byteStream, functionalArea.name());
  addEffectStart(byteStream, functionalArea.effectStart().is_set() ? functionalArea.effectStart().get() : -1);
  addEffectDuration(byteStream, functionalArea.effectDuration());
  addChargeTypeId(byteStream, functionalArea.chargeStruct().chargeTypeId());
  addArea(byteStream, functionalArea.area());
  addPartyId(byteStream, functionalArea.partyId().is_set() ? functionalArea.partyId().get() : -1);
  addPointSymbol(byteStream, functionalArea.pointSymbol().is_set() ? functionalArea.pointSymbol().get() : std::string());
  addFunctionalAreaTypeId(byteStream, functionalArea.functionalAreaTypeId());
  addDeconMode(byteStream, functionalArea.deconMode());
  addDeconTime(byteStream, functionalArea.deconTime());
  addMaintMode(byteStream, functionalArea.maintMode());
  addMaintTime(byteStream, functionalArea.maintTime());
  addMedicMode(byteStream, functionalArea.medicMode());
  addMedicTime(byteStream, functionalArea.medicTime());

  return byteStream;
}

QByteArray getByteStreamAesItem(const AreaEffectSimulation::BoobyTrap &boobyTrap, bool &isPrioritized)
{
  QByteArray byteStream;

  isPrioritized = false;

  addAesType(byteStream, AreaEffectSimulation::AesType::AtBoobyTrap);
  addAesItemId(byteStream, boobyTrap.id());
  addName(byteStream, boobyTrap.name());
  addEffectDuration(byteStream, boobyTrap.effectDuration());
  addChargeTypeId(byteStream, boobyTrap.chargeStruct().chargeTypeId());
  addImpactPosition(byteStream, boobyTrap.impactPosition());
  addImpactRadius(byteStream, boobyTrap.impactRadius());
  addTriggerRadius(byteStream, boobyTrap.triggerRadius());
  addRotationAngle(byteStream, boobyTrap.rotationAngle().is_set() ? boobyTrap.rotationAngle().get() : -1);
  addCentralAngle(byteStream, boobyTrap.centralAngle().is_set() ? boobyTrap.centralAngle().get() : -1);
  addEffectStart(byteStream, boobyTrap.effectStart().is_set() ? boobyTrap.effectStart().get() : -1);
  addPartyId(byteStream, boobyTrap.partyId().is_set() ? boobyTrap.partyId().get() : -1);

  return byteStream;
}

QByteArray getByteStreamAesItem(const AreaEffectSimulation::OffRouteMine &offRouteMine, bool &isPrioritized)
{
  QByteArray byteStream;

  isPrioritized = false;

  addAesType(byteStream, AreaEffectSimulation::AesType::AtOffRouteMine);
  addAesItemId(byteStream, offRouteMine.id());
  addName(byteStream, offRouteMine.name());
  addEffectDuration(byteStream, offRouteMine.effectDuration());
  addChargeTypeId(byteStream, offRouteMine.chargeStruct().chargeTypeId());
  addArea(byteStream, offRouteMine.area());
  addImpactRadius(byteStream, offRouteMine.impactRadius().is_set() ? offRouteMine.impactRadius().get() : -1);
  addEffectStart(byteStream, offRouteMine.effectStart().is_set() ? offRouteMine.effectStart().get() : -1);
  addPartyId(byteStream, offRouteMine.partyId().is_set() ? offRouteMine.partyId().get() : -1);

  return byteStream;
}

QByteArray getByteStreamAesItem(const AreaEffectSimulation::ExplosionCluster &explosionCluster, bool &isPrioritized)
{
  QByteArray byteStream;

  addAesType(byteStream, AreaEffectSimulation::AesType::AtExplosionCluster);
  addAesItemId(byteStream, explosionCluster.id());
  addName(byteStream, explosionCluster.name());
  addEffectStart(byteStream, explosionCluster.effectStart().is_set() ? explosionCluster.effectStart().get() : -1);
  addEffectDuration(byteStream, explosionCluster.effectDuration());
  addArea(byteStream, explosionCluster.area());
  addMhpCount(byteStream, static_cast<int32_t>(explosionCluster.mhPoints().size()));
  addMhpRotation(byteStream, explosionCluster.mhpRotation());
  addImpactCount(byteStream, explosionCluster.impactCount());
  addChargeTypeId(byteStream, explosionCluster.chargeStruct().chargeTypeId());
  addPartyId(byteStream, explosionCluster.partyId().is_set() ? explosionCluster.partyId().get() : -1);

  isPrioritized = explosionCluster.impactCount() == 1;  // we prioritize every single fire

  return byteStream;
}

void addAesItemId(QByteArray &buf, int32_t aesItemId)
{
  LtsUtils::set4Byte(aesItemId, buf);
}

void addAesMaLayingProcedureType(QByteArray &buf, const AreaEffectSimulation::AesMaLayingProcedureType &aesMaLayingProcedureType)
{
  addDdsEnumVal(buf, aesMaLayingProcedureType);
}

void addAesType(QByteArray &buf, const AreaEffectSimulation::AesType &aesType)
{
  using namespace AreaEffectSimulation;

  // we treat EffectClusters as ExplosionClusters
  addDdsEnumVal(buf, aesType == AesType::inner_enum::AtEffectCluster ? AesType::inner_enum::AtExplosionCluster : aesType);
}

void addAltitude(QByteArray &buf, int32_t altitude)
{
  LtsUtils::set4Byte(altitude, buf);
}

void addArea(QByteArray &buf, const AreaEffectSimulation::Area &area)
{
  addPosition2D(buf, area.cornerBottomLeft());
  LtsUtils::set8Byte(area.width(), buf);
  LtsUtils::set8Byte(area.height(), buf);
  LtsUtils::set8Byte(area.rotation(), buf);
}

void addBorderLengthInner(QByteArray &buf, double borderLengthInner)
{
  LtsUtils::set8Byte(borderLengthInner, buf);
}

void addBorderLengthOuter(QByteArray &buf, double borderLengthOuter)
{
  LtsUtils::set8Byte(borderLengthOuter, buf);
}

void addCannonCount(QByteArray &buf, int32_t cannonCount)
{
  LtsUtils::set4Byte(cannonCount, buf);
}

void addCannonRounds(QByteArray &buf, int32_t cannonRounds)
{
  LtsUtils::set4Byte(cannonRounds, buf);
}

void addCentralAesChangeType(QByteArray &buf, OcSituation::CentralAesChangeType changeType)
{
  LtsUtils::set1Byte(changeType, buf);
}

void addCentralAngle(QByteArray &buf, double centralAngle)
{
  LtsUtils::set8Byte(centralAngle, buf);
}

void addChargeTypeId(QByteArray &buf, int32_t chargeType)
{
  LtsUtils::set4Byte(chargeType, buf);
}

template<typename T>
void addDdsEnumVal(QByteArray &buf, const T &ddsEnumVal)
{
  LtsUtils::set4Byte(static_cast<int32_t>(ddsEnumVal.underlying()), buf);
}

void addDeconMode(QByteArray &buf, const AreaEffectSimulation::AesOperatingMode &deconMode)
{
  addDdsEnumVal(buf, deconMode);
}

void addDeconTime(QByteArray &buf, int32_t deconTime)
{
  LtsUtils::set4Byte(deconTime, buf);
}

void addDensity(QByteArray &buf, double density)
{
  LtsUtils::set8Byte(density, buf);
}

void addDetonationValue(QByteArray &buf, double detonationValue)
{
  LtsUtils::set8Byte(detonationValue, buf);
}

void addEffectDuration(QByteArray &buf, int32_t effectDuration)
{
  LtsUtils::set4Byte(effectDuration, buf);
}

void addEffectStart(QByteArray &buf, rti::core::int64 effectStart)
{
  LtsUtils::set8Byte(effectStart, buf);
}

void addExplosionGeometry(QByteArray &buf, const AreaEffectSimulation::AesExplosionGeometry &explosionGeometry)
{
  addDdsEnumVal(buf, explosionGeometry);
}

void addFireRequestTime(QByteArray &buf, rti::core::int64 fireRequestTime)
{
  LtsUtils::set8Byte(fireRequestTime, buf);
}

void addIgniterType(QByteArray &buf, int32_t igniterTypeId)
{
  LtsUtils::set4Byte(igniterTypeId, buf);
}

void addFunctionalAreaTypeId(QByteArray &buf, int32_t functionalAreaTypeId)
{
  LtsUtils::set4Byte(functionalAreaTypeId, buf);
}

void addImpactCount(QByteArray &buf, int32_t impactCount)
{
  LtsUtils::set4Byte(impactCount, buf);
}

void addImpactPosition(QByteArray &buf, const Core::GeoPosition2D &position)
{
  addPosition2D(buf, position);
}

void addImpactRadius(QByteArray &buf, double impactRadius)
{
  LtsUtils::set8Byte(impactRadius, buf);
}

void addIsCenterLine(QByteArray &buf, bool isCenterLine)
{
  LtsUtils::set1Byte(isCenterLine, buf);
}

void addIsLayedHidden(QByteArray &buf, bool isLayedHidden)
{
  LtsUtils::set1Byte(isLayedHidden, buf);
}

void addMaintMode(QByteArray &buf, const AreaEffectSimulation::AesOperatingMode &maintMode)
{
  addDdsEnumVal(buf, maintMode);
}

void addMaintTime(QByteArray &buf, int32_t maintTime)
{
  LtsUtils::set4Byte(maintTime, buf);
}

void addMedicMode(QByteArray &buf, const AreaEffectSimulation::AesOperatingMode &medicMode)
{
  addDdsEnumVal(buf, medicMode);
}

void addMedicTime(QByteArray &buf, int32_t medicTime)
{
  LtsUtils::set4Byte(medicTime, buf);
}

void addMhpCount(QByteArray &buf, int32_t mhpCount)
{
  LtsUtils::set4Byte(mhpCount, buf);
}

void addMhpRotation(QByteArray &buf, double mhpRotation)
{
  LtsUtils::set8Byte(mhpRotation, buf);
}

void addName(QByteArray &buf, const std::string &name)
{
  addString(buf, name, 8);
}

void addPartyId(QByteArray &buf, int32_t partyId)
{
  LtsUtils::set4Byte(partyId, buf);
}

void addPointSymbol(QByteArray &buf, const std::string &pointSymbol)
{
  addString(buf, pointSymbol, pointSymbol.length());
}

void addPosition2D(QByteArray &buf, const Core::GeoPosition2D &position)
{
  LtsUtils::set8Byte(position.lon(), buf);
  LtsUtils::set8Byte(position.lat(), buf);
  // no timestamp, as it is set in the client anyway
}

void addPurpose(QByteArray &buf, const std::string &purpose)
{
  addString(buf, purpose);
}

void addRotationAngle(QByteArray &buf, double rotationAngle)
{
  LtsUtils::set8Byte(rotationAngle, buf);
}

void addSegments(QByteArray &buf, const std::vector<AreaEffectSimulation::MineSegment> &segments)
{
  unsigned char len = segments.size() + 1;
  LtsUtils::set1Byte(len, buf);

  if (len == 1)
    return;

  AreaEffectSimulation::MineSegment lastSeg;

  for (const AreaEffectSimulation::MineSegment &currentMineSegment : qAsConst(segments))
  {
    addPosition2D(buf, currentMineSegment.positionStart());
    lastSeg = currentMineSegment;
  }
  addPosition2D(buf, lastSeg.positionEnd());
}

void addSpanAngle(QByteArray &buf, double spanAngle)
{
  LtsUtils::set8Byte(spanAngle, buf);
}

void addString(QByteArray &buf, const std::string &str, size_t maxLen)
{
  unsigned char len = std::min(str.size(), size_t(maxLen));
  LtsUtils::set1Byte(len, buf);
  buf.append(str.c_str(), len);
}

void addTriggerRadius(QByteArray &buf, double triggerRadius)
{
  LtsUtils::set8Byte(triggerRadius, buf);
}

void addWidth(QByteArray &buf, double width)
{
  LtsUtils::set8Byte(width, buf);
}

void addPropagationDirection(QByteArray &buf, double propagationDirection)
{
  LtsUtils::set8Byte(propagationDirection, buf);
}

void addWindSpeed(QByteArray &buf, double windSpeed)
{
  LtsUtils::set8Byte(windSpeed, buf);
}

} // namespace DataBuilder

} // namespace OcSituationServer