lifemaps/qt-migration-legatus
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

LtsUtilsCore: Alle Include-Pfade korrigiert (LtsUtils/ → LtsUtilsCore/)

Browse Source 
- CMakeLists.txt: Include-Pfade von ../ zu . geändert, json.h hinzugefügt
- ~95 Dateien: Include-Pfade systematisch korrigiert
  - LtsUtils/ → LtsUtilsCore/ für alle Core-Header
  - LtsUtilsGui/LtsUtils/LtsUtilsGui/ → LtsUtilsGui/LtsUtilsGuiDds/
- Logger-API: getLogger() mit const char* Parameter
- DataModification: enum class global (nicht im Lts-Namespace)
- Participant-Struct: Member mit m_-Präfix
- Export-Macro: SVCALMCOMMON_EXPORT statt ALMCOMMON_EXPORT
- Signal/Slot-Signaturen korrigiert für Qt6 template matching

Build validiert: LtsUtilsCore, LtsUtilsDds, LtsSessionData erfolgreich
This commit is contained in:
torsten committed 2026-08-21 01:49:35 +02:00
1 parent bd10a8db89
commit d17d397fe7
95 files changed
+667 -177
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

qt6-after/qt6-migrated-legatus/include/AlarmManagement/alm_dtc.h
+82 -1
View File
@@ -3,11 +3,92 @@
// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
// Für die Migration erstellen wir minimale Forward-Declarations
#include <cstdint>
#include <functional>
#include <optional>
#include <string>
#include <QObject>
#include "LtsUtils/data_modification_enum.h"
#include "ProjectDataManagement/pdm_types.h"
namespace AlarmManagement
{
// Position-Struct (wird normalerweise von DDS generiert)
struct Position
{
double longitude = 0.0;
double latitude = 0.0;
double lon() const { return longitude; }
double lat() const { return latitude; }
};
// Notification-Struct (wird normalerweise von DDS generiert)
struct Notification
{
int32_t id = 0;
int64_t time() const { return timestamp; }
int64_t timestamp = 0;
int32_t type = 0;
int32_t priority = 0;
int32_t status = 0;
std::string description;
// Zusätzliche Member für AlarmHistoryModel
int32_t operatorId() const { return m_operatorId; }
int32_t equipmentNumber() const { return m_equipmentNumber; }
std::optional<int32_t> participantId() const { return m_participantId; }
std::optional<int32_t> aesId() const { return m_aesId; }
ProjectDataManagement::EventType eventType() const { return m_eventType; }
Position position() const { return m_position; }
const std::string& properties() const { return m_properties; }
int32_t m_operatorId = 0;
int32_t m_equipmentNumber = 0;
std::optional<int32_t> m_participantId;
std::optional<int32_t> m_aesId;
ProjectDataManagement::EventType m_eventType = ProjectDataManagement::EventType::Unknown;
Position m_position;
std::string m_properties;
};
namespace Interface
{
class Dtc;
// Dtc interface class with signals for Qt6 migration STUB
class Dtc : public QObject
{
Q_OBJECT
public:
explicit Dtc(QObject* parent = nullptr) : QObject(parent) {}
~Dtc() override = default;
// Callback registration instead of enableNotification()
void notifications(std::function<void(const Notification&)> callback)
{
m_notificationCallback = callback;
}
// Trigger notification changed (for STUB testing)
void triggerNotificationChanged(const Notification& notification, DataModification modType)
{
emit notificationChanged(notification, modType);
if (m_notificationCallback)
{
m_notificationCallback(notification);
}
}
signals:
void notificationChanged(const Notification& notification, DataModification modType);
private:
std::function<void(const Notification&)> m_notificationCallback;
};
class Ftc;
} // namespace Interface
} // namespace AlarmManagement
qt6-after/qt6-migrated-legatus/include/AlarmManagement/alm_types.h
+4
View File
@@ -32,6 +32,9 @@ public:
bool global() const { return m_global; }
void setGlobal(bool value) { m_global = value; }
int vulnerabilityState() const { return m_vulnerabilityState; }
void setVulnerabilityState(int value) { m_vulnerabilityState = value; }
private:
int m_eventTypeId = 0;
@@ -40,6 +43,7 @@ private:
int m_participantId = 0;
int m_id = 0;
bool m_global = false;
int m_vulnerabilityState = -1;
};
} // namespace AlarmManagement
qt6-after/qt6-migrated-legatus/include/AreaEffectSimulation/aes_dtc.h
+110 -1
View File
@@ -3,11 +3,120 @@
// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
// Für die Migration erstellen wir minimale Forward-Declarations
#include <functional>
#include <memory>
#include <ostream>
#include <string>
#include <QObject>
#include "LtsUtils/data_modification_enum.h"
namespace AreaEffectSimulation
{
// AesItem-Struct (wird normalerweise von DDS generiert)
struct AesItem
{
int32_t id() const { return m_id; }
const std::string& name() const { return m_name; }
int32_t m_id = 0;
std::string m_name;
};
inline std::ostream& operator<<(std::ostream& os, const AesItem& item)
{
os << "AesItem{id=" << item.id() << ", name=" << item.name() << "}";
return os;
}
// BCContamination-Struct (wird normalerweise von DDS generiert)
struct BCContamination : public AesItem
{
};
// BoobyTrap-Struct (wird normalerweise von DDS generiert)
struct BoobyTrap : public AesItem
{
};
// OffRouteMine-Struct (wird normalerweise von DDS generiert)
struct OffRouteMine : public AesItem
{
};
namespace Interface
{
class Dtc;
// Dtc - Data Transfer Component für Area Effect Simulation
// DDS-generierte Klasse mit Signals für AES-Item-Änderungen
class Dtc : public QObject {
Q_OBJECT
public:
Dtc() = default;
~Dtc() override = default;
// Callback registration for AES item changes
void bcContaminations(std::function<void(const BCContamination&)> callback) {
m_bcCallback = callback;
}
void boobyTraps(std::function<void(const BoobyTrap&)> callback) {
m_boobyTrapCallback = callback;
}
void offRouteMines(std::function<void(const OffRouteMine&)> callback) {
m_offRouteMineCallback = callback;
}
void aesItems(std::function<void(const AesItem&)> callback) {
m_aesCallback = callback;
}
// Trigger methods for STUB testing
void triggerBCContaminationChanged(const BCContamination& item, DataModification modType) {
emit bcContaminationChanged(item, modType);
if (m_bcCallback) {
m_bcCallback(item);
}
}
void triggerBoobyTrapChanged(const BoobyTrap& item, DataModification modType) {
emit boobyTrapChanged(item, modType);
if (m_boobyTrapCallback) {
m_boobyTrapCallback(item);
}
}
void triggerOffRouteMineChanged(const OffRouteMine& item, DataModification modType) {
emit offRouteMineChanged(item, modType);
if (m_offRouteMineCallback) {
m_offRouteMineCallback(item);
}
}
void triggerAesItemChanged(const AesItem& item, DataModification modType) {
emit aesItemChanged(item, modType);
if (m_aesCallback) {
m_aesCallback(item);
}
}
signals:
void bcContaminationChanged(const BCContamination& item, DataModification modType);
void boobyTrapChanged(const BoobyTrap& item, DataModification modType);
void offRouteMineChanged(const OffRouteMine& item, DataModification modType);
void aesItemChanged(const AesItem& item, DataModification modType);
private:
std::function<void(const BCContamination&)> m_bcCallback;
std::function<void(const BoobyTrap&)> m_boobyTrapCallback;
std::function<void(const OffRouteMine&)> m_offRouteMineCallback;
std::function<void(const AesItem&)> m_aesCallback;
};
class Ftc;
} // namespace Interface
} // namespace AreaEffectSimulation
qt6-after/qt6-migrated-legatus/include/ParticipantManagement/ppm.hpp
+15 -4
View File
@@ -12,6 +12,8 @@
#include <memory>
#include <ostream>
#include "LtsUtils/data_modification_enum.h"
namespace ParticipantManagement
{
@@ -27,7 +29,7 @@ struct Type {
// Participant - Basisdaten eines Teilnehmers
struct Participant {
int id = 0;
int m_id = 0;
QString internalName;
QString externalName;
int typeId = 0;
@@ -41,8 +43,17 @@ struct Participant {
double z = 0.0;
double heading = 0.0;
// Optional fields (für DDS-Kompatibilität)
std::optional<int> equipmentNumber;
QString m_designator;
QString m_tacticalIdentifier;
// Helper methods
QString name() const { return internalName; }
QString designator() const { return m_designator; }
QString tacticalIdentifier() const { return m_tacticalIdentifier; }
std::optional<int> equipmentNumber() const { return equipmentNumber; }
int id() const { return m_id; }
};
// Party - Gruppe/Organisation von Teilnehmern
@@ -115,7 +126,7 @@ public:
void updateParticipant(const Participant& p) {
for (auto& existing : m_participants) {
if (existing.id == p.id) {
if (existing.m_id == p.m_id) {
existing = p;
emit participantChanged(p, DataModification::eModified);
return;
@@ -126,7 +137,7 @@ public:
void removeParticipant(int id) {
for (auto it = m_participants.begin(); it != m_participants.end(); ++it) {
if (it->id == id) {
if (it->m_id == id) {
Participant removed = *it;
m_participants.erase(it);
emit participantChanged(removed, DataModification::eRemoved);
@@ -166,7 +177,7 @@ inline std::ostream& operator<<(std::ostream& os, const Type& t) {
}
inline std::ostream& operator<<(std::ostream& os, const Participant& p) {
os << "Participant(id=" << p.id << ", name=" << p.name().toStdString() << ")";
os << "Participant(id=" << p.m_id << ", name=" << p.name().toStdString() << ")";
return os;
}
qt6-after/qt6-migrated-legatus/include/ParticipantManagement/ppm_enums.hpp
+67 -1
View File
@@ -13,7 +13,28 @@ enum class SymbolAppearance : int { Solid = 0, Dashed = 1, Dotted = 2 };
enum class SymbolVisibility : int { Visible = 0, Hidden = 1 };
enum class TypeClass : int { eUninitialized = 0, Unknown = 1, Aircraft = 2, Ground = 3, Naval = 4 };
enum class TypeClass : int {
eUninitialized = 0,
Unknown = 1,
Aircraft = 2,
Ground = 3,
Naval = 4,
Human = 5,
Unit = 6,
SupportUnit = 7,
SupportEntity = 8,
Vehicle = 9,
GroundVehicle = 10,
Airborne = 11,
Vessel = 12,
Building = 13,
WeaponSystem = 14,
TargetHuman = 15,
TargetVehicle = 16,
VehicleWithGear = 17,
VehicleMarker = 18,
None = 19
};
enum class DataModification : int { eAdded = 0, eModified = 1, eRemoved = 2 };
@@ -35,6 +56,51 @@ inline std::ostream& operator<<(std::ostream& os, TypeClass tc)
case TypeClass::Naval:
os << "Naval";
break;
case TypeClass::Human:
os << "Human";
break;
case TypeClass::Unit:
os << "Unit";
break;
case TypeClass::SupportUnit:
os << "SupportUnit";
break;
case TypeClass::SupportEntity:
os << "SupportEntity";
break;
case TypeClass::Vehicle:
os << "Vehicle";
break;
case TypeClass::GroundVehicle:
os << "GroundVehicle";
break;
case TypeClass::Airborne:
os << "Airborne";
break;
case TypeClass::Vessel:
os << "Vessel";
break;
case TypeClass::Building:
os << "Building";
break;
case TypeClass::WeaponSystem:
os << "WeaponSystem";
break;
case TypeClass::TargetHuman:
os << "TargetHuman";
break;
case TypeClass::TargetVehicle:
os << "TargetVehicle";
break;
case TypeClass::VehicleWithGear:
os << "VehicleWithGear";
break;
case TypeClass::VehicleMarker:
os << "VehicleMarker";
break;
case TypeClass::None:
os << "None";
break;
default:
os << std::string("Unknown");
}
qt6-after/qt6-migrated-legatus/include/ProjectDataManagement/pdm_enums.hpp
+2 -7
View File
@@ -7,18 +7,13 @@
#include <QMap>
#include <QString>
#include "pdm_types.h"
namespace ProjectDataManagement
{
// Original enums
enum class ChargeType : int { Unknown = 0 };
enum class UnitType : int { Unknown = 0 };
enum class SimulationType : int { Unknown = 0 };
// Additional enums required by AdlerJson/telegrams.h
// (ChargeType, UnitType, SimulationType are already defined in pdm_types.h)
enum class L4_TargetGeometry : int {
Unknown = 0,
Point, // P - Punktziel
qt6-after/qt6-migrated-legatus/include/ProjectDataManagement/pdm_translation.h
+124 -13
View File
@@ -18,18 +18,129 @@ class QString;
namespace ProjectDataManagement
{
// Translatable enumerations:
PDM_COMMON_EXPORT QString toString(ChargeType state);
PDM_COMMON_EXPORT QString toString(UnitType state);
PDM_COMMON_EXPORT QString toString(SimulationType state);
PDM_COMMON_EXPORT QString toString(L4_TargetGeometry state);
PDM_COMMON_EXPORT QString toString(L7_Request state);
PDM_COMMON_EXPORT QString toString(L19_Oi state);
PDM_COMMON_EXPORT QString toString(L22_FireHaltCategory state);
PDM_COMMON_EXPORT QString toString(L25_KindGuidingLine state);
PDM_COMMON_EXPORT QString toString(L26_EffectingSystemType state);
PDM_COMMON_EXPORT QString toString(L27_EffectorId state);
PDM_COMMON_EXPORT QString toString(L28_Status state);
PDM_COMMON_EXPORT QString toString(L46_GpsFrequency state);
PDM_COMMON_EXPORT QString toString(L48_TrajectoryRocket state);
inline PDM_COMMON_EXPORT QString toString(ChargeType ct)
{
switch (ct) {
case ChargeType::Unknown: return QStringLiteral("Unknown");
default: return QStringLiteral("Unknown");
}
}
inline PDM_COMMON_EXPORT QString toString(UnitType ut)
{
switch (ut) {
case UnitType::Unknown: return QStringLiteral("Unknown");
default: return QStringLiteral("Unknown");
}
}
inline PDM_COMMON_EXPORT QString toString(SimulationType st)
{
switch (st) {
case SimulationType::Unknown: return QStringLiteral("Unknown");
default: return QStringLiteral("Unknown");
}
}
inline PDM_COMMON_EXPORT QString toString(L4_TargetGeometry state)
{
switch (state) {
case L4_TargetGeometry::Unknown: return QStringLiteral("Unknown");
case L4_TargetGeometry::Point: return QStringLiteral("Point");
case L4_TargetGeometry::Area: return QStringLiteral("Area");
case L4_TargetGeometry::Radial: return QStringLiteral("Radial");
case L4_TargetGeometry::Linear: return QStringLiteral("Linear");
default: return QStringLiteral("Unknown");
}
}
inline PDM_COMMON_EXPORT QString toString(L7_Request state)
{
switch (state) {
case L7_Request::Unknown: return QStringLiteral("Unknown");
default: return QStringLiteral("Unknown");
}
}
inline PDM_COMMON_EXPORT QString toString(L19_Oi state)
{
switch (state) {
case L19_Oi::Unknown: return QStringLiteral("Unknown");
case L19_Oi::Empty: return QStringLiteral("Empty");
default: return QStringLiteral("Unknown");
}
}
inline PDM_COMMON_EXPORT QString toString(L22_FireHaltCategory state)
{
switch (state) {
case L22_FireHaltCategory::A: return QStringLiteral("A");
case L22_FireHaltCategory::R: return QStringLiteral("R");
case L22_FireHaltCategory::E: return QStringLiteral("E");
case L22_FireHaltCategory::C: return QStringLiteral("C");
case L22_FireHaltCategory::F: return QStringLiteral("F");
default: return QStringLiteral("Unknown");
}
}
inline PDM_COMMON_EXPORT QString toString(L25_KindGuidingLine state)
{
switch (state) {
case L25_KindGuidingLine::FFA: return QStringLiteral("FFA");
case L25_KindGuidingLine::NFA: return QStringLiteral("NFA");
case L25_KindGuidingLine::RFA: return QStringLiteral("RFA");
case L25_KindGuidingLine::FSCL: return QStringLiteral("FSCL");
case L25_KindGuidingLine::RFL: return QStringLiteral("RFL");
case L25_KindGuidingLine::FSSL: return QStringLiteral("FSSL");
case L25_KindGuidingLine::NFL: return QStringLiteral("NFL");
default: return QStringLiteral("Unknown");
}
}
inline PDM_COMMON_EXPORT QString toString(L26_EffectingSystemType state)
{
switch (state) {
case L26_EffectingSystemType::Unknown: return QStringLiteral("Unknown");
case L26_EffectingSystemType::Pzh2000: return QStringLiteral("Pzh2000");
case L26_EffectingSystemType::RRohr: return QStringLiteral("RRohr");
case L26_EffectingSystemType::Mars: return QStringLiteral("Mars");
default: return QStringLiteral("Unknown");
}
}
inline PDM_COMMON_EXPORT QString toString(L27_EffectorId state)
{
switch (state) {
case L27_EffectorId::Unknown: return QStringLiteral("Unknown");
default: return QStringLiteral("Unknown");
}
}
inline PDM_COMMON_EXPORT QString toString(L28_Status state)
{
switch (state) {
case L28_Status::NichtEinsatzbereit: return QStringLiteral("NichtEinsatzbereit");
case L28_Status::Einsatzbereit: return QStringLiteral("Einsatzbereit");
default: return QStringLiteral("Unknown");
}
}
inline PDM_COMMON_EXPORT QString toString(L46_GpsFrequency state)
{
switch (state) {
case L46_GpsFrequency::L1: return QStringLiteral("L1");
case L46_GpsFrequency::L2: return QStringLiteral("L2");
default: return QStringLiteral("Unknown");
}
}
inline PDM_COMMON_EXPORT QString toString(L48_TrajectoryRocket state)
{
switch (state) {
case L48_TrajectoryRocket::Nominal: return QStringLiteral("Nominal");
case L48_TrajectoryRocket::Vertical: return QStringLiteral("Vertical");
default: return QStringLiteral("Unknown");
}
}
} // namespace ProjectDataManagement
qt6-after/qt6-migrated-legatus/include/ProjectDataManagement/pdm_types.h
+60 -3
View File
@@ -27,8 +27,65 @@ enum class VulnerabilityClass : int
eClassC = 3
};
// STUB: toString-Funktionen für VulnerabilityState + VulnerabilityClass
PDM_COMMON_EXPORT QString toString(VulnerabilityState vs);
PDM_COMMON_EXPORT QString toString(VulnerabilityState vs, VulnerabilityClass vc);
// STUB: VulnerabilityState_def - DDS-generierte Wrapper-Struktur
struct VulnerabilityState_def
{
using type = VulnerabilityState;
static constexpr VulnerabilityState eUnknown = VulnerabilityState::eUnknown;
static constexpr VulnerabilityState eNormal = VulnerabilityState::eNormal;
static constexpr VulnerabilityState eWarning = VulnerabilityState::eWarning;
static constexpr VulnerabilityState eCritical = VulnerabilityState::eCritical;
};
// STUB: VulnerabilityClass_def - DDS-generierte Wrapper-Struktur
struct VulnerabilityClass_def
{
using type = VulnerabilityClass;
static constexpr VulnerabilityClass eUnknown = VulnerabilityClass::eUnknown;
static constexpr VulnerabilityClass eClassA = VulnerabilityClass::eClassA;
static constexpr VulnerabilityClass eClassB = VulnerabilityClass::eClassB;
static constexpr VulnerabilityClass eClassC = VulnerabilityClass::eClassC;
// Statische Member für SoldierInjuries und VehicleDamages
static constexpr VulnerabilityClass SoldierInjuries = VulnerabilityClass::eClassA;
static constexpr VulnerabilityClass VehicleDamages = VulnerabilityClass::eClassB;
};
// STUB: ChargeType Enum
enum class ChargeType : int
{
Unknown = 0,
Live = 1,
Inert = 2,
Practice = 3
};
// STUB: UnitType Enum
enum class UnitType : int
{
Unknown = 0,
Air = 1,
Ground = 2,
Naval = 3
};
// STUB: SimulationType Enum
enum class SimulationType : int
{
Unknown = 0,
Live = 1,
Constructive = 2,
Virtual = 3
};
// STUB: EventType Enum
enum class EventType : int
{
Unknown = 0,
Alarm = 1,
Warning = 2,
Info = 3,
Status = 4
};
} // namespace ProjectDataManagement
qt6-after/qt6-migrated-legatus/include/ProjectDataManagement/project_data_management.hpp
+43
View File
@@ -0,0 +1,43 @@
#pragma once
// STUB-HEADER: Diese Datei wird normalerweise von DDS/Codegenerator generiert
// Für die Migration erstellen wir minimale Typ-Definitionen
#include "pdm_types.h"
namespace ProjectDataManagement
{
// STUB: EventType Enum
enum class EventType : int
{
Unknown = 0,
Alarm = 1,
Warning = 2,
Info = 3
};
// STUB: EventType_def - Platzhalter für DDS-generierten Typ
// Wird in AlarmManagement für Event-Typisierung verwendet
struct EventType_def
{
int value{0};
EventType_def() = default;
explicit EventType_def(int v) : value(v) {}
explicit EventType_def(EventType t) : value(static_cast<int>(t)) {}
bool operator==(const EventType_def& other) const { return value == other.value; }
bool operator!=(const EventType_def& other) const { return value != other.value; }
bool operator<(const EventType_def& other) const { return value < other.value; }
};
// STUB: EventData - Basisstruktur für Event-Daten
struct EventData
{
EventType_def eventType;
QString description;
qint64 timestamp{0};
};
} // namespace ProjectDataManagement
qt6-after/qt6-migrated-legatus/include/Viewer/SituationMap/ElevationMap/elevation_map_manager.h
+1 -1
View File
@@ -12,7 +12,7 @@
#include <vector>
// QPoint3D ist bereits in LtsUtilsCore/qpoint3d.h definiert
// #include "LtsUtilsCore/qpoint3d.h" // Wird von lts_elevation_manager.h included
// #include "LtsUtils/qpoint3d.h" // Wird von lts_elevation_manager.h included
namespace LtsUtils
{