Qt6 migration fixes: RTI DDS alias targets, ErrorMessage namespace, DDS header include path

qt6-after/qt6-migrated-legatus/include/AdlerJson/flm_handler.h

@@ -11,10 +11,10 @@
 
 #include "logger.h"
 #include <QtCore/QObject>
-#include <FileManagement/flm_ftc.h>
+#include <Lts/Services/FileManagement/flm_ftc.h>
 #include <NotificationManagement/nom_ftc.h>
 #include <NotificationManagement/nom_ftc_types.h>
-#include <Plugins/OperatorManagement/opm_data_plugin_interface.h>
+#include <OperatorManagement/opm_data_plugin_interface.h>
 #include <TrainingAreaBase/dds_handler.h>
 
 namespace FileManagement

qt6-after/qt6-migrated-legatus/include/ExerciseManagement/exm_dtc.h

@@ -5,14 +5,27 @@
 
 #include "exm_exercise.h"
 #include "ParticipantManagement/ppm_enums.hpp"
+#include "FileManagement/flm_db.h"
 
 #include <QtCore/QObject>
 #include <QtCore/QList>
 #include <functional>
+#include <vector>
+#include <string>
 
 namespace ExerciseManagement
 {
 
+// ExercisePhase struct
+struct ExercisePhase
+{
+  [[nodiscard]] int id() const { return m_id; }
+  [[nodiscard]] std::string name() const { return m_name; }
+  
+  int m_id = 0;
+  std::string m_name;
+};
+
 namespace Interface
 {
 
@@ -24,6 +37,12 @@ public:
   Dtc() = default;
   ~Dtc() override = default;
   
+  // Initialization methods
+  void enableExercise() {}
+  void waitForHistoricalDataExercise() {}
+  void enableExercisePhase() {}
+  void waitForHistoricalDataExercisePhase() {}
+  
   // Exercise-Liste abrufen (Callback-basiert)
   void exercises(const std::function<void(const Exercise&)>& callback) const {
     for (const auto& ex : m_exercises) {
@@ -31,6 +50,31 @@ public:
     }
   }
   
+  // Einzelnes Exercise nach ID abrufen
+  Exercise exercise(int id) const {
+    for (const auto& ex : m_exercises) {
+      if (ex.id == id) {
+        return ex;
+      }
+    }
+    return Exercise{}; // Return empty exercise if not found
+  }
+  
+  // Exercise-Phase nach ID abrufen
+  ExercisePhase exercisePhase(int phaseId) const {
+    for (const auto& phase : m_phases) {
+      if (phase.m_id == phaseId) {
+        return phase;
+      }
+    }
+    return ExercisePhase{}; // Return empty phase if not found
+  }
+  
+  // Folders abrufen (Callback-basiert) - benötigt von LtsFileDialog
+  void folders(const std::function<void(const std::vector<FileManagement::Folder>&)>& callback) const {
+    callback(m_folders);
+  }
+  
   // Exercise-Liste als QList
   QList<Exercise> exercisesList() const { return m_exercises; }
   
@@ -67,6 +111,8 @@ signals:
   
 private:
   QList<Exercise> m_exercises;
+  std::vector<ExercisePhase> m_phases;
+  std::vector<FileManagement::Folder> m_folders;
 };
 
 } // namespace Interface

qt6-after/qt6-migrated-legatus/include/ExerciseManagement/exm_exercise.h

@@ -15,15 +15,18 @@ namespace ExerciseManagement
 struct EXMCOMMON_EXPORT Exercise
 {
     int id = 0;
-    QString name;
+    QString m_name;
+    int phase = 0;  // Exercise phase ID
     SymbolAppearance symbolAppearance = SymbolAppearance::Solid;
     SymbolVisibility symbolVisibility = SymbolVisibility::Visible;
+    
+    [[nodiscard]] std::string name() const { return m_name.toStdString(); }
     // Weitere Felder werden bei Bedarf ergänzt
 };
 
 // Stream operator for logging
 inline std::ostream& operator<<(std::ostream& os, const Exercise& ex) {
-    os << "Exercise(id=" << ex.id << ", name=" << ex.name.toStdString() << ")";
+    os << "Exercise(id=" << ex.id << ", name=" << ex.m_name.toStdString() << ")";
     return os;
 }
 

qt6-after/qt6-migrated-legatus/include/FileManagement/flm_dtc.h

@@ -1,13 +1,76 @@
 #pragma once
 
 // STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
