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

Remove STUB files, use real dependencies

Browse Source 
- Removed all STUB files for external dependencies:
  - lts_session_stub.h/cpp
  - lts_session_data_dds_stub.h/cpp
  - lts_session_lock_handler_stub.h
  - elevation_map_manager.h/cpp (entire ElevationMap STUB)
  - avm_enums_stub.hpp
  - Test files for STUBs

- Updated LtsSession/CMakeLists.txt:
  - Removed conditional BUILD_RTI logic for STUBs
  - Always use real implementation files
  - BUILD_RTI=ON is now the default

- External dependencies are now expected in ./external/
  - RTI Connext DDS 7.7.0
  - ArcGIS SDK (runtime mount)
  - Other deps to be integrated step by step

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
This commit is contained in:
torstenandCopilot committed 2026-08-20 19:15:57 +02:00
1 parent 32041db9a7
commit 8c824f87b4
12 files changed
+26 -821
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

qt6-after/qt6-migrated-legatus/Lts/Common/LtsSession/CMakeLists.txt
+26 -33
View File
@@ -5,6 +5,24 @@
# Created by Mike Wille, SLSE, 2016-05-15
#
# RTI Connext DDS - default ON
OPTION(BUILD_RTI "Build with RTI Connext DDS support" ON)
# Find RTI Connext DDS
IF(BUILD_RTI)
# Try to find RTI in external directory first, then system paths
FIND_PACKAGE(RTIConnextDDS 7.7.0 QUIET
PATHS "${CMAKE_SOURCE_DIR}/../../../external/rti_connext_dds-7.7.0"
NO_DEFAULT_PATH
)
IF(NOT RTIConnextDDS_FOUND)
FIND_PACKAGE(RTIConnextDDS 7.7.0 QUIET)
ENDIF()
IF(NOT RTIConnextDDS_FOUND)
MESSAGE(WARNING "RTI Connext DDS not found, building without RTI support")
SET(BUILD_RTI OFF)
ENDIF()
ENDIF()
# LtsSessionDataDds (only with RTI)
IF(BUILD_RTI)
@@ -26,44 +44,19 @@ IF(BUILD_RTI)
NGLLogger
Qt6::Core
)
ELSE()
# Stub version for BUILD_RTI=OFF
SET(LtsSessionDataDds_SRCS
lts_session_data_dds_stub.cpp
lts_session_data_dds_stub.h
)
NGL_ADD_LIBRARY2(WS LtsSessionDataDds SHARED ${LtsSessionDataDds_SRCS})
NGL_TARGET_INCLUDE_DIRECTORIES(LtsSessionDataDds
PUBLIC
${CMAKE_CURRENT_SOURCE_DIR}/../
${CMAKE_CURRENT_BINARY_DIR}/../
)
NGL_TARGET_LINK_LIBRARIES(LtsSessionDataDds
PUBLIC
Qt6::Core
)
ENDIF()
# LtsSession (RTI dependencies optional)
IF(BUILD_RTI)
SET(ltssession_SRCS
lts_session.h
lts_session.cpp
lts_session_lock_handler.h
lts_session_manager.h
lts_session_manager.cpp
lts_session_lock_handler.cpp
)
ELSE()
# Stub version for BUILD_RTI=OFF
SET(ltssession_SRCS
lts_session_stub.h
lts_session_stub.cpp
lts_session_lock_handler.h
)
ENDIF()
SET(ltssession_SRCS
lts_session.h
lts_session.cpp
lts_session_lock_handler.h
lts_session_manager.h
lts_session_manager.cpp
lts_session_lock_handler.cpp
)
NGL_ADD_LIBRARY2(WS LtsSession SHARED ${ltssession_SRCS})
NGL_TARGET_INCLUDE_DIRECTORIES(LtsSession
qt6-after/qt6-migrated-legatus/Lts/Common/LtsSession/lts_session_data_dds_stub.cpp
-14
View File
@@ -1,14 +0,0 @@
/**
* @RDE_HEADER@
* Stub implementation for lts_session_data_dds.cpp when BUILD_RTI=OFF
* Provides minimal implementations to allow linking without RTI Connext DDS
*/
#include "lts_session_data_dds_stub.h"
namespace LtsSession
{
// No additional implementation needed - all methods are inline in header
} // namespace LtsSession
qt6-after/qt6-migrated-legatus/Lts/Common/LtsSession/lts_session_data_dds_stub.h
-176
View File
@@ -1,176 +0,0 @@
/**
* @RDE_HEADER@
* Stub header for lts_session_data_dds.h when BUILD_RTI=OFF
* Provides minimal declarations to allow compilation without RTI Connext DDS
*
* NOTE: No Q_OBJECT macro - this is a stub class without signals/slots
*/
#pragma once
#include <QObject>
#include <QMap>
#include <QString>
#include <QStringList>
#include <QUrl>
#include <memory>
#include "Lts/Common/ProjectConfig/project_defines.h"
// IDL::PartitionType is already defined in project_defines.h
// No need to redefine it here
namespace LtsSession
{
// Stub DdsConnectionParams - minimal version without DDS dependencies
struct DdsConnectionParams
{
int domainId = -1;
int partitionId = 0;
IDL::PartitionType partitionType = IDL::PartitionType::Any;
int exerciseId = 0;
QUrl tcpConnectionUrl;
QStringList qos_file;
DdsConnectionParams() = default;
bool isValid() const
{
return false;
} // Always invalid without DDS
bool hasSameDomainParams(const DdsConnectionParams&) const
{
return false;
}
bool operator==(const DdsConnectionParams&) const
{
return false;
}
bool operator!=(const DdsConnectionParams&) const
{
return true;
}
bool operator<(const DdsConnectionParams&) const
{
return false;
}
};
// Forward declare internal classes
namespace DDSConnector
{
class DdsConnector;
}
namespace DataPluginBase
{
class Interface;
}
namespace GuiPluginBase
{
class Interface;
}
// Stub LtsSessionDataDds class - inherits QObject for QPointer compatibility
// NO Q_OBJECT macro - avoids MOC generation issues, but provides QObject interface
class LtsSessionDataDds : public QObject
{
public:
explicit LtsSessionDataDds(QObject* parent = nullptr) : QObject(parent) {}
~LtsSessionDataDds() override = default;
bool init(const DdsConnectionParams&)
{
return false;
}
std::shared_ptr<DDSConnector::DdsConnector> ddsConnector()
{
return nullptr;
}
std::shared_ptr<DDSConnector::DdsConnector> ddsConnectorGlobal()
{
return nullptr;
}
int domainId() const
{
return -1;
}
int exerciseId() const
{
return -1;
}
int partitionId() const
{
return -1;
}
QStringList qosFile() const
{
return QStringList();
}
QString toString() const
{
return QStringLiteral("LtsSessionDataDds(stub)");
}
QUrl tcpConnectionUrl() const
{
return QUrl();
}
DdsConnectionParams connParams() const
{
return DdsConnectionParams();
}
qint64 partitionTime() const
{
return 0;
}
// Stub methods for signals (no-op in stub version)
void partitionTimeChanged(qint64) {} // no-op
void partitionTimeChangedInternal() {} // no-op
// Q_OBJECT compatibility methods (delegate to QObject)
void* qt_metacast(const char* _clname) override
{
return QObject::qt_metacast(_clname);
}
int qt_metacall(QMetaObject::Call _c, int _id, void** _a) override
{
return QObject::qt_metacall(_c, _id, _a);
}
// staticMetaObject - inline definition to avoid linker errors
// Points to QObject's meta object since we have no custom meta-object
static inline const QMetaObject staticMetaObject = QObject::staticMetaObject;
};
// Stub Fetcher class
class Fetcher
{
public:
Fetcher(LtsSessionDataDds*, const QString&) {}
template <typename T> void getForeignGuiInterface(std::shared_ptr<T>&, const QString&, bool) {}
bool status() const
{
return false;
}
};
} // namespace LtsSession
qt6-after/qt6-migrated-legatus/Lts/Common/LtsSession/lts_session_lock_handler_stub.h
-118
View File
@@ -1,118 +0,0 @@
/**
* @RDE_HEADER@
* Stub header for lts_session_lock_handler.h when BUILD_RTI=OFF
* Provides minimal declarations to allow compilation without RTI Connext DDS
*/
#pragma once
#include <LtsSession/ltssession_export.h>
#include <LtsWidgets/lts_dialog.h>
#include <NGLLogger/NGLLoggerBootstrap.h>
#include <QObject>
#include <QPointer>
#include <memory>
namespace LtsSession
{
// Stub TopicLockHandler class - minimal version without DDS functionality
class LTSSESSION_EXPORT TopicLockHandler : public QObject
{
Q_OBJECT
public:
explicit TopicLockHandler(QObject* parent = nullptr)
: QObject(parent),
m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger().getNGLLogger("LtsSession.TopicLockHandler"))
{
}
~TopicLockHandler() override = default;
bool init(const void* /*coreFtc*/, int /*exerciseId*/)
{
return false;
}
bool isLocked() const
{
return false;
}
LtsWidgets::TopicInfo getTopicInfo() const
{
return LtsWidgets::TopicInfo();
}
public slots:
void slotTryLock(const LtsWidgets::TopicInfo& /*topicInfo*/) {}
bool slotUnlock()
{
return false;
}
void slotFinalize()
{
deleteLater();
}
signals:
void signalLockDialog(const QString& /*lockedBy*/) {}
void signalUnlockDialog() {}
private:
NGL::INGLLogger& m_logger;
};
class LTSSESSION_EXPORT TopicLockHanderData : public QObject
{
Q_OBJECT
public:
explicit TopicLockHanderData(QObject* parent = nullptr) : QObject(parent) {}
~TopicLockHanderData() override = default;
void init(const void* /*coreFtc*/, int /*exerciseId*/) {}
void unlock() {}
void slotTryLock(const LtsWidgets::TopicInfo& /*topicInfo*/) {}
bool isLocked() const
{
return false;
}
LtsWidgets::TopicInfo getTopicInfo() const
{
return LtsWidgets::TopicInfo();
}
const QString& getLockedBy() const
{
return m_lockedBy;
}
Q_SIGNALS:
void lockDataChanged();
private Q_SLOTS:
void slotLock(const QString& /*lockedBy*/) {}
void slotUnlock() {}
public:
QString m_debugName;
private:
QPointer<TopicLockHandler> m_topicLockHandler;
QString m_lockedBy;
};
} // namespace LtsSession
qt6-after/qt6-migrated-legatus/Lts/Common/LtsSession/lts_session_stub.cpp
-60
View File
@@ -1,60 +0,0 @@
/**
* @RDE_HEADER@
* Stub implementation for lts_session.cpp when BUILD_RTI=OFF
* Provides minimal LtsSession class without RTI Connext DDS dependencies
*/
#include "lts_session_stub.h"
#include <QDebug>
namespace LtsSession
{
LtsSession::LtsSession(QObject* parent)
: LtsSessionDataDds(parent)
, m_initialized(false)
, m_sessionId(QStringLiteral("stub-session"))
{
}
LtsSession::~LtsSession() = default;
bool LtsSession::init(const DdsConnectionParams& /*params*/)
{
qWarning() << "LtsSession::init() called in STUB mode (BUILD_RTI=OFF) - no DDS functionality available";
m_initialized = false;
emit initialized(false);
return false;
}
bool LtsSession::isInitialized() const
{
return m_initialized;
}
std::shared_ptr<DataPluginBase::Interface> LtsSession::dataPlugin() const
{
return nullptr;
}
std::shared_ptr<GuiPluginBase::Interface> LtsSession::guiPlugin() const
{
return nullptr;
}
QString LtsSession::sessionId() const
{
return m_sessionId;
}
int LtsSession::exerciseId() const
{
return -1;
}
QString LtsSession::toString() const
{
return QStringLiteral("LtsSession(stub, initialized=%1)").arg(m_initialized ? "true" : "false");
}
} // namespace LtsSession
qt6-after/qt6-migrated-legatus/Lts/Common/LtsSession/lts_session_stub.h
-64
View File
@@ -1,64 +0,0 @@
/**
* @RDE_HEADER@
* Stub header for lts_session.h when BUILD_RTI=OFF
* Provides minimal LtsSession class without RTI Connext DDS dependencies
*/
#pragma once
#include "lts_session_data_dds_stub.h"
#include <QObject>
#include <memory>
namespace LtsSession
{
// Forward declarations
namespace DataPluginBase
{
class Interface;
}
namespace GuiPluginBase
{
class Interface;
}
/**
* @brief Stub LtsSession class for BUILD_RTI=OFF
*
* This stub provides the same interface as the real LtsSession class
* but without any RTI DDS functionality. All methods return default values
* or nullptr.
*/
class LtsSession : public LtsSessionDataDds
{
Q_OBJECT
public:
explicit LtsSession(QObject* parent = nullptr);
~LtsSession() override;
// Initialization - always returns false in stub mode
bool init(const DdsConnectionParams& params);
bool isInitialized() const;
// Plugin interfaces - return nullptr in stub mode
std::shared_ptr<DataPluginBase::Interface> dataPlugin() const;
std::shared_ptr<GuiPluginBase::Interface> guiPlugin() const;
// Session info - return default values
QString sessionId() const;
int exerciseId() const;
QString toString() const;
signals:
void initialized(bool success);
void sessionEnded();
private:
bool m_initialized = false;
QString m_sessionId;
};
} // namespace LtsSession
qt6-after/qt6-migrated-legatus/Lts/Viewer/SituationMap/ElevationMap/CMakeLists.txt
-20
View File
@@ -1,20 +0,0 @@
#
# ElevationMap STUB - Qt6 Migration
# Minimal implementation to allow LtsElevation compilation
#
NGL_ADD_LIBRARY2(WS SV HLA situationMapElevationMap SHARED
elevation_map_manager.cpp
elevation_map_manager.h
)
NGL_TARGET_INCLUDE_DIRECTORIES(situationMapElevationMap
PUBLIC
${CMAKE_CURRENT_SOURCE_DIR}/../../include/Viewer/SituationMap/ElevationMap
)
NGL_TARGET_LINK_LIBRARIES(situationMapElevationMap
PUBLIC
Qt6::Core
Qt6::Gui
)
qt6-after/qt6-migrated-legatus/Lts/Viewer/SituationMap/ElevationMap/elevation_map_manager.cpp
-92
View File
@@ -1,92 +0,0 @@
/**
* STUB-Implementierung für ElevationMapManager - Qt6 Migration
* Diese Datei ermöglicht das Kompilieren von LtsElevation ohne das vollständige ElevationMap-Modul
*/
#include "elevation_map_manager.h"
namespace SituationMap
{
class ElevationMapManager::Private
{
public:
bool initialized = false;
};
ElevationMapManager::ElevationMapManager() : d(new Private())
{
}
ElevationMapManager::~ElevationMapManager()
{
delete d;
}
int ElevationMapManager::init(const QStringList &filePaths_rough_to_fine)
{
Q_UNUSED(filePaths_rough_to_fine);
d->initialized = true;
return 0; // Success
}
void ElevationMapManager::cleanupCurrentContent()
{
d->initialized = false;
}
bool ElevationMapManager::waitForInitialization()
{
return d->initialized;
}
bool ElevationMapManager::isValid() const
{
return d->initialized;
}
double ElevationMapManager::elevation(double /*lon_rad*/, double /*lat_rad*/, bool * /*bIsCovered*/) const
{
return 0.0;
}
double ElevationMapManager::elevation(double /*lon_rad*/, double /*lat_rad*/, double defaultValue, bool * /*bIsCovered*/) const
{
return defaultValue;
}
QRectF ElevationMapManager::simpleUnitedExtent() const
{
return QRectF();
}
bool ElevationMapManager::contains(const QPointF & /*point*/) const
{
return false;
}
void ElevationMapManager::LOSProfile(const QPointF & /*start*/, const QPointF & /*end*/, LOSVector &losProfile)
{
losProfile.clear();
}
ElevationMapManager::LineOfSight ElevationMapManager::lineOfSightCalculation(const LOSVector & /*losProfile*/,
double /*centerHat*/,
double /*objHat*/) const
{
return LineOfSight::LOS_UNDEFINED;
}
ElevationMapManager::LineOfSight ElevationMapManager::lineOfSightCalculation(const LtsUtils::QPoint3D & /*startPointGeo_absZ*/,
const LtsUtils::QPoint3D & /*endPointGeo_absZ*/)
{
return LineOfSight::LOS_UNDEFINED;
}
ElevationMapManager::LineOfSight ElevationMapManager::lineOfSightCalculation(const QPointF & /*startPointGeo*/, double /*startHat*/,
const QPointF & /*endPointGeo*/, double /*endHat*/)
{
return LineOfSight::LOS_UNDEFINED;
}
} // namespace SituationMap
qt6-after/qt6-migrated-legatus/Lts/Viewer/SituationMap/ElevationMap/elevation_map_manager.h
-74
View File
@@ -1,74 +0,0 @@
/**
* STUB-Header für ElevationMapManager - Qt6 Migration
* Diese Datei ermöglicht das Kompilieren von LtsElevation ohne das vollständige ElevationMap-Modul
*/
#pragma once
#include <QObject>
#include <QStringList>
#include <QRectF>
#include <QPointF>
#include <vector>
namespace LtsUtils
{
struct QPoint3D
{
double x{0.0};
double y{0.0};
double z{0.0};
};
} // namespace LtsUtils
using LOSVector = std::vector<double>;
namespace SituationMap
{
class ElevationMapManager final : public QObject
{
Q_OBJECT
public:
ElevationMapManager();
ElevationMapManager(const ElevationMapManager &) = delete;
ElevationMapManager &operator = (const ElevationMapManager &) = delete;
~ElevationMapManager();
int init(const QStringList &filePaths_rough_to_fine);
void cleanupCurrentContent();
bool waitForInitialization();
bool isValid() const;
double elevation(double lon_rad, double lat_rad, bool *bIsCovered = nullptr) const;
double elevation(double lon_rad, double lat_rad, double defaultValue, bool *bIsCovered = nullptr) const;
QRectF simpleUnitedExtent() const;
bool contains(const QPointF &point) const;
void LOSProfile(const QPointF &start, const QPointF &end, LOSVector &losProfile);
enum class LineOfSight { LOS_UNDEFINED = 0,
LOS_ERROR,
LOS_VISIBLE,
LOS_INVISIBLE };
LineOfSight lineOfSightCalculation(const LOSVector &losProfile,
double centerHat,
double objHat) const;
LineOfSight lineOfSightCalculation(const LtsUtils::QPoint3D &startPointGeo_absZ,
const LtsUtils::QPoint3D &endPointGeo_absZ);
LineOfSight lineOfSightCalculation(const QPointF &startPointGeo, double startHat,
const QPointF &endPointGeo, double endHat);
protected:
class Private;
Private *d;
}; // ElevationMapManager
} // namespace SituationMap
qt6-after/qt6-migrated-legatus/include/AudioVideoManagement/avm_enums_stub.hpp
-128
View File
@@ -1,128 +0,0 @@
// Stub enums for AudioVideoManagement when BUILD_RTI is OFF
// These enums are normally generated from avm_enums.idl by RTI DDS tools
// This file provides minimal definitions for building without RTI
#ifndef AVM_ENUMS_STUB_HPP
#define AVM_ENUMS_STUB_HPP
#include <QString>
namespace AudioVideoManagement {
// RcOperatingMode enum wrapper with inner_enum typedef and underlying() method
struct RcOperatingMode {
enum Type {
FixedFreqEncNone = 0,
FixedFreqEncHwKr = 1,
FixedFreqEncHwKrKl = 2,
AkwEncNone = 3,
AkwEncEccm = 4,
SIMPLEX = 5,
HALFDUPLEX = 6,
DUPLEX = 7
};
using inner_enum = Type;
Type value;
constexpr RcOperatingMode(Type v = FixedFreqEncNone) : value(v) {}
constexpr operator Type() const { return value; }
int underlying() const { return static_cast<int>(value); }
static constexpr Type FixedFreqEncNone_v = FixedFreqEncNone;
static constexpr Type FixedFreqEncHwKr_v = FixedFreqEncHwKr;
static constexpr Type FixedFreqEncHwKrKl_v = FixedFreqEncHwKrKl;
static constexpr Type AkwEncNone_v = AkwEncNone;
static constexpr Type AkwEncEccm_v = AkwEncEccm;
static constexpr Type SIMPLEX_v = SIMPLEX;
static constexpr Type HALFDUPLEX_v = HALFDUPLEX;
static constexpr Type DUPLEX_v = DUPLEX;
};
// FrequencyBand enum wrapper with inner_enum typedef and underlying() method
struct FrequencyBand {
enum Type {
Undefined = 0,
HF = 1,
VHF = 2,
UHF = 3,
REL = 4
};
using inner_enum = Type;
Type value;
constexpr FrequencyBand(Type v = Undefined) : value(v) {}
constexpr operator Type() const { return value; }
int underlying() const { return static_cast<int>(value); }
static constexpr Type Undefined_v = Undefined;
static constexpr Type HF_v = HF;
static constexpr Type VHF_v = VHF;
static constexpr Type UHF_v = UHF;
static constexpr Type REL_v = REL;
};
// FrequencyBand_def namespace for legacy code compatibility
namespace FrequencyBand_def {
constexpr int HF = 1;
constexpr int UHF = 3;
constexpr int VHF = 2;
constexpr int REL = 4;
}
// RcOperatingMode_def namespace for legacy code compatibility
namespace RcOperatingMode_def {
constexpr int FixedFreqEncNone = 0;
constexpr int FixedFreqEncHwKr = 1;
constexpr int FixedFreqEncHwKrKl = 2;
constexpr int AkwEncNone = 3;
constexpr int AkwEncEccm = 4;
constexpr int SIMPLEX = 5;
constexpr int HALFDUPLEX = 6;
constexpr int DUPLEX = 7;
}
// ModulationType enum wrapper with inner_enum typedef and underlying() method
struct ModulationType {
enum Type {
AM = 0,
FM = 1
};
using inner_enum = Type;
Type value;
constexpr ModulationType(Type v = AM) : value(v) {}
constexpr operator Type() const { return value; }
int underlying() const { return static_cast<int>(value); }
};
// ChannelSpacingHF enum wrapper with inner_enum typedef and underlying() method
struct ChannelSpacingHF {
enum Type {
CS_100_Hz = 0
};
using inner_enum = Type;
Type value;
constexpr ChannelSpacingHF(Type v = CS_100_Hz) : value(v) {}
constexpr operator Type() const { return value; }
int underlying() const { return static_cast<int>(value); }
};
// ChannelSpacing enum wrapper with inner_enum typedef and underlying() method
struct ChannelSpacing {
enum Type {
CS_25_00_kHz = 0,
CS_12_50_kHz = 1,
CS_8_33_kHz = 2
};
using inner_enum = Type;
Type value;
constexpr ChannelSpacing(Type v = CS_25_00_kHz) : value(v) {}
constexpr operator Type() const { return value; }
int underlying() const { return static_cast<int>(value); }
};
} // namespace AudioVideoManagement
#endif // AVM_ENUMS_STUB_HPP
qt6-after/qt6-migrated-legatus/tests/test_lts_session_data_dds_stub.cpp
-21
View File
@@ -1,21 +0,0 @@
#include "qt6-after/qt6-migrated-legatus/Lts/Common/LtsSession/lts_session_data_dds_stub.h"
#include <gtest/gtest.h>
TEST(LtsSessionDataDdsStubTest, HeaderCompiles)
{
// Verify header compiles without errors
EXPECT_TRUE(true);
}
TEST(LtsSessionDataDdsStubTest, CanInstantiate)
{
// Basic instantiation test if class is instantiable
// Add specific instantiation code if class can be constructed
}
TEST(LtsSessionDataDdsStubTest, NamespaceExists)
{
// Verify namespace exists
// Add namespace verification if applicable
}
qt6-after/qt6-migrated-legatus/tests/test_lts_session_lock_handler_stub.cpp
-21
View File
@@ -1,21 +0,0 @@
#include "qt6-after/qt6-migrated-legatus/Lts/Common/LtsSession/lts_session_lock_handler_stub.h"
#include <gtest/gtest.h>
TEST(LtsSessionLockHandlerStubTest, HeaderCompiles)
{
// Verify header compiles without errors
EXPECT_TRUE(true);
}
TEST(LtsSessionLockHandlerStubTest, CanInstantiate)
{
// Basic instantiation test if class is instantiable
// Add specific instantiation code if class can be constructed
}
TEST(LtsSessionLockHandlerStubTest, NamespaceExists)
{
// Verify namespace exists
// Add namespace verification if applicable
}