-// Für die Migration erstellen wir minimale Forward-Declarations
+// Für die Migration erstellen wir minimale Implementierungen
+
+#include <functional>
+#include <QObject>
+#include "flm_db.h"
 
 namespace FileManagement
 {
 namespace Interface
 {
-class Dtc;
+
+// DataModification Enum (aus DDS generiert)
+enum class DataModification
+{
+  eAdded,
+  eModified,
+  eRemoved
+};
+
+// Callback types
+using FolderCallback = std::function<void(const std::vector<Folder>&, const std::vector<int32_t>&, DataModification)>;
+using FileContentCallback = std::function<void(const std::vector<FileContent>&, const std::vector<int32_t>&, DataModification)>;
+
+// Dtc - Data Transfer Component interface for FileManagement
+class Dtc : public QObject
+{
+  Q_OBJECT
+  
+public:
+  virtual ~Dtc() = default;
+  
+  // Initialization methods
+  virtual void enableFolder() {}
+  virtual void waitForHistoricalDataFolder() {}
+  virtual void enableFileContent() {}
+  virtual void waitForHistoricalDataFileContent() {}
+  
+  // Folder operations
+  virtual void folders(FolderCallback callback) const
+  {
+    // STUB-Implementierung - keine Ordner vorhanden
+    std::vector<Folder> emptyFolders;
+    std::vector<int32_t> emptyIds;
+    callback(emptyFolders, emptyIds, DataModification::eModified);
+  }
+  
+  virtual std::shared_ptr<Folder> folder(int32_t /*folderId*/) const
+  {
+    return nullptr;
+  }
+  
+  // FileContent operations
+  virtual void fileContents(FileContentCallback callback) const
+  {
+    // STUB-Implementierung
+    std::vector<FileContent> emptyContents;
+    std::vector<int32_t> emptyIds;
+    callback(emptyContents, emptyIds, DataModification::eModified);
+  }
+  
+  virtual std::shared_ptr<FileContent> fileContent(int32_t /*fileContentId*/) const
+  {
+    return nullptr;
+  }
+  
+signals:
+  void folderChanged(const FileManagement::Folder &folder, DataModification modification);
+  void fileContentChanged(const FileManagement::FileContent &fileContent, DataModification modification);
+};
+
 class Ftc;
 } // namespace Interface
 } // namespace FileManagement

qt6-after/qt6-migrated-legatus/include/FileManagement/flm_enums.hpp

@@ -3,7 +3,7 @@
 // STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
 // Für die Migration erstellen wir minimale Typ-Definitionen
 
-#include <QString>
+#include <QtCore/QString>
 
 namespace FileManagement
 {

qt6-after/qt6-migrated-legatus/include/FilterManagement/flt_ftc.h

@@ -14,7 +14,7 @@
 #include <QtCore/QJsonObject>
 #include <Core/core_types.h>
 #include <Core/core_enums.hpp>
-#include <Services/AreaEffectSimulation/aes.hpp>
+#include <AreaEffectSimulation/aes.hpp>
 
 namespace rti {
 namespace core {

qt6-after/qt6-migrated-legatus/include/InfrastructureManagement/ism.hpp

@@ -10,8 +10,17 @@
 
 #include <cstdint>
 #include <string>
+#include <vector>
+#include <QtCore/QString>
+#include <QtCore/QByteArray>
+#include <QtGui/QImage>
+#include <QtCore/QMap>
 #include "InfrastructureManagement/ism_enums.hpp"
 #include "ParticipantManagement/ppm.hpp"
+#include "ParticipantManagement/ppm_enums.hpp"
+
+// Using-declaration for DataModification in InfrastructureManagement namespace
+using ParticipantManagement::DataModification;
 
 namespace InfrastructureManagement {
 
@@ -53,7 +62,7 @@ private:
 // StructureElement Stub-Klasse
 class StructureElement {
 public:
-    StructureElement() : id_(0), mainStructureElementId_(0), mountingPointTypeId_(MountingPointType::Undefined) {}
+    StructureElement() : id_(0), mainStructureElementId_(0), mountingPointTypeId_(MountingPointType::Undefined), mountingPointId_(0) {}
     
     int32_t id() const { return id_; }
     void id(int32_t v) { id_ = v; }
@@ -64,6 +73,14 @@ public:
     MountingPointType mountingPointTypeId() const { return mountingPointTypeId_; }
     void mountingPointTypeId(MountingPointType v) { mountingPointTypeId_ = v; }
     
+    // Für Kompatibilität: structureElementTypeId() als Alias
+    MountingPointType structureElementTypeId() const { return mountingPointTypeId_; }
+    void structureElementTypeId(MountingPointType v) { mountingPointTypeId_ = v; }
+    
+    // mountingPointId() für Sub-ID
+    int32_t mountingPointId() const { return mountingPointId_; }
+    void mountingPointId(int32_t v) { mountingPointId_ = v; }
+    
     Core::GeoPosition geoPosition() const { return geoPosition_; }
     void geoPosition(const Core::GeoPosition& v) { geoPosition_ = v; }
     
@@ -79,17 +96,138 @@ public:
     std::string displayName() const { return displayName_; }
     void displayName(const std::string& v) { displayName_ = v; }
     
+    // path() returns vector of IDs im Hierarchie-Pfad
+    const std::vector<int32_t>& path() const { return path_; }
+    void path(const std::vector<int32_t>& v) { path_ = v; }
+    
 private:
     int32_t id_;
     int32_t mainStructureElementId_;
     MountingPointType mountingPointTypeId_;
+    int32_t mountingPointId_;
     Core::GeoPosition geoPosition_;
     Core::RelativePosition relPosition_;
     std::string properties_;
     std::string name_;
     std::string displayName_;
+    std::vector<int32_t> path_;
 };
 
+// MainStructureElement - Stub für DDS-generierten Typ
+class MainStructureElement {
+public:
+    MainStructureElement() : id_(0), groupId_(0) {}
+    
+    int32_t id() const { return id_; }
+    void id(int32_t v) { id_ = v; }
+    
+    int32_t groupId() const { return groupId_; }
+    void groupId(int32_t v) { groupId_ = v; }
+    
+    std::string name() const { return name_; }
+    void name(const std::string& v) { name_ = v; }
+    
+    std::string displayName() const { return displayName_; }
+    void displayName(const std::string& v) { displayName_ = v; }
+    
+    Core::GeoPosition geoPosition() const { return geoPosition_; }
+    void geoPosition(const Core::GeoPosition& v) { geoPosition_ = v; }
+    
+    // For compatibility: elements() returns empty vector by default
+    const std::vector<StructureElement>& elements() const { return elements_; }
+    void elements(const std::vector<StructureElement>& v) { elements_ = v; }
+    
+private:
+    int32_t id_;
+    int32_t groupId_;
+    std::string name_;
+    std::string displayName_;
+    Core::GeoPosition geoPosition_;
+    std::vector<StructureElement> elements_;
+};
+
+// MountingPointAsset - Stub für DDS-generierten Typ
+class MountingPointAsset {
+public:
+    MountingPointAsset() : id_(0), mountingPointId_(0), assetId_(0) {}
+    
+    int32_t id() const { return id_; }
+    void id(int32_t v) { id_ = v; }
+    
+    int32_t mountingPointId() const { return mountingPointId_; }
+    void mountingPointId(int32_t v) { mountingPointId_ = v; }
+    
+    int32_t assetId() const { return assetId_; }
+    void assetId(int32_t v) { assetId_ = v; }
+    
+    std::string name() const { return name_; }
+    void name(const std::string& v) { name_ = v; }
+    
+    // For compatibility: structureElementId() alias for mountingPointId()
+    int32_t structureElementId() const { return mountingPointId_; }
+    void structureElementId(int32_t v) { mountingPointId_ = v; }
+    
+private:
+    int32_t id_;
+    int32_t mountingPointId_;
+    int32_t assetId_;
+    std::string name_;
+};
+
+// Forward declaration - full definition in ism_mounting_point.h
+class MountingPoint;
+
+// FootprintElement - für Footprint-Daten
+class FootprintElement {
+public:
+    FootprintElement() : isGroundLevel_(false) {}
+    
+    bool isGroundLevel() const { return isGroundLevel_; }
+    void isGroundLevel(bool v) { isGroundLevel_ = v; }
+    
+    Core::RelativePosition relPosition() const { return relPosition_; }
+    void relPosition(const Core::RelativePosition& v) { relPosition_ = v; }
+    
+private:
+    bool isGroundLevel_;
+    Core::RelativePosition relPosition_;
+};
+
+// MainFootprint - Footprint-Daten für MainStructureElement
+class MainFootprint {
+public:
+    MainFootprint() : id_(0) {}
+    
+    int32_t id() const { return id_; }
+    void id(int32_t v) { id_ = v; }
+    
+    const std::vector<FootprintElement>& elements() const { return elements_; }
+    void elements(const std::vector<FootprintElement>& v) { elements_ = v; }
+    
+private:
+    int32_t id_;
+    std::vector<FootprintElement> elements_;
+};
+
+// InstrumentationAsset - Stub für DDS-generierten Typ
+class InstrumentationAsset {
+public:
+    InstrumentationAsset() : id_(0) {}
+    
+    int32_t id() const { return id_; }
+    void id(int32_t v) { id_ = v; }
+    
+    std::string name() const { return name_; }
+    void name(const std::string& v) { name_ = v; }
+    
+private:
+    int32_t id_;
+    std::string name_;
+};
+
+// StructureElementType Enum (Alias für MountingPointType für Kompatibilität)
+using StructureElementType = MountingPointType;
+
 } // namespace InfrastructureManagement
 
 #endif // ISM_HPP

qt6-after/qt6-migrated-legatus/include/InfrastructureManagement/ism_dtc.h

@@ -1,13 +1,129 @@
 #pragma once
 
 // STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
-// Für die Migration erstellen wir minimale Forward-Declarations
+// Für die Migration erstellen wir minimale Implementierungen
+
+#include <QtCore/QObject>
+#include <QtCore/QMap>
+#include <QtCore/QHash>
+#include <functional>
+#include "ism.hpp"
+#include "ism_mounting_point.h"
 
 namespace InfrastructureManagement
 {
 namespace Interface
 {
+
+// Forward declarations
 class Dtc;
 class Ftc;
+
+// DataModification Enum
+enum class DataModification
+{
+  eAdded,
+  eModified,
+  eRemoved
+};
+
+// MountingPointPlan - Planungsdaten für MountingPoints (MUST come before MainSchedule)
+class MountingPointPlan {
+public:
+  MountingPointPlan() : structureElementId_(0) {}
+  int32_t structureElementId() const { return structureElementId_; }
+  void structureElementId(int32_t v) { structureElementId_ = v; }
+  
+  MountingPointState mountingPointState() const { return mountingPointState_; }
+  void mountingPointState(const MountingPointState& v) { mountingPointState_ = v; }
+  
+private:
+  int32_t structureElementId_;
+  MountingPointState mountingPointState_;
+};
+
+// MainSchedule - benötigt für Schedule-Daten
+class MainSchedule {
+public:
+  MainSchedule() : id_(0) {}
+  int32_t id() const { return id_; }
+  void id(int32_t v) { id_ = v; }
+  
+  // elements() returns vector of MountingPointPlan
+  const std::vector<MountingPointPlan>& elements() const { return elements_; }
+  void elements(const std::vector<MountingPointPlan>& v) { elements_ = v; }
+  
+private:
+  int32_t id_;
+  std::vector<MountingPointPlan> elements_;
+};
+
+// InstrumentationAssetState Enum
+enum class InstrumentationAssetState
+{
+  Undefined = 0,
+  Ok = 1,
+  Defect = 2
+};
+
+// InstrumentationAsset - Asset-Daten
+class InstrumentationAsset {
+public:
+  InstrumentationAsset() : assetId_(0), assetStateId_(InstrumentationAssetState::Undefined) {}
+  int32_t assetId() const { return assetId_; }
+  void assetId(int32_t v) { assetId_ = v; }
+  
+  InstrumentationAssetState assetStateId() const { return assetStateId_; }
+  void assetStateId(InstrumentationAssetState v) { assetStateId_ = v; }
+  
+private:
+  int32_t assetId_;
+  InstrumentationAssetState assetStateId_;
+};
+
+// Dtc - Data Transfer Component (Hauptklasse für ISM-Daten)
+class Dtc : public QObject
+{
+  Q_OBJECT
+  
+public:
+  Dtc(QObject* parent = nullptr) : QObject(parent) {}
+  ~Dtc() override = default;
+  
+  // MainStructureElement Zugriff
+  virtual const QMap<qint32, MainStructureElement>& mainStructureElements() const = 0;
+  virtual MainStructureElement mainStructureElement(int32_t id) const = 0;
+  virtual bool getStructureElementById(int32_t id, StructureElement& out) const = 0;
+  virtual void waitForHistoricalDataMainStructureElement(int timeoutMs) = 0;
+  
+  // MainSchedule Zugriff
+  virtual const QMap<qint32, MainSchedule>& mainSchedules() const = 0;
+  virtual MainSchedule mainSchedule(int32_t id) const = 0;
+  virtual void waitForHistoricalDataMainSchedule(int timeoutMs) = 0;
+  
+  // MountingPointAsset Zugriff
+  virtual void mountingPointAssets(const std::function<void(const MountingPointAsset&)>& cb) = 0;
+  virtual void waitForHistoricalDataMountingPointAsset(int timeoutMs) = 0;
+  virtual InstrumentationAsset instrumentationAsset(int32_t assetId) const = 0;
+  
+  // MainFootprint Zugriff (wird in ism_dtc_impl_custom_p.h verwendet)
+  virtual MainFootprint mainFootprint(int mseId) const = 0;
+  
+signals:
+  void mainStructureElementChanged(const MainStructureElement& data, DataModification modType);
+  void mainScheduleChanged(const MainSchedule& data, DataModification modType);
+  void mountingPointAssetChanged(const MountingPointAsset& data, DataModification modType);
+};
+
+// Ftc - Forward Declaration (wird später implementiert)
+class Ftc : public QObject
+{
+  Q_OBJECT
+  
+public:
+  Ftc(QObject* parent = nullptr) : QObject(parent) {}
+  ~Ftc() override = default;
+};
+
 } // namespace Interface
 } // namespace InfrastructureManagement

qt6-after/qt6-migrated-legatus/include/OperatorManagement/opm_dtc.h

@@ -1,10 +1,11 @@
 #pragma once
 
 // STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
-// Für die Migration erstellen wir minimale Forward-Declarations
+// Für die Migration erstellen wir minimale Implementierungen
 
 #include <QtGlobal>
 #include <string>
+#include <memory>
 
 namespace OperatorManagement
 {
@@ -20,7 +21,23 @@ struct User
 
 namespace Interface
 {
-class Dtc;
+class Dtc
+{
+public:
+  // Initialization methods
+  void enableUser() {}
+  void waitForHistoricalDataUser() {}
+  
+  User user(qint32 id) const
+  {
+    // STUB-Implementierung - leerer User
+    User u;
+    u.m_id = id;
+    u.m_name = "Unknown";
+    return u;
+  }
+};
+
 class Ftc;
 } // namespace Interface
 } // namespace OperatorManagement

qt6-after/qt6-migrated-legatus/include/ParticipantManagement/ppm.hpp

@@ -4,10 +4,10 @@
 
 #include "ppm_enums.hpp"
 
-#include <QObject>
-#include <QString>
-#include <QList>
-#include <QMap>
+#include <QtCore/QObject>
+#include <QtCore/QString>
+#include <QtCore/QList>
+#include <QtCore/QMap>
 #include <functional>
 #include <memory>
 #include <ostream>

qt6-after/qt6-migrated-legatus/include/ParticipantManagement/ppm_enums.hpp

@@ -4,7 +4,7 @@
 // Für die Migration erstellen wir minimale Typ-Definitionen
 
 #include <ostream>
-#include <QString>
+#include <QtCore/QString>
 
 namespace ParticipantManagement
 {

qt6-after/qt6-migrated-legatus/include/ProjectDataManagement/pdm_enums.hpp

@@ -5,8 +5,8 @@
 
 #pragma once
 
-#include <QMap>
-#include <QString>
+#include <QtCore/QMap>
+#include <QtCore/QString>
 #include "pdm_types.h"
 
 namespace ProjectDataManagement

qt6-after/qt6-migrated-legatus/include/ProjectDataManagement/pdm_translation.h

@@ -11,7 +11,13 @@
 // filename: pdm_translation.h
 
 #include "pdm_enums.hpp"
+#ifndef PDM_COMMON_EXPORT
+#ifdef BUILD_RTI
 #include "svcpdmcommon_export.h"
+#else
+#define PDM_COMMON_EXPORT
+#endif
+#endif
 
 class QString;
 

qt6-after/qt6-migrated-legatus/include/Services/AreaEffectSimulation/aes.hpp

@@ -2,9 +2,9 @@
 // STUB-HEADER: Diese Datei wird normalerweise von DDS generiert
 // Für die Migration erstellen wir minimale Typ-Definitionen
 
-#include <QString>
-#include <QList>
-#include <QVector>
+#include <QtCore/QString>
+#include <QtCore/QList>
+#include <QtCore/QVector>
 
 namespace AreaEffectSimulation
 {

qt6-after/qt6-migrated-legatus/include/Services/AreaEffectSimulation/aes_enums.hpp

@@ -2,7 +2,7 @@
 // STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
 // Für die Migration erstellen wir minimale Typ-Definitionen
 
-#include <QString>
+#include <QtCore/QString>
 
 namespace AreaEffectSimulation
 {