Merge feature/lts-viewer-validation-testing-phase into feature/qt6-migration-basis-modules-merge

Resolves 1 conflict (new_docker_build.sh, union of viewer-only + codification options); folds in fixes for pre-existing defects surfaced by the validation runs (KDReports-qt6 wiring, LtsSession RTI linking, LtsFileDialog/WLS/BSM Qt6/RTI API migration, GROUP4 target list, new --cmake_build_flags option); validated with BUILD_RTI=ON BUILD_GRANTLEE=ON in 3 Docker runs (run 3: build green, 6 base-state first-run CTest failures documented).
Emit record_replay fromQVariant for plain enums; document PPM MOC exclusion
2026-09-27 07:33:29 +02:00 · 2026-09-26 00:49:47 +02:00 · 2026-09-25 20:23:37 +02:00 · 2026-09-24 16:49:49 +02:00 · 2026-09-23 17:37:56 +02:00 · 2026-09-23 13:36:37 +02:00
119 changed files with 1877 additions and 1578 deletions
@@ -191,6 +191,7 @@ OPTION(BUILD_PLUGINS_PARTICIPANT_ORG_CHART "Build ParticipantOrgChart (requires
 OPTION(BUILD_PLUGINS_MSDL "Build MSDL module (requires Qt6 XmlPatterns)" OFF)
 OPTION(BUILD_PLUGINS_SAAB "Build Saab module (requires Qt6 XmlPatterns)" OFF)
 OPTION(BUILD_RTI "Build RTI Connext DDS dependent modules" OFF)
+OPTION(BUILD_VIEWER_ONLY "Build only Viewer module (no RTI required)" OFF)
 # Add Lts/ include path globally for QosProfile and other Lts headers
 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/Lts)
 IF(BUILD_RTI)
@@ -525,8 +526,10 @@ if(NOT TARGET Qt6::WebEngineWidgets)
 endif()

 # Stub KDReports::KDReports target if not available (needed by LtsReportDisplay)
+# UNKNOWN (not INTERFACE) so FindKDReports.cmake can upgrade it with a real
+# IMPORTED_LOCATION; an INTERFACE imported target ignores IMPORTED_LOCATION.
 if(NOT TARGET KDReports::KDReports)
-  add_library(KDReports::KDReports INTERFACE IMPORTED)
+  add_library(KDReports::KDReports UNKNOWN IMPORTED)
  set_target_properties(KDReports::KDReports PROPERTIES
    INTERFACE_COMPILE_DEFINITIONS "NO_KDREPORTS"
  )
@@ -171,8 +171,20 @@ std::vector<T> fromJson(const QVariant &jsonData, type<std::vector<T>>)
  return ret;
 }

+// Primary fallback for any migrated plain-`enum class` enumerators that have no
+// explicit specialization below - most importantly the nested foreign
+// ProjectDataManagement / Core enums a plugin reads back from the database (they are
+// not in this service's idl_enums, so the per-own-enum specializations do not cover
+// them). Giving the primary template a body (rather than leaving it declaration-only)
+// is what lets those foreign-enum instantiations resolve, so the plugin .so links. The
+// explicit specializations for primitives / own enums / structs / vectors / optionals
+// all take precedence over this fallback, so it is only ever instantiated for an enum
+// type, where `static_cast<T>(val.toInt())` is the correct conversion.
 template<typename T>
-T fromQVariant(const QVariant &val, type<T>);
+T fromQVariant(const QVariant &val, type<T>)
+{
+  return static_cast<T>(val.toInt());
+}

 template<>
 bool fromQVariant(const QVariant &val, type<bool>)
@@ -266,6 +278,23 @@ T fromQVariant(const QVariant &val)
  return fromQVariant(val, type<T>{});
 }

+// rtiddsgen 7.7 spells the migrated enumerators as plain `enum class` in the service
+// namespace (the legacy dds::core::safe_enum<T> wrapper is gone). The record_replay
+// plugin still instantiates fromQVariant<Enum>() for each enum member it reads back,
+// and none of the generic overloads above are ever deduced for those types, so each of
+// this service's own enumerations needs its own explicit specialization. `idl_enums`
+// carries the service's own enumerations by local name and this block runs inside
+// `namespace {{ namespace }}`, so the local name resolves to the fully-qualified enum
+// type. (Nested foreign PDM enumerations are still not covered - same limitation as the
+// documented svcBuildings exclusion.)
+{% for enumeration in idl_enums %}
+template<>
+{{ enumeration.name }} fromQVariant(const QVariant &val, type<{{ enumeration.name }}>)
+{
+  return static_cast<{{ enumeration.name }}>(val.toInt());
+}
+{% endfor %}
+
 {% for dt in serializeTopics.member %}
 //
 // Begin {{ dt.typeFq }}
@@ -121,7 +121,7 @@ protected:
  int64_t                                                m_snapshot{{ dt.name }}MapTime = -1;  // time for which the snapshot is valid
 {% endif %} {% endfor %}

-  NGL::INGLLogger*                                         m_logger;
+  NGL::INGLLogger&                                         m_logger;
 };

 }
@@ -32,8 +32,10 @@ NGL_TARGET_LINK_LIBRARIES(LtsSessionDataDds
  PRIVATE
    $<$<BOOL:${BUILD_RTI}>:$<IF:$<TARGET_EXISTS:ddsconnector>,ddsconnector,>>
  PUBLIC
-    $<$<BOOL:${BUILD_RTI}>:nddscore>
+    $<$<BOOL:${BUILD_RTI}>:RTI::nddscore>
    $<$<BOOL:${BUILD_RTI}>:ddsQoS>
+    # Generated Core type support (topic_type_support<Core::PartitionTime>, ...)
+    $<$<BOOL:${BUILD_RTI}>:$<IF:$<TARGET_EXISTS:ddscore>,ddscore,>>
    NGLLogger
    Qt6::Core
 )
@@ -112,7 +114,7 @@ IF(BUILD_RTI)
    PRIVATE
      ddsconnector
    PUBLIC
-      nddscore
+      RTI::nddscore
  )
  TARGET_COMPILE_DEFINITIONS(LtsSession PUBLIC BUILD_RTI)
 ENDIF()
@@ -40,7 +40,9 @@
 #include <LtsWidgets/lts_tab_widget.h>
 #include <PluginInterfaces/data_plugin_interface.h>
 #include <PluginInterfaces/gui_plugin_interface.h>
-#ifdef BUILD_FILTERMANAGEMENT
+// Complete type needed for dynamic_pointer_cast of m_ohvIfc (BUILD_RTI code below);
+// the header is self-contained (Qt only), the FilterManagement plugin is only the implementor.
+#ifdef BUILD_RTI
 #include <Lts/Plugins/OnlineHelp/ohp_online_help_viewer_gui_plugin_interface.h> // XXX: grrr..
 #endif
 #include <QtWidgets/QApplication>
@@ -156,7 +158,7 @@ QString LtsSession::toString() const
    str.append(QStringLiteral(", workspaceId='%1'").arg(workspaceId()));
 #ifdef BUILD_RTI
    str.append(QStringLiteral(", appToString='%1'").arg(appToString(app())));
-    str.append(QStringLiteral(", partitionType=%1, exerciseId='%2'").arg(partitionType()).arg(exerciseId()));
+    str.append(QStringLiteral(", partitionType=%1, exerciseId='%2'").arg(static_cast<int>(partitionType())).arg(exerciseId()));
    str.append(QStringLiteral(", LtsSessionDataDds=%1").arg(LtsSessionDataDds::toString()));
 #else
    str.append(QStringLiteral(", app=Login (stub)"));
@@ -20,30 +20,6 @@
 #include <QtCore/QSet>
 #include <QtCore/QVector>

-namespace
-{
-// Convert LtsSession::PartitionType to IDL::PartitionType
-IDL::PartitionType toIdlPartitionType(LtsSession::PartitionType type)
-{
-    switch (type)
-    {
-        case LtsSession::PartitionType::Any:
-            return IDL::PartitionType::Any;
-        case LtsSession::PartitionType::Global:
-            return IDL::PartitionType::Global;
-        case LtsSession::PartitionType::Exercise:
-            return IDL::PartitionType::Exercise;
-        case LtsSession::PartitionType::AllExercises:
-            return IDL::PartitionType::AllExercises;
-        case LtsSession::PartitionType::Replay:
-            return IDL::PartitionType::Replay;
-        case LtsSession::PartitionType::Invalid:
-        default:
-            return IDL::PartitionType::Any;
-    }
-}
-} // namespace
-
 namespace LtsSession
 {
 /**
@@ -74,7 +50,7 @@ class DdsConnectionContainer
        for (int i = ddsConnections.size() - 1; i >= 0; --i)
        {
            const DdsConnection& conn = ddsConnections.at(i);
-            if (toIdlPartitionType(conn.partitionType) != IDL::PartitionType::Global)
+            if (conn.partitionType != IDL::PartitionType::Global)
                continue;
            auto ret = conn.ddsConnector.lock();
            if (ret != nullptr)
@@ -242,7 +218,7 @@ bool LtsSessionDataDds::init(const DdsConnectionParams& connParams)
 #endif

        m_ddsConnector = std::make_shared<DDSConnector::DdsConnector>(
-            connParams.domainId, toIdlPartitionType(connParams.partitionType), connParams.partitionId,
+            connParams.domainId, connParams.partitionType, connParams.partitionId,
            connParams.exerciseId, // same as partition Id in live but not in replay
            type);
        s_ddsConnections()->insertConnection(connParams, m_ddsConnector);
@@ -277,7 +253,7 @@ bool LtsSessionDataDds::init(const dds::domain::DomainParticipant& dp, const Dds
        if (m_ddsConnector == nullptr)
        {
            m_ddsConnector =
-                std::make_shared<DDSConnector::DdsConnector>(dp, toIdlPartitionType(connParams.partitionType), type, connParams.partitionId);
+                std::make_shared<DDSConnector::DdsConnector>(dp, connParams.partitionType, type, connParams.partitionId);

            s_ddsConnections()->insertConnection(connParams, m_ddsConnector);
        }
@@ -292,38 +268,27 @@ Fetcher* LtsSessionDataDds::fetcher(const QString& yourPluginsName)
    return m_fetcher;
 }

-QString LtsSessionDataDds::partitionTypeString(PartitionType partitionType)
+QString LtsSessionDataDds::partitionTypeString(IDL::PartitionType partitionType)
 {
    switch (partitionType)
    {
-        case PartitionType::AllExercises:
+        case IDL::PartitionType::AllExercises:
            return QStringLiteral("AllExercises");
-        case PartitionType::Any:
+        case IDL::PartitionType::Any:
            return QStringLiteral("Any");
-        case PartitionType::Exercise:
+        case IDL::PartitionType::Exercise:
            return QStringLiteral("Exercise");
-        case PartitionType::Global:
+        case IDL::PartitionType::Global:
            return QStringLiteral("Global");
-        case PartitionType::Replay:
+        case IDL::PartitionType::Replay:
            return QStringLiteral("Replay");
+        default:
+            break;
    }

    return QStringLiteral("Invalid (%1)").arg(int(partitionType));
 }

-LtsSession::PartitionType LtsSessionDataDds::toPartitionType(IDL::PartitionType idlType)
-{
-    switch (idlType)
-    {
-        case IDL::PartitionType::Any: return PartitionType::Any;
-        case IDL::PartitionType::Exercise: return PartitionType::Exercise;
-        case IDL::PartitionType::Replay: return PartitionType::Replay;
-        case IDL::PartitionType::AllExercises: return PartitionType::AllExercises;
-        case IDL::PartitionType::Global: return PartitionType::Global;
-        default: return PartitionType::Invalid;
-    }
-}
-
 QString LtsSessionDataDds::toString() const
 {
    return QStringLiteral("(LtsSessionDataDds: id=%1, partitionId=%2, partitionType=%3(%4), exerciseId=%5)")
@@ -349,9 +314,9 @@ int LtsSessionDataDds::partitionId() const
    return m_ddsConnector ? m_ddsConnector->getPartitionId() : -1;
 }

-PartitionType LtsSessionDataDds::partitionType() const
+IDL::PartitionType LtsSessionDataDds::partitionType() const
 {
-    return m_ddsConnector ? toPartitionType(m_ddsConnector->getPartitionType()) : PartitionType::Global;
+    return m_ddsConnector ? m_ddsConnector->getPartitionType() : IDL::PartitionType::Global;
 }

 QStringList LtsSessionDataDds::qosFile() const
@@ -394,7 +359,7 @@ bool LtsSessionDataDds::initInternal()
    assert(m_dtcPartitionTime.get());

    m_dtcPartitionTime->setSubscriberCallback([this](const Core::PartitionTime& data, DataModification) {
-        m_curMSecSinceEpoch = data.timeStamp();
+        m_curMSecSinceEpoch = data.timeStamp;
        emit partitionTimeChangedInternal();
    });
    connect(this, &LtsSessionDataDds::partitionTimeChangedInternal, this,
@@ -38,12 +38,12 @@ struct DdsConnectionParams

  DdsConnectionParams() = default;
  explicit DdsConnectionParams(const Core::ReplayPartition &rp)
-    : domainId(rp.domainId())
-    , partitionId(rp.id())
-    , exerciseId(rp.exerciseId())
+    : domainId(rp.domainId)
+    , partitionId(rp.id)
+    , exerciseId(rp.exerciseId)
    , partitionType(IDL::PartitionType::Replay)
  {
-    setTcpConnectionUrl(rp.tcpConnectionUrl());
+    setTcpConnectionUrl(rp.tcpConnectionUrl);
  }

  bool isValid() const { return domainId >= 0 && partitionType != IDL::PartitionType::Any; }
@@ -58,7 +58,7 @@ class GenericDtc
    bool takeAlive(TopicType& data) { return BaseClass::takeAlive(data); }
    bool takeDisposed(TopicType& data) { return BaseClass::takeDisposed(data); }
    bool hasSamples() const { return BaseClass::hasSamples(); }
-    std::shared_ptr<DRO_OBJECT> dataReader() { return BaseClass::dataReader(); }
+    DRO_OBJECT* dataReader() const override { return BaseClass::dataReader(); }
    bool waitForHistoricalData(int timeoutMSec) { return BaseClass::waitForHistoricalData(timeoutMSec); }
 };

@@ -81,7 +81,7 @@ class GenericDtcSampleInfo
    bool takeAlive(TopicType& data) { return BaseClass::takeAlive(data); }
    bool takeDisposed(TopicType& data) { return BaseClass::takeDisposed(data); }
    bool hasSamples() const { return BaseClass::hasSamples(); }
-    std::shared_ptr<DRO_OBJECT> dataReader() { return BaseClass::dataReader(); }
+    DRO_OBJECT* dataReader() const override { return BaseClass::dataReader(); }
    bool waitForHistoricalData(int timeoutMSec) { return BaseClass::waitForHistoricalData(timeoutMSec); }
 };

@@ -104,7 +104,7 @@ class Ddtc
    bool takeAlive(TopicType& data) { return BaseClass::takeAlive(data); }
    bool takeDisposed(TopicType& data) { return BaseClass::takeDisposed(data); }
    bool hasSamples() const { return BaseClass::hasSamples(); }
-    std::shared_ptr<DRO_OBJECT> dataReader() { return BaseClass::dataReader(); }
+    DRO_OBJECT* dataReader() const override { return BaseClass::dataReader(); }
    bool waitForHistoricalData(int timeoutMSec) { return BaseClass::waitForHistoricalData(timeoutMSec); }
 };

@@ -127,7 +127,7 @@ class DdtcSampleInfo
    bool takeAlive(TopicType& data) { return BaseClass::takeAlive(data); }
    bool takeDisposed(TopicType& data) { return BaseClass::takeDisposed(data); }
    bool hasSamples() const { return BaseClass::hasSamples(); }
-    std::shared_ptr<DRO_OBJECT> dataReader() { return BaseClass::dataReader(); }
+    DRO_OBJECT* dataReader() const override { return BaseClass::dataReader(); }
    bool waitForHistoricalData(int timeoutMSec) { return BaseClass::waitForHistoricalData(timeoutMSec); }
 };
 } // namespace DTC
@@ -111,6 +111,17 @@ class GenericDtcImplSubscriberTemplate : public DDSGeneric::SubscriberListenerCa
        return ret;
    }

+    bool readAlive(TopicTypeRead& data) override final
+    {
+        auto samples = readAlive();
+        if (samples.length() > 0)
+        {
+            data = samples[0].data();
+            return true;
+        }
+        return false;
+    }
+
    dds::sub::LoanedSamples<TopicTypeRead> takeAlive() const override final
    {
        if (!m_dataReaderObject)
@@ -124,6 +135,17 @@ class GenericDtcImplSubscriberTemplate : public DDSGeneric::SubscriberListenerCa
        return ret;
    }

+    bool takeAlive(TopicTypeRead& data) override final
+    {
+        auto samples = takeAlive();
+        if (samples.length() > 0)
+        {
+            data = samples[0].data();
+            return true;
+        }
+        return false;
+    }
+
    dds::sub::LoanedSamples<TopicTypeRead> takeDisposed() const override final
    {
        if (!m_dataReaderObject)
@@ -132,6 +154,17 @@ class GenericDtcImplSubscriberTemplate : public DDSGeneric::SubscriberListenerCa
        return m_dataReaderObject->takeDisposed();
    }

+    bool takeDisposed(TopicTypeRead& data) override final
+    {
+        auto samples = takeDisposed();
+        if (samples.length() > 0)
+        {
+            data = samples[0].data();
+            return true;
+        }
+        return false;
+    }
+
    bool hasSamples() const override final
    {
        if (!m_dataReaderObject)
@@ -64,5 +64,6 @@ class FunctionTopicTests : public QObject
    DdsUnitTests::FunctionRequestWithState m_requestTopicWithState;
    DdsUnitTests::FunctionReplyWithState m_replyTopicWithState;

+    NGL::INGLLogger& m_logger;
    Qt::HANDLE m_mainThreadId;
 };
@@ -47,6 +47,10 @@ NGL_TARGET_LINK_LIBRARIES(BuildingControlBsm
    BuildingControlCommon
    svcTabCommon
 )
+NGL_TARGET_INCLUDE_DIRECTORIES(BuildingControlBsm
+  PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}/../..
+)

 NGL_ADD_EXECUTABLE(AAR SV BuildingControlTestBsm bsm_test_main.cpp)
 NGL_TARGET_LINK_LIBRARIES(BuildingControlTestBsm
@@ -3,6 +3,7 @@

 #include "bsm_api.h"
 #include "bsm_socket_handler.h"
+#include <TrainingAreaBase/logger.h>

 namespace BuildingControlUnit
 {
@@ -6,6 +6,7 @@
 #include "bsm_telegrams_configuration_setup.h"
 #include <QtCore/QTimer>
 #include <QtNetwork/QHostAddress>
+#include <TrainingAreaBase/logger.h>

 static const int s_aliveTimeout = 10;  
 namespace BuildingControlUnit
@@ -3,6 +3,7 @@

 #include "bsm_socket_handler.h"
 #include <utility>
+#include <TrainingAreaBase/logger.h>
 #include "bsm_telegrams_base.h"
 #include "bsm_telegrams_bit_timeout_request.h"
 #include "bsm_telegrams_chopped_signal_flash.h"
@@ -3,6 +3,7 @@

 #include "bsm_telegrams_base.h"
 #include "bsm_telegrams_alive.h"
+#include <TrainingAreaBase/logger.h>
 #include "bsm_telegrams_bit_timeout_report.h"
 #include "bsm_telegrams_direct_fire.h"
 #include "bsm_telegrams_sw_version_report.h"
@@ -2,7 +2,7 @@


 #include "bsm_telegrams_direct_fire.h"
-#include "logger.h"
+#include <TrainingAreaBase/logger.h>
 #include <QStringBuilder>

 namespace BuildingControlUnit
@@ -2,6 +2,7 @@


 #include "vwm_api.h"
+#include <TrainingAreaBase/logger.h>
 #include <utility>
 #include "vwm_deposition.h"
 #include "vwm_xml_reader.h"
@@ -2,6 +2,7 @@


 #include "vwm_building.h"
+#include <TrainingAreaBase/logger.h>
 #include <utility>
 #include "vwm_math.h"
 #include <QtCore/QSet>
@@ -2,6 +2,7 @@


 #include "vwm_building_room_geometry.h"
+#include <TrainingAreaBase/logger.h>
 #include "bcu_xml_reader.h"

 #include <LtsUtils/LtsUtilsCore/qpoint3d.h>
@@ -2,6 +2,7 @@


 #include "vwm_math.h"
+#include <TrainingAreaBase/logger.h>
 #include <utility>

 #include <logger.h>
@@ -1,6 +1,7 @@


 #include "vwm_state_store.h"
+#include <TrainingAreaBase/logger.h>
 #include <utility>
 #include <logger.h>
 #include <QtCore/QJsonDocument>
@@ -3,6 +3,7 @@


 #include "vwm_xml_reader.h"
+#include <TrainingAreaBase/logger.h>
 #include "vwm_building_room_geometry.h"
 #include <logger.h>
 #include <QtCore/QFile>
@@ -2,6 +2,7 @@

 #include "connection_handler.h"
 #include <utility>
+#include <NGLLogger/NGLLoggerBootstrap.h>

 #include "client_connection.h"

@@ -4,6 +4,7 @@
 #include "message_transmitter.h"
 #include "client_message.h"
 #include <memory>
+#include <NGLLogger/NGLLoggerBootstrap.h>

 namespace CombatNetRadio
 {
@@ -7,6 +7,7 @@
 #include "Messages/message_transmitter.h"
 #include "dds_handler.h"
 #include "exercise_manager.h"
+#include <NGLLogger/NGLLoggerBootstrap.h>

 namespace CombatNetRadio
 {
@@ -17,6 +18,7 @@ WebSocketInterfaceHandler::WebSocketInterfaceHandler(ExerciseManager *exerciseMa
  : m_exerciseManager(exerciseManager)
  , m_connectionHandler(nullptr)
  , m_messageHandler(nullptr)
+  , m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger())
 {
  Q_ASSERT(exerciseManager);
 }
@@ -51,7 +51,7 @@ bool CheckmkHandler::initialize(const QString &checkMkServerHostname, int checkM
  }

  connect(m_socket, &QTcpSocket::stateChanged, this, &CheckmkHandler::onStateChanged);
-  connect(m_socket, qOverload<QAbstractSocket::SocketError>(&QAbstractSocket::error),
+  connect(m_socket, &QAbstractSocket::errorOccurred,
          this, &CheckmkHandler::onSocketError);

  connect(m_socket, &QTcpSocket::connected,
@@ -51,7 +51,7 @@ bool CheckmkHandlerScheduleCheck::initialize(const QString &checkMkServerHostnam
  }

  connect(m_socket, &QTcpSocket::stateChanged, this, &CheckmkHandlerScheduleCheck::onStateChanged);
-  connect(m_socket, qOverload<QAbstractSocket::SocketError>(&QAbstractSocket::error),
+  connect(m_socket, &QAbstractSocket::errorOccurred,
          this, &CheckmkHandlerScheduleCheck::onSocketError);

  connect(m_socket, &QTcpSocket::connected,
@@ -127,6 +127,11 @@ CODEGEN_SERVER_TOPICS(SRCS_server ${xml_FILE})
 CODEGEN_SQL(SRCS_server ${xml_FILE})

 NGL_ADD_LIBRARY2(AAR SV svcGnaServer SHARED ${SRCS_server})
+# NGL_ADD_LIBRARY2 (unlike NGL_ADD_LIBRARY) does not define the
+# MAKE_<SYMBOL>_LIB compile guard, but the generated gna_[d|f]ts_impl.h
+# headers that this target compiles carry such a guard — same situation as
+# svcGnaClient, which defines MAKE_SVCGNACLIENT_LIB explicitly for the same reason.
+TARGET_COMPILE_DEFINITIONS(svcGnaServer PRIVATE MAKE_SVCGNASERVER_LIB)
 NGL_TARGET_LINK_LIBRARIES(svcGnaServer
  PRIVATE
    ddsfts
@@ -4,6 +4,7 @@
 #include "dds_handler.h"
 #include <TrainingAreaBase/tab_dts.h>
 #include <DDS/DTS/generic_dts.h>
+#include <NGLLogger/NGLLoggerBootstrap.h>

 namespace GuezNasat
 {
@@ -12,7 +13,8 @@ namespace GuezNasat


 Participant2Dds::Participant2Dds(const dds::domain::DomainParticipant &domainParticipant, int exerciseId)
-  : m_ddsConnector(new DDSConnector::DdsConnector(domainParticipant, IDL::PartitionType::Exercise, exerciseId))
+  : m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger())
+  , m_ddsConnector(new DDSConnector::DdsConnector(domainParticipant, IDL::PartitionType::Exercise, exerciseId))
 {
  m_ddsConnector->initPublisherSubscriber();
  m_ppmDtc = ParticipantManagement::Interface::Dtc::create(m_ddsConnector);
@@ -9,6 +9,7 @@
 #include <ExerciseManagement/exm_dtc.h>
 #include <AreaEffectSimulation/aes_ftc.h>
 #include <ParticipantManagement/ppm.hpp>
+#include <ParticipantManagement/ppm_dtc.h>
 #include <ProjectDataManagement/pdm_dtc.h>
 #include <TrainingAreaBase/tab_dts.h>
 #include <QtCore/QHash>
@@ -33,6 +33,7 @@ NasatAircraft fromDb(const Database::NasatAircraft &db)
 HandlerNasatAircraft::HandlerNasatAircraft(Initialization *mainHandler)
  : QObject()
  , Interface::Fts::ModifyNasatAircraftRequestHandler(mainHandler->dds()->fts())
+  , m_logger(getLogger("HandlerNasatAircraft"))
  , m_mainHandler(mainHandler)
  , m_dts(mainHandler->dds()->dts())
  , m_fts(mainHandler->dds()->fts())
@@ -35,6 +35,7 @@ NasatAircraftParticipant fromDb(const Database::NasatAircraftParticipant &db)
 HandlerNasatAircraftParticipant::HandlerNasatAircraftParticipant(Initialization *mainHandler)
  : QObject()
  , Interface::Fts::ModifyNasatAircraftParticipantRequestHandler(mainHandler->dds()->fts())
+  , m_logger(getLogger("HandlerNasatAircraftParticipant"))
  , m_mainHandler(mainHandler)
  , m_dts(mainHandler->dds()->dts())
  , m_fts(mainHandler->dds()->fts())
@@ -21,6 +21,7 @@ namespace GuezNasat
 {
 HandlerNasatImpact::HandlerNasatImpact(Initialization *mainHandler)
  : AreaEffectSimulation::Interface::Ftc::AirSupportImpactModifyReplyHandler()
+  , m_logger(getLogger("HandlerNasatImpact"))
  , m_mainHandler(mainHandler)
 {
  TRACE_LOG(m_logger) << Q_FUNC_INFO << " START";
@@ -15,7 +15,8 @@
 namespace GuezNasat
 {
 HandlerNasatNineLiner::HandlerNasatNineLiner(Initialization *mainHandler)
-  : m_mainHandler(mainHandler)
+  : m_logger(getLogger("HandlerNasatNineLiner"))
+  , m_mainHandler(mainHandler)
 {}

 bool HandlerNasatNineLiner::init() const
@@ -38,8 +39,8 @@ static Nasat9Liner createDds9Liner(const NasatNineLiner &nasatNineLiner)
  nl.sampleTime = tsMSec;

  if (nasatNineLiner.initialPointMode != 0)
-    nl.initialPoint(Core::GeoPosition2D(LtsCoordTrans::deg2rad() * nasatNineLiner.initialPoint.lon,
-                                        LtsCoordTrans::deg2rad() * nasatNineLiner.initialPoint.lat));
+    nl.initialPoint = Core::GeoPosition2D(LtsCoordTrans::deg2rad() * nasatNineLiner.initialPoint.lon,
+                                          LtsCoordTrans::deg2rad() * nasatNineLiner.initialPoint.lat);

  if (nasatNineLiner.heading2InitialPointMode != Heading2InitialPointMode::Undefined)
  {
@@ -60,9 +61,9 @@ static Nasat9Liner createDds9Liner(const NasatNineLiner &nasatNineLiner)
  if (nasatNineLiner.targetPositionMode != 0)
  {
    const auto z = nasatNineLiner.altitudeTargetMode != 0 ? nasatNineLiner.altitudeTarget : -1;
-    nl.targetPosition(Core::GeoPosition(LtsCoordTrans::deg2rad() * nasatNineLiner.targetPosition.lon,
-                                        LtsCoordTrans::deg2rad() * nasatNineLiner.targetPosition.lat,
-                                        z));
+    nl.targetPosition = Core::GeoPosition(LtsCoordTrans::deg2rad() * nasatNineLiner.targetPosition.lon,
+                                          LtsCoordTrans::deg2rad() * nasatNineLiner.targetPosition.lat,
+                                          z);
  }
  else
  {
@@ -25,7 +25,8 @@ NasatAircraftParticipantEx::NasatAircraftParticipantEx()
 }

 NasatAircraftParticipantEx::NasatAircraftParticipantEx(const NasatAircraftParticipant &nap, const std::shared_ptr<Participant2Dds> &publisher)
-  : m_nap(nap)
+  : m_logger(getLogger("NasatAircraftParticipantEx"))
+  , m_nap(nap)
  , m_publisher(publisher)
 {
  DEBUG_LOG(m_logger) << Q_FUNC_INFO << " START";
@@ -22,7 +22,7 @@ class AbstractSocketHandler;
 using DbHandler = NGLDB::DbServiceHandler<DatabaseInterface>;
 class HandlerCodificationData;

-class GNA_SERVER_EXPORT Initialization final
+class SVCGNASERVER_EXPORT Initialization final
 {
 public:
  Initialization();
@@ -15,7 +15,7 @@ namespace GuezNasat
 {
 namespace Settings
 {
-GNA_SERVER_EXPORT void setIniFile(const QString &ini);
+SVCGNASERVER_EXPORT void setIniFile(const QString &ini);
 NGL::Settings *settings();
 quint16 socketListenPort();
 bool useWebSocket();
@@ -297,6 +297,14 @@ NGL_TARGET_LINK_LIBRARIES(svcTrainingAreaBase
  LtsUtilsCore
  svcTabCommon
  svcTabServer
+  # main_handler.cpp includes the generated <TrainingAreaBase/tab_record_replay_plugin.h>
+  # and directly instantiates TrainingAreaBase::RecordReplayPluginCustom (whose methods
+  # live in the plugin .so). Linking the plugin target (rather than relying on a full
+  # `make all` having generated the header first) makes this a proper build dependency:
+  # the plugin's codegen runs before the exe compiles (so the generated header exists),
+  # the plugin's PUBLIC build-tree include dir is inherited (so the include resolves),
+  # and the plugin .so is linked (so the RecordReplayPluginCustom symbols resolve).
+  $<IF:$<TARGET_EXISTS:tabRecordReplayPlugin>,tabRecordReplayPlugin,>
  svcNomClient
  svcAesClient
  svcOpmClient
@@ -4,7 +4,7 @@

 #include <TrainingAreaBase/tab_record_replay_plugin.h>

-#include <../../Common/PluginInterfaces/record_replay_plugin.h>
+#include <Common/PluginInterfaces/record_replay_plugin.h>

 namespace TrainingAreaBase
 {
@@ -4,7 +4,8 @@
 #include "canag_handler.h"

 #include <LtsUtils/LtsUtilsCore/dds_vector.h>
-#include <LtsUtils/qbytearray_byteaccess.h>
+#include <LtsUtilsCore/qbytearray_byteaccess.h>
+#include <NGLLogger/NGLLoggerBootstrap.h>

 #include "connection_handler.h"
 #include "main_handler.h"
@@ -222,7 +223,8 @@ void TxDdlHandler::sendAbort(quint8 error)
 }

 RxDdlHandler::RxDdlHandler(bool isMultiplexed)
-  : m_isMultiplexed(isMultiplexed)
+  : m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger())
+  , m_isMultiplexed(isMultiplexed)
 {}

 void RxDdlHandler::process(const QByteArray &data)
@@ -333,7 +335,8 @@ void RxDdlHandler::sendDPConfirmation(const quint32 ccs, const quint32 toggle, c
 }

 CanagHandler::CanagHandler(MainHandler *mainHandler)
-  : m_mainHandler(mainHandler)
+  : m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger())
+  , m_mainHandler(mainHandler)
  , m_connectionHandler(mainHandler->connectionHandler())
  , m_rxHandler(mainHandler->rxHandler())
  , m_freeText(QByteArray())
@@ -91,6 +91,7 @@ signals:
 private:
  void sendDPConfirmation(const quint32 ccs, const quint32 toggle, const quint32 wirkfeldMultiplex = 0);

+  NGL::INGLLogger &m_logger;
  bool        m_isMultiplexed = false;
  DdlState    m_state = DdlState::NotStarted;

@@ -186,6 +187,7 @@ private:
    WakeUpSfm = 1773
  };

+  NGL::INGLLogger &m_logger;
  MainHandler                        *m_mainHandler;
  std::shared_ptr<ConnectionHandler>  m_connectionHandler;
  std::shared_ptr<HandlerAesData>     m_handlerAesData;
@@ -3,16 +3,20 @@

 #include "connection_handler.h"

+#include <NGLLogger/NGLLoggerBootstrap.h>
+
 namespace TrainingAreaBaseOC
 {

 #ifdef GUEZ_MODE
 ConnectionHandler::ConnectionHandler()
  : ConnectionHandlerSerial()
+  , m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger())
 {}
 #else
 ConnectionHandler::ConnectionHandler()
  : ConnectionHandlerTcpTtci()
+  , m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger())
 {}
 #endif

@@ -5,6 +5,8 @@

 #include <QtCore/QTimer>

+#include <NGLLogger/NGLLoggerBootstrap.h>
+
 #include "settings.h"

 namespace TrainingAreaBaseOC
@@ -5,6 +5,8 @@

 #include <QtCore/QTimer>

+#include <NGLLogger/NGLLoggerBootstrap.h>
+
 #include "settings.h"

 namespace TrainingAreaBaseOC
@@ -28,7 +30,7 @@ bool ConnectionHandlerTcp::init()
  m_socket = new QTcpSocket();

  connect(m_socket, &QTcpSocket::readyRead, this, &ConnectionHandlerTcp::read);
-  connect(m_socket, QOverload<QAbstractSocket::SocketError>::of(&QAbstractSocket::error), this, &ConnectionHandlerTcp::handleError);
+  connect(m_socket, &QAbstractSocket::errorOccurred, this, &ConnectionHandlerTcp::handleError);
  connect(m_socket, &QTcpSocket::disconnected, this, &ConnectionHandlerTcp::open);
  connect(m_socket, &QTcpSocket::disconnected, this, &ConnectionHandlerTcp::disconnectedFromEq);
  open();
@@ -9,6 +9,8 @@

 #include <QtCore/QTimer>

+#include <NGLLogger/NGLLoggerBootstrap.h>
+
 using namespace NGL;

 namespace TrainingAreaBaseOC
@@ -62,7 +62,7 @@ bool DdsHandler::init(const QStringList &qosFileList)

 qint64 DdsHandler::currentPartitionTime() const
 {
-  return m_dtcCore->partitionTime().timeStamp();
+  return m_dtcCore->partitionTime().timeStamp;
 }

 } // Namespace PDM
@@ -6,7 +6,9 @@
 #include <utility>
 #include <QtCore/QPointF>

-#include <LtsUtils/qbytearray_byteaccess.h>
+#include <LtsUtilsCore/qbytearray_byteaccess.h>
+
+#include <NGLLogger/NGLLoggerBootstrap.h>

 #include "handler_aes_data.h"
 #include "settings.h"
@@ -33,6 +35,7 @@ HandlerAesData::HandlerAesData(const std::shared_ptr<DdsHandler> &dds,
    , m_aesFtc(aesFtc)
    , m_pdmDtc(pdmDtc)
    , m_utmCoord(LtsCoordTrans::UtmCoordinate::fromMgrs(Settings::baseCoord()))
+    , m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger())
 {
 }

@@ -262,28 +265,28 @@ template <typename T> static inline void getBasicData(const QByteArray &data, si
  uint64_t tmp;

  LtsUtils::get2Byte(data, pos, tmp);
-  req.id(tmp);
-  req.name(data.mid(pos, 8).toStdString());
-  QString name = QString::fromStdString(req.name());
+  req.id = tmp;
+  req.name = data.mid(pos, 8).toStdString();
+  QString name = QString::fromStdString(req.name);

  name = name.replace(QRegularExpression(QStringLiteral("[^ -~]")), QLatin1String(""));
  name = name.trimmed();
  if (!name.isEmpty())
-    req.name(name.toStdString());
+    req.name = name.toStdString();

  pos += 8;
  LtsUtils::get1Byte(data, pos, tmp);
  if (tmp != 0)
-    req.partyId(dds::core::optional<int32_t>(tmp));
+    req.partyId = dds::core::optional<int32_t>(tmp);
  else
-    req.partyId(dds::core::optional<int32_t>());
+    req.partyId = dds::core::optional<int32_t>();
  if (!withoutEffectStart)
  {
    LtsUtils::get4Byte(data, pos, tmp);
    if (tmp != 0)
-      req.effectStart(dds::core::optional<rti::core::int64>(tmp * 1000));
+      req.effectStart = dds::core::optional<rti::core::int64>(tmp * 1000);
    else
-      req.effectStart(dds::core::optional<rti::core::int64>());
+      req.effectStart = dds::core::optional<rti::core::int64>();
  }
 }

@@ -310,7 +313,7 @@ void HandlerAesData::bcContaminations(const QByteArray &data)
  LtsUtils::get1Byte(data, pos, cnt);

  AreaEffectSimulation::BCContaminationModifyRequest req;
-  req.weatherSource(AreaEffectSimulation::AesWeatherSource::AwsNoUpdate);
+  req.weatherSource = AreaEffectSimulation::AesWeatherSource::AwsNoUpdate;
  uint64_t tmp;
  int x = 0, y = 0;

@@ -318,41 +321,41 @@ void HandlerAesData::bcContaminations(const QByteArray &data)
  {
    getBasicData(data, pos, req);
    LtsUtils::get1Byte(data, pos, tmp);
-    req.effectDuration(tmp * 60 * 1000);
-    LtsUtils::get3Byte(data, pos, y); 
-    LtsUtils::get3Byte(data, pos, x); 
-    req.impactPosition(relativeToGeoPosition(x, y));
+    req.effectDuration = tmp * 60 * 1000;
+    LtsUtils::get3Byte(data, pos, y);
+    LtsUtils::get3Byte(data, pos, x);
+    req.impactPosition = relativeToGeoPosition(x, y);
    LtsUtils::get2Byte(data, pos, tmp);
-    req.impactRadius(tmp);
-    LtsUtils::get1Byte(data, pos, tmp);                                                   
-    LtsUtils::get2Byte(data, pos, tmp);                                                   
-    req.propagationDirection(dds::core::optional<double>(compassToMathAngleForSfm(tmp))); 
-    LtsUtils::get1Byte(data, pos, tmp);                                                   
-    req.windSpeed(dds::core::optional<double>(tmp));
-    LtsUtils::get4Byte(data, pos, tmp);                                      
-    req.weatherTimestamp(dds::core::optional<rti::core::int64>(tmp * 1000)); 
-    LtsUtils::get3Byte(data, pos, y);                                        
-    LtsUtils::get3Byte(data, pos, x);                                        
-    req.weatherPosition(dds::core::optional<Core::GeoPosition2D>(relativeToGeoPosition(x, y)));
+    req.impactRadius = tmp;
+    LtsUtils::get1Byte(data, pos, tmp);
+    LtsUtils::get2Byte(data, pos, tmp);
+    req.propagationDirection = dds::core::optional<double>(compassToMathAngleForSfm(tmp));
+    LtsUtils::get1Byte(data, pos, tmp);
+    req.windSpeed = dds::core::optional<double>(tmp);
+    LtsUtils::get4Byte(data, pos, tmp);
+    req.weatherTimestamp = dds::core::optional<rti::core::int64>(tmp * 1000);
+    LtsUtils::get3Byte(data, pos, y);
+    LtsUtils::get3Byte(data, pos, x);
+    req.weatherPosition = dds::core::optional<Core::GeoPosition2D>(relativeToGeoPosition(x, y));
+    LtsUtils::get1Byte(data, pos, tmp);
+    req.chargeTypeId = chargeTypeIdFromChargeTasCode(ProjectDataManagement::GearClass::GearClass_Chemical, tmp);
+    if (req.chargeTypeId == 0)
+      req.chargeTypeId = chargeTypeIdFromChargeTasCode(ProjectDataManagement::GearClass::GearClass_Biological, tmp);
    LtsUtils::get1Byte(data, pos, tmp);
-    req.chargeTypeId(chargeTypeIdFromChargeTasCode(ProjectDataManagement::GearClass::Chemical, tmp));
-    if (req.chargeTypeId() == 0)
-      req.chargeTypeId(chargeTypeIdFromChargeTasCode(ProjectDataManagement::GearClass::Biological, tmp));
-    LtsUtils::get1Byte(data, pos, tmp); 

-    DEBUG_LOG(m_logger) << (aesToBeDeleted.contains(req.id()) ? "Modifying " : "Creating ") << "BC contamination: " << req;
+    DEBUG_LOG(m_logger) << (aesToBeDeleted.contains(req.id) ? "Modifying " : "Creating ") << "BC contamination: " << req;

-    aesToBeDeleted.removeAll(req.id()); 
-    req.id(req.id() * -1);              
+    aesToBeDeleted.removeAll(req.id);
+    req.id = req.id * -1;

    m_aesFtc->bCContaminationModifyRequest(req, this);
  }

  for (int id : std::as_const(aesToBeDeleted))
  {
-    if (m_aesDtc->bCContamination(id).isCentral())
+    if (m_aesDtc->bCContamination(id).isCentral)
      continue;
-    if (m_aesDtc->bCContamination(id).effectStateId().underlying() > AreaEffectSimulation::AesEffectState::EsRemoved)
+    if (m_aesDtc->bCContamination(id).effectStateId > AreaEffectSimulation::AesEffectState::EsRemoved)
    {
      DEBUG_LOG(m_logger) << "Removing BC contamination id: " << id;
      m_aesFtc->bCContaminationRemoveRequest(Core::RemoveElementRequest(id), this);
@@ -377,78 +380,78 @@ void HandlerAesData::explosionAreas(const QByteArray &data)

  for (int i = 0; i < cnt; ++i)
  {
-    
-    LtsUtils::get2Byte(data, pos, tmp); 
-    req.id(tmp);

-    req.name(data.mid(pos, 8).toStdString()); 
-    QString name = QString::fromStdString(req.name());
-    
+    LtsUtils::get2Byte(data, pos, tmp);
+    req.id = tmp;
+
+    req.name = data.mid(pos, 8).toStdString();
+    QString name = QString::fromStdString(req.name);
+
    name = name.replace(QRegularExpression(QStringLiteral("[^ -~]")), QLatin1String(""));
    name = name.trimmed();
    if (!name.isEmpty())
-      req.name(name.toStdString());
+      req.name = name.toStdString();

    pos += 8;
-    LtsUtils::get1Byte(data, pos, tmp); 
-    req.partyId(tmp);
-
-    LtsUtils::get4Byte(data, pos, tmp); 
-    req.effectStart(tmp * 1000);
-
-    LtsUtils::get2Byte(data, pos, tmp); 
-    req.effectDuration(tmp * 1000);
-
-    
-    AreaEffectSimulation::Area area;
-    LtsUtils::get3Byte(data, pos, y); 
-    LtsUtils::get3Byte(data, pos, x); 
-    area.cornerBottomLeft(relativeToGeoPosition(x, y));
    LtsUtils::get1Byte(data, pos, tmp);
-    area.width(tmp * 5);
-    LtsUtils::get1Byte(data, pos, tmp);
-    area.height(tmp * 5);
+    req.partyId = tmp;
+
+    LtsUtils::get4Byte(data, pos, tmp);
+    req.effectStart = tmp * 1000;
+
    LtsUtils::get2Byte(data, pos, tmp);
-    area.rotation(mathToCompassAngle(tmp + 9000)); 
-    req.area(area);
+    req.effectDuration = tmp * 1000;

-    LtsUtils::get2Byte(data, pos, tmp); 

-    LtsUtils::get2Byte(data, pos, tmp);              
-    req.mhpRotation(mathToCompassAngle(tmp + 9000)); 
+    AreaEffectSimulation::Area area;
+    LtsUtils::get3Byte(data, pos, y);
+    LtsUtils::get3Byte(data, pos, x);
+    area.cornerBottomLeft = relativeToGeoPosition(x, y);
+    LtsUtils::get1Byte(data, pos, tmp);
+    area.width = tmp * 5;
+    LtsUtils::get1Byte(data, pos, tmp);
+    area.height = tmp * 5;
+    LtsUtils::get2Byte(data, pos, tmp);
+    area.rotation = mathToCompassAngle(tmp + 9000);
+    req.area = area;

-    LtsUtils::get2Byte(data, pos, tmp); 
-    req.impactCount(tmp);
+    LtsUtils::get2Byte(data, pos, tmp);

-    LtsUtils::get2Byte(data, pos, tmp); 
+    LtsUtils::get2Byte(data, pos, tmp);
+    req.mhpRotation = mathToCompassAngle(tmp + 9000);

-    LtsUtils::get1Byte(data, pos, tmp); 
-    req.chargeStruct().chargeTypeId(chargeTypeIdFromChargeTasCode(ProjectDataManagement::GearClass::Artillery, tmp));
-    if (req.chargeStruct().chargeTypeId() == 0)
-      req.chargeStruct().chargeTypeId(chargeTypeIdFromChargeTasCode(ProjectDataManagement::GearClass::Mortar, tmp));
-    if (req.chargeStruct().chargeTypeId() == 0)
-      req.chargeStruct().chargeTypeId(chargeTypeIdFromChargeTasCode(ProjectDataManagement::GearClass::AirSupport, tmp));
+    LtsUtils::get2Byte(data, pos, tmp);
+    req.impactCount = tmp;

-    LtsUtils::get2Byte(data, pos, tmp); 
+    LtsUtils::get2Byte(data, pos, tmp);

-    LtsUtils::get1Byte(data, pos, tmp); 
-    req.mhpCount(tmp);
+    LtsUtils::get1Byte(data, pos, tmp);
+    req.chargeStruct.chargeTypeId = chargeTypeIdFromChargeTasCode(ProjectDataManagement::GearClass::GearClass_Artillery, tmp);
+    if (req.chargeStruct.chargeTypeId == 0)
+      req.chargeStruct.chargeTypeId = chargeTypeIdFromChargeTasCode(ProjectDataManagement::GearClass::GearClass_Mortar, tmp);
+    if (req.chargeStruct.chargeTypeId == 0)
+      req.chargeStruct.chargeTypeId = chargeTypeIdFromChargeTasCode(ProjectDataManagement::GearClass::GearClass_AirSupport, tmp);

-    
-    for (int32_t mhpCounter = 0; mhpCounter < req.mhpCount(); ++mhpCounter)
+    LtsUtils::get2Byte(data, pos, tmp);
+
+    LtsUtils::get1Byte(data, pos, tmp);
+    req.mhpCount = tmp;
+
+
+    for (int32_t mhpCounter = 0; mhpCounter < req.mhpCount; ++mhpCounter)
    {
      LtsUtils::get3Byte(data, pos, tmp);
      LtsUtils::get3Byte(data, pos, tmp);
    }

    DEBUG_LOG(m_logger) << "New ExplosionClusterOcModifyRequest: "
-                        << "\nid:" << req.id() << "\nname:" << req.name() << "\neffectStart:" << req.effectStart() << "\neffectDuration:" << req.effectDuration()
-                        << "\narea:" << req.area() << "\nmhpCount:" << req.mhpCount() << "\nmhpRotation:" << req.mhpRotation() << "\nimpactCount:" << req.impactCount()
-                        << "\nchargeTypeId:" << req.chargeStruct().chargeTypeId() << "\npartyId:" << req.partyId();
+                        << "\nid:" << req.id << "\nname:" << req.name << "\neffectStart:" << req.effectStart << "\neffectDuration:" << req.effectDuration
+                        << "\narea:" << req.area << "\nmhpCount:" << req.mhpCount << "\nmhpRotation:" << req.mhpRotation << "\nimpactCount:" << req.impactCount
+                        << "\nchargeTypeId:" << req.chargeStruct.chargeTypeId << "\npartyId:" << req.partyId;

-    DEBUG_LOG(m_logger) << (aesToBeDeleted.contains(req.id()) ? "Modifying " : "Creating ") << "explosion cluster: " << req;
-    aesToBeDeleted.removeOne(req.id()); 
-    req.id(req.id() * -1);              
+    DEBUG_LOG(m_logger) << (aesToBeDeleted.contains(req.id) ? "Modifying " : "Creating ") << "explosion cluster: " << req;
+    aesToBeDeleted.removeOne(req.id);
+    req.id = req.id * -1;

    m_aesFtc->explosionClusterOcModifyRequest(req, this);
  }
@@ -457,14 +460,14 @@ void HandlerAesData::explosionAreas(const QByteArray &data)
  {
    const AreaEffectSimulation::ExplosionCluster &exp = m_aesDtc->explosionCluster(id);

-    if (exp.isCentral())
+    if (exp.isCentral)
      continue;

-    if ((exp.effectStateId().underlying() >= AreaEffectSimulation::AesEffectState::EsPrepared)
-        || ((exp.effectStateId().underlying() >= AreaEffectSimulation::AesEffectState::EsActivated)
-            && (((exp.effectStart().is_set() && ((exp.effectStart().get() + exp.effectDuration())) < (m_dds->currentPartitionTime() - 5000)))
-                ||                                                                                      
-                (exp.effectStateId().underlying() == AreaEffectSimulation::AesEffectState::EsPaused)))) 
+    if ((exp.effectStateId >= AreaEffectSimulation::AesEffectState::EsPrepared)
+        || ((exp.effectStateId >= AreaEffectSimulation::AesEffectState::EsActivated)
+            && (((exp.effectStart.is_set() && ((exp.effectStart.get() + exp.effectDuration)) < (m_dds->currentPartitionTime() - 5000)))
+                ||
+                (exp.effectStateId == AreaEffectSimulation::AesEffectState::EsPaused))))
    {
      DEBUG_LOG(m_logger) << "Removing explosion cluster with id: " << id;
      m_aesFtc->explosionClusterRemoveRequest(Core::RemoveElementRequest(id), this);
@@ -491,31 +494,31 @@ void HandlerAesData::explosionSingles(const QByteArray &data)
  {
    getBasicData(data, pos, req);

-    LtsUtils::get3Byte(data, pos, y); 
-    LtsUtils::get3Byte(data, pos, x); 
-    req.impactPosition(relativeToGeoPosition(x, y));
+    LtsUtils::get3Byte(data, pos, y);
+    LtsUtils::get3Byte(data, pos, x);
+    req.impactPosition = relativeToGeoPosition(x, y);
    if (m_use2BytesForSingleFireDiameter)
-      LtsUtils::get2Byte(data, pos, tmp); 
+      LtsUtils::get2Byte(data, pos, tmp);
    else
-      LtsUtils::get1Byte(data, pos, tmp); 
+      LtsUtils::get1Byte(data, pos, tmp);
    LtsUtils::get1Byte(data, pos, tmp);
-    req.chargeTypeId(chargeTypeIdFromChargeTasCode(ProjectDataManagement::GearClass::Artillery, tmp));
-    if (req.chargeTypeId() == 0)
-      req.chargeTypeId(chargeTypeIdFromChargeTasCode(ProjectDataManagement::GearClass::Mortar, tmp));
-    DEBUG_LOG(m_logger) << (aesToBeDeleted.contains(req.id()) ? "Modifying " : "Creating ") << "explosion single: " << req;
+    req.chargeTypeId = chargeTypeIdFromChargeTasCode(ProjectDataManagement::GearClass::GearClass_Artillery, tmp);
+    if (req.chargeTypeId == 0)
+      req.chargeTypeId = chargeTypeIdFromChargeTasCode(ProjectDataManagement::GearClass::GearClass_Mortar, tmp);
+    DEBUG_LOG(m_logger) << (aesToBeDeleted.contains(req.id) ? "Modifying " : "Creating ") << "explosion single: " << req;

-    aesToBeDeleted.removeAll(req.id()); 
-    req.id(req.id() * -1);              
+    aesToBeDeleted.removeAll(req.id);
+    req.id = req.id * -1;
    m_aesFtc->explosionSingleModifyRequest(req, this);
  }

  for (int id : std::as_const(aesToBeDeleted))
  {
    const AreaEffectSimulation::ExplosionSingle &exp = m_aesDtc->explosionSingle(id);
-    if (exp.isCentral())
+    if (exp.isCentral)
      continue;
-    if ((exp.effectStateId().underlying() > AreaEffectSimulation::AesEffectState::EsRemoved)
-        && (exp.effectStart().is_set() && (exp.effectStart().get() > (m_dds->currentPartitionTime() + 5000)))) 
+    if ((exp.effectStateId > AreaEffectSimulation::AesEffectState::EsRemoved)
+        && (exp.effectStart.is_set() && (exp.effectStart.get() > (m_dds->currentPartitionTime() + 5000))))
    {
      DEBUG_LOG(m_logger) << "Removing explosion single id: " << id;
      m_aesFtc->explosionSingleRemoveRequest(Core::RemoveElementRequest(id), this);
@@ -541,49 +544,49 @@ void HandlerAesData::functionalAreas(const QByteArray &data)
  for (int i = 0; i < cnt; ++i)
  {
    getBasicData(data, pos, req, true);
-    if (!aesToBeDeleted.contains(req.id()))                                                        
-      req.effectStart(dds::core::optional<rti::core::int64>(m_dds->currentPartitionTime() + 100)); 
+    if (!aesToBeDeleted.contains(req.id))                                                        
+      req.effectStart = dds::core::optional<rti::core::int64>(m_dds->currentPartitionTime() + 100); 

    
    AreaEffectSimulation::Area area;
    LtsUtils::get3Byte(data, pos, y); 
    LtsUtils::get3Byte(data, pos, x); 
-    area.cornerBottomLeft(relativeToGeoPosition(x, y));
+    area.cornerBottomLeft = relativeToGeoPosition(x, y);
    LtsUtils::get1Byte(data, pos, tmp);
-    area.width(tmp * 5);
+    area.width = tmp * 5;
    LtsUtils::get1Byte(data, pos, tmp);
-    area.height(tmp * 5);
-    area.rotation(0);
-    req.area(area);
+    area.height = tmp * 5;
+    area.rotation = 0;
+    req.area = area;

    
    LtsUtils::get1Byte(data, pos, tmp);
-    req.deconMode(static_cast<AreaEffectSimulation::AesOperatingMode>(tmp));
+    req.deconMode = static_cast<AreaEffectSimulation::AesOperatingMode>(tmp);
    LtsUtils::get1Byte(data, pos, tmp);
-    req.deconTime(tmp * 10 * 60 * 1000); 
+    req.deconTime = tmp * 10 * 60 * 1000;
    LtsUtils::get1Byte(data, pos, tmp);
-    req.maintMode(static_cast<AreaEffectSimulation::AesOperatingMode>(tmp));
+    req.maintMode = static_cast<AreaEffectSimulation::AesOperatingMode>(tmp);
    LtsUtils::get1Byte(data, pos, tmp);
-    req.maintTime(tmp * 10 * 60 * 1000); 
+    req.maintTime = tmp * 10 * 60 * 1000;
    LtsUtils::get1Byte(data, pos, tmp);
-    req.medicMode(static_cast<AreaEffectSimulation::AesOperatingMode>(tmp));
+    req.medicMode = static_cast<AreaEffectSimulation::AesOperatingMode>(tmp);
    LtsUtils::get1Byte(data, pos, tmp);
-    req.medicTime(tmp * 10 * 60 * 1000); 
-    req.chargeTypeId(411);               
+    req.medicTime = tmp * 10 * 60 * 1000;
+    req.chargeTypeId = 411;

-    DEBUG_LOG(m_logger) << (aesToBeDeleted.contains(req.id()) ? "Modifying " : "Creating ") << "functional area: " << req;
+    DEBUG_LOG(m_logger) << (aesToBeDeleted.contains(req.id) ? "Modifying " : "Creating ") << "functional area: " << req;

-    aesToBeDeleted.removeAll(req.id()); 
-    req.id(req.id() * -1);              
+    aesToBeDeleted.removeAll(req.id);
+    req.id = req.id * -1;

    m_aesFtc->functionalAreaModifyRequest(req, this);
  }

  for (int id : std::as_const(aesToBeDeleted))
  {
-    if (m_aesDtc->functionalArea(id).isCentral())
+    if (m_aesDtc->functionalArea(id).isCentral)
      continue;
-    if (m_aesDtc->functionalArea(id).effectStateId().underlying() > AreaEffectSimulation::AesEffectState::EsRemoved)
+    if (m_aesDtc->functionalArea(id).effectStateId > AreaEffectSimulation::AesEffectState::EsRemoved)
    {
      DEBUG_LOG(m_logger) << "Removing functional area id: " << id;
      m_aesFtc->functionalAreaRemoveRequest(Core::RemoveElementRequest(id), this);
@@ -611,36 +614,36 @@ void HandlerAesData::nContaminations(const QByteArray &data)
    getBasicData(data, pos, req);

    LtsUtils::get2Byte(data, pos, tmp);
-    req.effectDuration(tmp * 6 * 60 * 1000);
-    LtsUtils::get3Byte(data, pos, y); 
-    LtsUtils::get3Byte(data, pos, x); 
-    req.impactPosition(relativeToGeoPosition(x, y));
+    req.effectDuration = tmp * 6 * 60 * 1000;
+    LtsUtils::get3Byte(data, pos, y);
+    LtsUtils::get3Byte(data, pos, x);
+    req.impactPosition = relativeToGeoPosition(x, y);
    LtsUtils::get2Byte(data, pos, tmp);
-    req.impactRadius(tmp);
+    req.impactRadius = tmp;
    LtsUtils::get2Byte(data, pos, tmp);
-    req.borderLengthInner(tmp);
+    req.borderLengthInner = tmp;
    LtsUtils::get2Byte(data, pos, tmp);
-    req.borderLengthOuter(tmp);
+    req.borderLengthOuter = tmp;
    LtsUtils::get2Byte(data, pos, tmp);
-    req.spanAngle(tmp / 100.0);
+    req.spanAngle = tmp / 100.0;
    LtsUtils::get2Byte(data, pos, tmp);
-    req.rotationAngle(mathToCompassAngle(tmp));
+    req.rotationAngle = mathToCompassAngle(tmp);

-    req.chargeTypeId(chargeTypeIdFromChargeTasCode(ProjectDataManagement::GearClass::Nuclear, 1));
+    req.chargeTypeId = chargeTypeIdFromChargeTasCode(ProjectDataManagement::GearClass::GearClass_Nuclear, 1);

-    DEBUG_LOG(m_logger) << (aesToBeDeleted.contains(req.id()) ? "Modifying " : "Creating ") << "N contamination: " << req;
+    DEBUG_LOG(m_logger) << (aesToBeDeleted.contains(req.id) ? "Modifying " : "Creating ") << "N contamination: " << req;

-    aesToBeDeleted.removeAll(req.id()); 
-    req.id(req.id() * -1);              
+    aesToBeDeleted.removeAll(req.id);
+    req.id = req.id * -1;

    m_aesFtc->nContaminationModifyRequest(req, this);
  }

  for (int id : std::as_const(aesToBeDeleted))
  {
-    if (m_aesDtc->nContamination(id).isCentral())
+    if (m_aesDtc->nContamination(id).isCentral)
      continue;
-    if (m_aesDtc->nContamination(id).effectStateId().underlying() > AreaEffectSimulation::AesEffectState::EsRemoved)
+    if (m_aesDtc->nContamination(id).effectStateId > AreaEffectSimulation::AesEffectState::EsRemoved)
    {
      DEBUG_LOG(m_logger) << "Removing N contamination id: " << id;
      m_aesFtc->nContaminationRemoveRequest(Core::RemoveElementRequest(id), this);
@@ -668,52 +671,52 @@ void HandlerAesData::mineAreas(const QByteArray &data)
    getBasicData(data, pos, req);

    LtsUtils::get1Byte(data, pos, tmp);
-    req.effectDuration(tmp * 60 * 60 * 1000); 
+    req.effectDuration = tmp * 60 * 60 * 1000; 
    LtsUtils::get1Byte(data, pos, tmp);
-    req.width(tmp);
+    req.width = tmp;
    LtsUtils::get1Byte(data, pos, tmp);
-    req.density(tmp / 100.0);
+    req.density = tmp / 100.0;

    LtsUtils::get1Byte(data, pos, tmp);
    if (217 > tmp && 210 < tmp) 
-      req.chargeStruct().chargeTypeId(chargeTypeIdFromChargeTasCode(ProjectDataManagement::GearClass::MineArea, tmp));
+      req.chargeStruct.chargeTypeId = chargeTypeIdFromChargeTasCode(ProjectDataManagement::GearClass::GearClass_MineArea, tmp);
    else 
-      req.chargeStruct().chargeTypeId(tmp);
+      req.chargeStruct.chargeTypeId = tmp;

    LtsUtils::get2Byte(data, pos, tmp); 

    
    int segmentCnt = 0;
    LtsUtils::get1Byte(data, pos, segmentCnt);
-    req.segments().resize(segmentCnt);
+    req.segments.resize(segmentCnt);

    for (int j = 0; j < segmentCnt; ++j)
    {
-      AreaEffectSimulation::MineSegment &segment = req.segments().at(j);
+      AreaEffectSimulation::MineSegment &segment = req.segments.at(j);
      LtsUtils::get3Byte(data, pos, y);
      LtsUtils::get3Byte(data, pos, x);
-      segment.positionStart(relativeToGeoPosition(x, y));
+      segment.positionStart = relativeToGeoPosition(x, y);
      LtsUtils::get3Byte(data, pos, y);
      LtsUtils::get3Byte(data, pos, x);
-      segment.positionEnd(relativeToGeoPosition(x, y));
+      segment.positionEnd = relativeToGeoPosition(x, y);
    }

-    req.isCenterLine(true);
+    req.isCenterLine = true;

-    DEBUG_LOG(m_logger) << (aesToBeDeleted.contains(req.id()) ? "Modifying " : "Creating ") << "mine area: " << req;
+    DEBUG_LOG(m_logger) << (aesToBeDeleted.contains(req.id) ? "Modifying " : "Creating ") << "mine area: " << req;

-    aesToBeDeleted.removeAll(req.id()); 
-    req.id(req.id() * -1);              
+    aesToBeDeleted.removeAll(req.id); 
+    req.id = req.id * -1;              

-    req.setMineSorted(false);
+    req.setMineSorted = false;
    m_aesFtc->mineAreaModifyFromCtaDataRequest(req, this);
  }

  for (int id : std::as_const(aesToBeDeleted))
  {
-    if (m_aesDtc->mineArea(id).isCentral())
+    if (m_aesDtc->mineArea(id).isCentral)
      continue;
-    if (m_aesDtc->mineArea(id).effectStateId().underlying() > AreaEffectSimulation::AesEffectState::EsRemoved)
+    if (m_aesDtc->mineArea(id).effectStateId > AreaEffectSimulation::AesEffectState::EsRemoved)
    {
      DEBUG_LOG(m_logger) << "Removing mine area id: " << id;
      m_aesFtc->mineAreaRemoveRequest(Core::RemoveElementRequest(id), this);
@@ -754,18 +757,18 @@ void HandlerAesData::explosionAreasResume(const QByteArray &data)
  LtsUtils::get1Byte(data, pos, cnt);
  uint64_t tmp;
  AreaEffectSimulation::ExplosionAreaPauseResumeRequest req;
-  req.resumeExecution(true);
+  req.resumeExecution = true;
  for (int i = 0; i < cnt; ++i)
  {
    LtsUtils::get2Byte(data, pos, tmp);
-    req.id(tmp);
+    req.id = tmp;
+    LtsUtils::get2Byte(data, pos, tmp);
+    req.resumeSeed = dds::core::optional<int32_t>(tmp);
    LtsUtils::get2Byte(data, pos, tmp);
-    req.resumeSeed(dds::core::optional<int32_t>(tmp));
-    LtsUtils::get2Byte(data, pos, tmp); 
    LtsUtils::get4Byte(data, pos, tmp);
-    req.timeToResume(dds::core::optional<rti::core::int64>(tmp * 1000));
+    req.timeToResume = dds::core::optional<rti::core::int64>(tmp * 1000);
    LtsUtils::get2Byte(data, pos, tmp);
-    req.remainingDuration(dds::core::optional<int32_t>(tmp));
+    req.remainingDuration = dds::core::optional<int32_t>(tmp);
    DEBUG_LOG(m_logger) << "Resuming: " << req;
    m_aesFtc->explosionAreaPauseResumeRequest(req, this);
  }
@@ -5,6 +5,8 @@
 #include "dds_handler.h"
 #include "main_handler.h"

+#include <NGLLogger/NGLLoggerBootstrap.h>
+
 namespace TrainingAreaBaseOC
 {

@@ -17,12 +19,13 @@ RecvFromDdsFts::RecvFromDdsFts(MainHandler *mainHandler)
  , m_ftsTaboc(mainHandler->dds()->ftsTaboc())
  , m_ftsTab(mainHandler->dds()->ftsTab())
  , m_txCallback(mainHandler->txHandler())
+  , m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger())
 {}

 void RecvFromDdsFts::onDemandCyclicPositionsRequest(const rti::core::SampleIdentity &cookie, const DemandCyclicPositionsRequest &request)
 {
  OcTelegrams::DemandCyclicPositions data;
-  data.cycleTime = request.cycleTime();
+  data.cycleTime = request.cycleTime;

  m_ftsTaboc->demandCyclicPositionsReply(cookie, fillFro(m_txCallback->txData(data)));
 }
@@ -36,7 +39,7 @@ void RecvFromDdsFts::onDemandSfmSelfTestRequest(const rti::core::SampleIdentity
 void RecvFromDdsFts::onSendTechnicalStateOcRequest(const rti::core::SampleIdentity &cookie, const SendTechnicalStateOcRequest &request)
 {
  OcTelegrams::TechnicalStateOc data;
-  data.errorCode = request.errorCode();
+  data.errorCode = request.errorCode;

  m_ftsTaboc->sendTechnicalStateOcReply(cookie, fillFro(m_txCallback->txData(data)));
 }
@@ -45,7 +48,7 @@ void RecvFromDdsFts::onSendOcDataRequest(const rti::core::SampleIdentity &cookie
 {
  TrainingAreaBase::TetraIcd::OpaquePayloadDataOut data;
  data.payloadType = TrainingAreaBase::TetraIcd::OpaquePayloadDataBase::Type::OC;
-  data.payload = request.payload();
+  data.payload = request.payload;

  m_ftsTab->sendOcDataReply(cookie, fillFro(m_txCallback->txData(data)));
 }
@@ -54,7 +57,7 @@ void RecvFromDdsFts::onSendFireSmokeMarkerDataRequest(const rti::core::SampleIde
 {
  TrainingAreaBase::TetraIcd::OpaquePayloadDataOut data;
  data.payloadType = TrainingAreaBase::TetraIcd::OpaquePayloadDataBase::Type::FireSmokeMarker;
-  data.payload = request.payload();
+  data.payload = request.payload;

  m_ftsTab->sendFireSmokeMarkerDataReply(cookie, fillFro(m_txCallback->txData(data)));
 }
@@ -5,6 +5,8 @@

 #include <QtCore/QPointF>

+#include <NGLLogger/NGLLoggerBootstrap.h>
+
 #include "main_handler.h"

 namespace TrainingAreaBaseOC
@@ -21,21 +23,21 @@ void SendToDds::rxData(const OcTelegrams::Display &inData)
  if (0 == inData.multiplexer)
  {
    TrainingAreaBaseOC::ShortMessage outData;
-    outData.id(m_idToSend++);
+    outData.id = m_idToSend++;

-    outData.textType(static_cast<long>(inData.textType));
-    outData.indexVbg(inData.indexVbg);
-    outData.indexVba(inData.indexVba);
-    outData.timeStamp(QDateTime::currentDateTimeUtc().toMSecsSinceEpoch());
+    outData.textType = static_cast<long>(inData.textType);
+    outData.indexVbg = inData.indexVbg;
+    outData.indexVba = inData.indexVba;
+    outData.timeStamp = QDateTime::currentDateTimeUtc().toMSecsSinceEpoch();

    m_dtsTaboc->publish(outData);
  }
  else
  {
    TrainingAreaBaseOC::FreeText outData;
-    outData.id(m_idToSend++);
-    outData.text(inData.text.data());
-    outData.timeStamp(QDateTime::currentDateTimeUtc().toMSecsSinceEpoch());
+    outData.id = m_idToSend++;
+    outData.text = inData.text.data();
+    outData.timeStamp = QDateTime::currentDateTimeUtc().toMSecsSinceEpoch();

    m_dtsTaboc->publish(outData);
  }
@@ -44,10 +46,10 @@ void SendToDds::rxData(const OcTelegrams::Display &inData)
 void SendToDds::rxData(const OcTelegrams::TimeSync &inData)
 {
  TrainingAreaBaseOC::TimeSync outData;
-  outData.id(1);
+  outData.id = 1;

-  outData.gpsTime(inData.gpsTimeMsec);
-  outData.timezone(inData.timezone);
+  outData.gpsTime = inData.gpsTimeMsec;
+  outData.timezone = inData.timezone;

  m_dtsTaboc->publish(outData);
 }
@@ -61,14 +63,14 @@ void SendToDds::rxData(const OcTelegrams::SpecificsExercise &inData)
                                                      QString::number(inData.easting).rightJustified(7, QLatin1Char('0')));

  TrainingAreaBaseOC::SpecificsExercise outData;
-  outData.id(1);
+  outData.id = 1;

-  outData.exerciseId(inData.exerciseId);
-  outData.zone(inData.zone);
-  outData.band(inData.band);
-  outData.square(inData.square.data());
-  outData.easting(inData.easting);
-  outData.northing(inData.northing);
+  outData.exerciseId = inData.exerciseId;
+  outData.zone = inData.zone;
+  outData.band = inData.band;
+  outData.square = inData.square.data();
+  outData.easting = inData.easting;
+  outData.northing = inData.northing;

  m_dtsTaboc->publish(outData);
 }
@@ -76,14 +78,14 @@ void SendToDds::rxData(const OcTelegrams::SpecificsExercise &inData)
 void SendToDds::rxData(const OcTelegrams::SpecificsEquipment &inData)
 {
  TrainingAreaBaseOC::SpecificsEquipment outData;
-  outData.id(1);
+  outData.id = 1;

-  outData.equipmentNumber(inData.equipmentNumber);
-  outData.playerType(inData.playerType);
-  outData.language(static_cast<ProjectDataManagement::LanguageConfiguration>(inData.language));
-  outData.pyrotechnics(inData.pyrotechnics);
-  outData.voiceOutput(inData.voiceOutput);
-  outData.exerciseBreak(inData.exerciseBreak);
+  outData.equipmentNumber = inData.equipmentNumber;
+  outData.playerType = inData.playerType;
+  outData.language = static_cast<ProjectDataManagement::LanguageConfiguration>(inData.language);
+  outData.pyrotechnics = inData.pyrotechnics;
+  outData.voiceOutput = inData.voiceOutput;
+  outData.exerciseBreak = inData.exerciseBreak;

  m_dtsTaboc->publish(outData);
 }
@@ -91,16 +93,16 @@ void SendToDds::rxData(const OcTelegrams::SpecificsEquipment &inData)
 void SendToDds::rxData(const OcTelegrams::TechnicalStateSfm &inData)
 {
  TrainingAreaBaseOC::TechnicalStateSfm outData;
-  outData.id(1);
+  outData.id = 1;

-  outData.sfmConnected(inData.sfmConnected);
-  outData.radioAvailable(inData.radioAvailable);
-  outData.licensed(inData.licensed);
-  outData.timeStamp(inData.gpsTimeMsec);
-  outData.batteryTest(inData.batteryTest);
-  outData.manipulationEquipment(inData.manipulationEquipment);
-  outData.manipulationSfm(inData.manipulationSfm);
-  outData.errorCode(inData.errorCode);
+  outData.sfmConnected = inData.sfmConnected;
+  outData.radioAvailable = inData.radioAvailable;
+  outData.licensed = inData.licensed;
+  outData.timeStamp = inData.gpsTimeMsec;
+  outData.batteryTest = inData.batteryTest;
+  outData.manipulationEquipment = inData.manipulationEquipment;
+  outData.manipulationSfm = inData.manipulationSfm;
+  outData.errorCode = inData.errorCode;

  m_dtsTaboc->publish(outData);
 }
@@ -108,13 +110,13 @@ void SendToDds::rxData(const OcTelegrams::TechnicalStateSfm &inData)
 void SendToDds::rxData(const OcTelegrams::EnterLeaveAes &inData)
 {
  TrainingAreaBaseOC::EnterLeaveAes outData;
-  outData.id(1);
+  outData.id = 1;

-  outData.aesId(inData.aesId);
-  outData.aesEntered(inData.aesEntered);
-  outData.abcArea(inData.nbcArea);
-  outData.chargeTypeId(inData.chargeTasCode);
-  outData.cAreaType(inData.cAreaType);
+  outData.aesId = inData.aesId;
+  outData.aesEntered = inData.aesEntered;
+  outData.abcArea = inData.nbcArea;
+  outData.chargeTypeId = inData.chargeTasCode;
+  outData.cAreaType = inData.cAreaType;

  m_dtsTaboc->publish(outData);
 }
@@ -122,17 +124,17 @@ void SendToDds::rxData(const OcTelegrams::EnterLeaveAes &inData)
 void SendToDds::rxData(const OcTelegrams::OwnPosition &inData)
 {
  TrainingAreaBaseOC::OwnPosition outData;
-  outData.id(1);
+  outData.id = 1;

-  outData.valid(inData.valid);
-  outData.timeStamp(inData.gpsTimeMsec); 
+  outData.valid = inData.valid;
+  outData.timeStamp = inData.gpsTimeMsec;
  if (inData.valid)
  {
    const QPointF point(m_utmCoord.geographic(inData.easting, inData.northing));
-    outData.position(Core::GeoPosition(point.x(), point.y(), 0));
+    outData.position = Core::GeoPosition(point.x(), point.y(), 0);
  }
  else
-    outData.position(Core::GeoPosition(nan(""), nan(""), 0));
+    outData.position = Core::GeoPosition(nan(""), nan(""), 0);

  m_dtsTaboc->publish(outData);
 }
@@ -144,8 +146,8 @@ void SendToDds::rxData(const TrainingAreaBase::TetraIcd::OpaquePayloadDataBase &
  case TrainingAreaBase::TetraIcd::OpaquePayloadDataBase::Type::OC:
  {
    TrainingAreaBase::OcData outData;
-    outData.equipmentNumber(1);
-    outData.payload(inData.payload);
+    outData.equipmentNumber = 1;
+    outData.payload = inData.payload;

    m_dtsTab->publish(outData);
    break;
@@ -153,8 +155,8 @@ void SendToDds::rxData(const TrainingAreaBase::TetraIcd::OpaquePayloadDataBase &
  case TrainingAreaBase::TetraIcd::OpaquePayloadDataBase::Type::FireSmokeMarker:
  {
    TrainingAreaBase::FireSmokeMarkerData outData;
-    outData.equipmentNumber(1);
-    outData.payload(inData.payload);
+    outData.equipmentNumber = 1;
+    outData.payload = inData.payload;

    m_dtsTab->publish(outData);
    break;
@@ -13,8 +13,7 @@ Channel::Channel(QChar channel, bool bIsBinary, QObject *parent) : QObject(paren
  , m_channel(channel)
  , m_bIsBinary(bIsBinary)
  , m_device(nullptr)
-  .getNGLLogger("SCTT.Channel")),
-    m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger()) {}
+  , m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger().getNGLLogger("SCTT.Channel")) {}

 void Channel::setDevice(Device *dev)
 {
@@ -16,8 +16,7 @@ Device::Device(QObject *parent, bool tcpMode) : QObject(parent)
  , m_restartTimer(new QTimer(this))
  , m_receiveTimeoutTimer(new QTimer(this))
  , m_tcpMode(tcpMode)
-  .getNGLLogger("TTCI.Device")),
-    m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger()) {
+  , m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger().getNGLLogger("TTCI.Device")) {
  connect(m_spQuerry, &LtsSerialPortQuerry::LtsSerialPortQuerry::connectionEstablished, this, &Device::open);
  m_spQuerry->restartQuerry();

@@ -55,7 +54,7 @@ bool Device::open()
      return false;
    }
    connect(m_socket, &QTcpSocket::readyRead, this, &Device::onDataAvailable);
-    connect(m_socket, QOverload<QAbstractSocket::SocketError>::of(&QAbstractSocket::error), this, &Device::handleError);
+    connect(m_socket, &QAbstractSocket::errorOccurred, this, &Device::handleError);
    connect(m_socket, &QTcpSocket::disconnected, this, &Device::open);
    DEBUG_LOG(m_logger) << "(Re)openend tcp destination " << m_socket->peerName() << ":" <<  Settings::portTtci();
  }
@@ -3,6 +3,8 @@

 #include "settings.h"

+#include <NGLLogger/NGLLoggerBootstrap.h>
+
 #include <QtCore/QPointF>
 #include <QtCore/QTimer>
 #include <QtCore/QJsonDocument>
@@ -22,9 +24,9 @@ WebsocketHandler::WebsocketHandler(QObject *parent, int exerciseId,
  m_tryConnectionTimer->start(10 * 1000);
  connect(m_dtcTaboc.get(), &TrainingAreaBaseOC::Interface::Dtc::specificsEquipmentChanged,
          this, [this](){
-    m_ownEquipmentId = m_dtcTaboc->specificsEquipment(1).equipmentNumber();
+    m_ownEquipmentId = m_dtcTaboc->specificsEquipment(1).equipmentNumber;
  });
-  m_ownEquipmentId = m_dtcTaboc->specificsEquipment(1).equipmentNumber();
+  m_ownEquipmentId = m_dtcTaboc->specificsEquipment(1).equipmentNumber;


  m_fetchPositionTimer = new QTimer(this);
@@ -142,23 +144,23 @@ void WebsocketHandler::onSendOwnPosition(const QString &message)
  const QJsonObject obj = doc.object().value(QStringLiteral("data")).toObject();

  TrainingAreaBaseOC::OwnPosition outData;
-  outData.id(1);
+  outData.id = 1;

  
  
  if (obj.contains(QStringLiteral("lon")) && obj.contains(QStringLiteral("lat")))
  {
    DEBUG_LOG(m_logger) << "Got message with position";
-    outData.position(Core::GeoPosition(obj.value(QStringLiteral("lon")).toDouble(),obj.value(QStringLiteral("lat")).toDouble(),obj.value(QStringLiteral("height")).toDouble()));
-    outData.timeStamp(QDateTime::currentMSecsSinceEpoch());
+    outData.position = Core::GeoPosition(obj.value(QStringLiteral("lon")).toDouble(),obj.value(QStringLiteral("lat")).toDouble(),obj.value(QStringLiteral("height")).toDouble());
+    outData.timeStamp = QDateTime::currentMSecsSinceEpoch();
    if (obj.contains(QStringLiteral("buildingId")) && obj.contains(QStringLiteral("roomId")) )
    {
-      outData.moutObjectId().set(obj.value(QStringLiteral("buildingId")).toInt());
-      outData.moutRoomId().set(obj.value(QStringLiteral("roomId")).toInt());
+      outData.moutObjectId = obj.value(QStringLiteral("buildingId")).toInt();
+      outData.moutRoomId = obj.value(QStringLiteral("roomId")).toInt();
    }
  }
  else
-    outData.position(Core::GeoPosition(nan(""), nan(""),0));
+    outData.position = Core::GeoPosition(nan(""), nan(""),0);

  m_dtsTaboc->publish(outData);

@@ -3,6 +3,7 @@

 #include "ism_handler.h"
 #include "main_handler.h"
+#include <NGLLogger/NGLLoggerBootstrap.h>

 namespace WirelessLocationSystem
 {
@@ -34,26 +35,26 @@ void IsmHandler::onMainStructureElementChanged(const InfrastructureManagement::M
  case DataModification::eAdded:
  case DataModification::eModified:
  {
-    m_mainStructureElements[data.id()] = data;
-    if (data.externalWlsId() != 0)
-      m_externalWlsId2MseId[data.externalWlsId()] = data.id();
+    m_mainStructureElements[data.id] = data;
+    if (data.externalWlsId != 0)
+      m_externalWlsId2MseId[data.externalWlsId] = data.id;
    QMap<int, int> roomNumber2roomId;
-    for (const auto &element : data.elements())
+    for (const auto &element : data.elements)
    {
-      if (element.structureElementTypeId() != InfrastructureManagement::StructureElementType::Room)
+      if (element.structureElementTypeId != InfrastructureManagement::StructureElementType::Room)
        continue;
-      roomNumber2roomId[element.mountingPointId()] = element.id();
+      roomNumber2roomId[element.mountingPointId] = element.id;
    }
-    m_mseId2RoomId[data.id()] = roomNumber2roomId;
+    m_mseId2RoomId[data.id] = roomNumber2roomId;
    break;
  }
  case DataModification::eRemoved:
  {
-    m_mainStructureElements.remove(data.id());
-    m_mseId2RoomId.remove(data.id());
+    m_mainStructureElements.remove(data.id);
+    m_mseId2RoomId.remove(data.id);
    for (auto it = m_externalWlsId2MseId.begin(); it != m_externalWlsId2MseId.end(); ++it)
    {
-      if (it.value() == data.id())
+      if (it.value() == data.id)
      {
        m_externalWlsId2MseId.erase(it);
        break;
@@ -10,6 +10,8 @@
 #include "wls_handler.h"
 #include "wls_participant_handler.h"

+#include <NGLLogger/NGLLoggerBootstrap.h>
+
 #include <LtsUtils/LtsUtilsCore/dds_vector.h>

 #include <QtCore/QJsonDocument>
@@ -13,6 +13,8 @@
 #include <QtCore/QDateTime>
 #include <web_socket_handler.h>

+#include <NGLLogger/NGLLoggerBootstrap.h>
+
 namespace WirelessLocationSystem
 {

@@ -9,6 +9,8 @@
 #include <LtsUtils/LtsUtilsCore/dds_vector.h>
 #include <LtsUtils/LtsUtilsCore/sfm_bytemessage_converter.h>

+#include <NGLLogger/NGLLoggerBootstrap.h>
+
 static constexpr qint64 s_dataCommunicationAliveTimeout = 5 * 1000;
 static constexpr int s_maxWlsRetryCount = 3;

@@ -7,6 +7,7 @@
 #include "wls_handler.h"

 #include <QtCore/QDateTime>
+#include <NGLLogger/NGLLoggerBootstrap.h>

 namespace WirelessLocationSystem
 {
@@ -269,7 +269,7 @@ bool DdsHandler::isJamming(const AreaEffectSimulation::ChargeStruct &chargeStruc

 bool DdsHandler::isDus(const AreaEffectSimulation::ChargeStruct &chargeStruct)
 {
-  const bool isDus = m_dtcPdm->mineClass(chargeStruct.chargeTypeId, chargeStruct.igniterTypeId, chargeStruct.igniterFunctionId)== AreaEffectSimulation::MineClass::Concrete;
+  const bool isDus = static_cast<AreaEffectSimulation::MineClass>(m_dtcPdm->mineClass(chargeStruct.chargeTypeId, chargeStruct.igniterTypeId, chargeStruct.igniterFunctionId)) == AreaEffectSimulation::MineClass::Concrete;
  DEBUG_LOG(m_logger) << "isDus = " << isDus;
  return isDus;
 }
@@ -113,12 +113,12 @@ void HandlerParticipant::onParticipantPositionChanged(const ParticipantManagemen
  DEBUG_LOG(m_logger) << "onParticipantPositionChanged: " << data;
  if (modType == DataModification::eRemoved)
  {
-    DEBUG_LOG(m_logger) << "m_participantsOutsideMap.remove participantId: " << data.participantId();
-    //m_participantsOutsideMap.remove(data.participantId());
+    DEBUG_LOG(m_logger) << "m_participantsOutsideMap.remove participantId: " << data.participantId;
+    //m_participantsOutsideMap.remove(data.participantId);
  }
  else
  {
-    ParticipantManagement::TypeClass typeClass = typeClassFromTypeId(data.participantTypeId());
+    ParticipantManagement::TypeClass typeClass = typeClassFromTypeId(data.participantTypeId);
    if (typeClass == ParticipantManagement::TypeClass::SupportEntity
        || typeClass == ParticipantManagement::TypeClass::SupportUnit
        || typeClass == ParticipantManagement::TypeClass::Unit
@@ -128,15 +128,15 @@ void HandlerParticipant::onParticipantPositionChanged(const ParticipantManagemen
    // [GUEZE-3102] Aufgesessene Teilnehmer bekommen den Schaden vom Fahrzeug, auf dem sie aufgesessen sind.
    if (data.mountedOn.is_set())
      return;
-    int floorId = m_handlerBuildingData->getFloorIdFromRoomId(data.roomId());
+    int floorId = m_handlerBuildingData->getFloorIdFromRoomId(data.roomId);
    int lastFloorId;
    CesParticipantData partPos(data);

    // update LtsPosition/LtsCoordinate: (created as new master, with Z, geo and utm)
    LtsCoordTrans::LtsCoordinate &ltsCoordRef = partPos.ltsCoordinate();
-    ltsCoordRef = LtsCoordTrans::LtsCoordinate(data.pos());
+    ltsCoordRef = LtsCoordTrans::LtsCoordinate(data.pos);

-    //    ltsPosRef.setGeoPosition(data.pos(), 0.0);  // hier wird 0.0 zu NaN umgewandelt ...
+    //    ltsPosRef.setGeoPosition(data.pos, 0.0);  // hier wird 0.0 zu NaN umgewandelt ...
    //    ltsPosRef.setZValueAccordingElevation(0.0); // hier wird implizit der LtsElevationManager genutzt
    //    DEBUG_LOG(m_logger) << "-   ltsPosRef: " << ltsPosRef;

@@ -145,16 +145,16 @@ void HandlerParticipant::onParticipantPositionChanged(const ParticipantManagemen


    bool lastGeoPositionValid = false;
-    auto it = m_positionsMap.find(partPos.participantId());
+    auto it = m_positionsMap.find(partPos.participantId);
    if (it != m_positionsMap.end())
    {
      const CesParticipantData &partPosOld = *it;
      lastGeoPositionValid = partPosOld.lastPositionValid;
-      lastFloorId = m_handlerBuildingData->getFloorIdFromRoomId(partPosOld.roomId());
+      lastFloorId = m_handlerBuildingData->getFloorIdFromRoomId(partPosOld.roomId);


      partPos.vulnerabilityState = partPosOld.vulnerabilityState;
-      partPos.lastGeoPosition = partPosOld.pos(); // save previous position
+      partPos.lastGeoPosition = partPosOld.pos; // save previous position
      partPos.lastPositionValid = true;
      if (floorId < 0 )
        partPos.insideBuildingValue = false;
@@ -168,21 +168,21 @@ void HandlerParticipant::onParticipantPositionChanged(const ParticipantManagemen
      INFO_LOG(m_logger) << "m_positionsMap.insert="
                         << partPos;

-      m_positionsMap.insert(data.participantId(), partPos);
+      m_positionsMap.insert(data.participantId, partPos);
    }
    //
    if (lastGeoPositionValid)
    {
      if (floorId < 0)
      {
-        partPos.buildingId(0);
-        partPos.roomId(0);
+        partPos.buildingId = 0;
+        partPos.roomId = 0;
        DEBUG_LOG(m_logger) << "emit and insert newOutdoorPosition:"
                            << partPos;
-        m_positionsMap.insert(data.participantId(), partPos);
+        m_positionsMap.insert(data.participantId, partPos);
        emit newOutdoorPosition(partPos);
        if (lastFloorId > 0)
-          emit participantLeavesBuilding(partPos.participantId());
+          emit participantLeavesBuilding(partPos.participantId);
      }
      else
      {
@@ -195,18 +195,18 @@ void HandlerParticipant::onParticipantPositionChanged(const ParticipantManagemen
    while (i.hasNext())
    {
      i.next();
-      DEBUG_LOG(m_logger) << i.key() << ": " << i.value().participantId();
+      DEBUG_LOG(m_logger) << i.key() << ": " << i.value().participantId;
    }
-    if (m_positionsCheatingMap.contains(data.participantId()))
+    if (m_positionsCheatingMap.contains(data.participantId))
    {
-      DEBUG_LOG(m_logger) << "checkCheatingPosition participantId=" << data.participantId();
-      checkCheatingPosition(data.participantId());
+      DEBUG_LOG(m_logger) << "checkCheatingPosition participantId=" << data.participantId;
+      checkCheatingPosition(data.participantId);
    }

    INFO_LOG(m_logger) << "onParticipantPositionChanged()"
-                       << " participantId; " << data.participantId()
-                       << " participantTypeId: " << data.participantTypeId()
-                       << " partyId: " << data.partyId()
+                       << " participantId; " << data.participantId
+                       << " participantTypeId: " << data.participantTypeId
+                       << " partyId: " << data.partyId
                       << " vulnerabilityState: " << partPos.vulnerabilityState
                       << " insideBuilding: " << partPos.insideBuilding();
    INFO_LOG(m_logger) << partPos;
@@ -222,24 +222,24 @@ void HandlerParticipant::onDynamicParticipantDataChanged(const ParticipantManage
  if (modType == DataModification::eRemoved)
    return;

-  CesParticipantData &participantPosition = m_positionsMap[data.participantId()];  // reference!
+  CesParticipantData &participantPosition = m_positionsMap[data.participantId];  // reference!
  // save vulnerabilityState in participantHandler
-  ProjectDataManagement::VulnerabilityState newVulnerabilityState = ProjectDataManagement::VulnerabilityState::CombatReady;
-  if (data.stateHistory().size() > 0)
+  ProjectDataManagement::VulnerabilityState newVulnerabilityState = ProjectDataManagement::VulnerabilityState::VulnerabilityState_CombatReady;
+  if (data.stateHistory.size() > 0)
  {
-    const ParticipantManagement::StateInformation &vul = ParticipantManagement::youngestStateInformation(data.stateHistory());
-    newVulnerabilityState = vul.vulnerabilityState();
-    DEBUG_LOG(m_logger) << "newVulnerabilityState" << vul.vulnerabilityState();
+    const ParticipantManagement::StateInformation &vul = ParticipantManagement::youngestStateInformation(data.stateHistory);
+    newVulnerabilityState = vul.vulnerabilityState;
+    DEBUG_LOG(m_logger) << "newVulnerabilityState" << vul.vulnerabilityState;

-    if (newVulnerabilityState == ProjectDataManagement::VulnerabilityState::CombatReady)
+    if (newVulnerabilityState == ProjectDataManagement::VulnerabilityState::VulnerabilityState_CombatReady)
    {
-      emit participantDecontaminated(participantPosition.participantId());
-      DEBUG_LOG(m_logger) << "emit participantDecontaminated id=" << participantPosition.participantId();
+      emit participantDecontaminated(participantPosition.participantId);
+      DEBUG_LOG(m_logger) << "emit participantDecontaminated id=" << participantPosition.participantId;
    }
  }
  if (participantPosition.vulnerabilityState != newVulnerabilityState)
  {
-    checkCheating(data.participantId(), participantPosition, newVulnerabilityState);
+    checkCheating(data.participantId, participantPosition, newVulnerabilityState);
    participantPosition.vulnerabilityState = newVulnerabilityState;
    emit newParticipantState(participantPosition);
  }
@@ -249,31 +249,31 @@ void HandlerParticipant::onParticipantChanged(const ParticipantManagement::Parti
 {

  // Remove Participant:
-  if (modType == DataModification::eRemoved || data.isDeleted())
+  if (modType == DataModification::eRemoved || data.isDeleted)
  {
-    DEBUG_LOG(m_logger) << "onParticipantChanged m_positionsMap.remove id=" << data.id();
-    m_participantData.remove(data.id());
-    m_positionsMap.remove(data.id());
+    DEBUG_LOG(m_logger) << "onParticipantChanged m_positionsMap.remove id=" << data.id;
+    m_participantData.remove(data.id);
+    m_positionsMap.remove(data.id);
    return;
  }

  // No OC in CES
-  ParticipantManagement::TypeClass typeClass = typeClassFromTypeId(data.typeId());
+  ParticipantManagement::TypeClass typeClass = typeClassFromTypeId(data.typeId);
  if (typeClass == ParticipantManagement::TypeClass::SupportEntity
      || typeClass == ParticipantManagement::TypeClass::SupportUnit
      || typeClass == ParticipantManagement::TypeClass::Unit
      || typeClass == ParticipantManagement::TypeClass::Unknown)
    return;
-  m_participantData[data.id()] = data;
+  m_participantData[data.id] = data;

-  CesParticipantData &pos = m_positionsMap[data.id()];
-  pos.partyId(data.partyId());
-  pos.participantId(data.id());
-  pos.participantTypeId(data.typeId());
+  CesParticipantData &pos = m_positionsMap[data.id];
+  pos.partyId = data.partyId;
+  pos.participantId = data.id;
+  pos.participantTypeId = data.typeId;
  DEBUG_LOG(m_logger) << "onParticipantChanged"
-                      << " id=" << data.id()
-                      << " typeId=" << data.typeId()
-                      << " designator=" << data.designator();
+                      << " id=" << data.id
+                      << " typeId=" << data.typeId
+                      << " designator=" << data.designator;
 }

 void HandlerParticipant::onTypeChanged(const ParticipantManagement::Type &data, DataModification modType)
@@ -281,10 +281,10 @@ void HandlerParticipant::onTypeChanged(const ParticipantManagement::Type &data,

  if (modType == DataModification::eRemoved)
    return;
-  m_typeMap.insert(data.id(), data.typeClass());
+  m_typeMap.insert(data.id, data.typeClass);
  DEBUG_LOG(m_logger) << "m_typeMap.size()" << m_typeMap.size()
-                      << "  equipmentTypeId=" << data.id()
-                      << "  typeClass=" << data.typeClass();
+                      << "  equipmentTypeId=" << data.id
+                      << "  typeClass=" << data.typeClass;
 }

 void HandlerParticipant::onRestoreRadioReadinessChanged(const TrainingAreaBase::RestoreRadioReadiness &data, DataModification modType)
@@ -296,9 +296,9 @@ void HandlerParticipant::onRestoreRadioReadinessChanged(const TrainingAreaBase::
  }

  auto dtcPpm = m_ddsHandler->dtcPpm();
-  int participantId = dtcPpm->participantIdByEquipmentNumber(data.equipmentNumber());
+  int participantId = dtcPpm->participantIdByEquipmentNumber(data.equipmentNumber);
  DEBUG_LOG(m_logger) << "onRestoreRadioReadinessChanged"
-                      << " data.equipmentNumber=" << data.equipmentNumber()
+                      << " data.equipmentNumber=" << data.equipmentNumber
                      << " participantId=" << participantId;
  emit restoreRadioReadinessChanged(participantId);
  auto partPos = m_positionsMap.value(participantId);
@@ -306,8 +306,8 @@ void HandlerParticipant::onRestoreRadioReadinessChanged(const TrainingAreaBase::
    emit newIndoorPosition(partPos);
  else
  {
-    partPos.buildingId(0);
-    partPos.roomId(0);
+    partPos.buildingId = 0;
+    partPos.roomId = 0;
    m_positionsMap.insert(participantId, partPos);
    emit newOutdoorPosition(partPos);
  }
@@ -322,9 +322,9 @@ QPolygonF HandlerParticipant::getParticipantStep(int participantId, int zone) co
    return {};
  const CesParticipantData &partPos = it.value();
  QPointF p1 = CentralEffectSimulation::geographic2Utm(partPos.lastGeoPosition, &zone);
-  QPointF p2 = CentralEffectSimulation::geographic2Utm(partPos.pos(), &zone);
+  QPointF p2 = CentralEffectSimulation::geographic2Utm(partPos.pos, &zone);

-  //return {CentralEffectSimulation::geographic2Utm(partPos.lastGeoPosition, &zone), CentralEffectSimulation::geographic2Utm(partPos.pos(), &zone)};
+  //return {CentralEffectSimulation::geographic2Utm(partPos.lastGeoPosition, &zone), CentralEffectSimulation::geographic2Utm(partPos.pos, &zone)};
  result << p1 << p2 ;
  return result;
 }
@@ -336,7 +336,7 @@ QPointF HandlerParticipant::getParticipantPositionUtm(int participantId, int zon
  if (m_positionsMap.contains(participantId))
  {
    const CesParticipantData &partPos = m_positionsMap.value(participantId);
-    result  = CentralEffectSimulation::geographic2Utm(partPos.pos(), &zone);
+    result  = CentralEffectSimulation::geographic2Utm(partPos.pos, &zone);
  }
  return result;
 }
@@ -352,12 +352,12 @@ QHash<int, HandlerParticipant::CesParticipantData> HandlerParticipant::positions
  QHash<int, HandlerParticipant::CesParticipantData> result;
  for (const HandlerParticipant::CesParticipantData &pos : m_positionsMap)
  {
-    ParticipantManagement::TypeClass typeClass = typeClassFromTypeId(pos.participantTypeId());
+    ParticipantManagement::TypeClass typeClass = typeClassFromTypeId(pos.participantTypeId);
    if (typeClass != ParticipantManagement::TypeClass::Aircraft)
      continue;
-    if (!m_participantData.contains(pos.participantId()))
+    if (!m_participantData.contains(pos.participantId))
      continue;
-    result.insert(pos.participantId(), pos);
+    result.insert(pos.participantId, pos);
  }
  return result;
 }
@@ -368,10 +368,10 @@ QVector<int32_t> HandlerParticipant::getParticipantsBuilding(const int32_t build
  DEBUG_LOG(m_logger) << "getParticipantsBuilding:" << buildingId;
  for (const HandlerParticipant::CesParticipantData &pos : m_positionsMap)
  {
-    if (buildingId == pos.buildingId())
+    if (buildingId == pos.buildingId)
    {
-      DEBUG_LOG(m_logger) << "result.append " << pos.participantId();
-      result.append(pos.participantId());
+      DEBUG_LOG(m_logger) << "result.append " << pos.participantId;
+      result.append(pos.participantId);
    }
  }
  return result;
@@ -413,9 +413,9 @@ void HandlerParticipant::checkCheating(const int participantId,
 {
  DEBUG_LOG(m_logger) << "checkCheating state =" <<  newVulnerabilityState
                      << " participantId=" << participantId;
-  if (!m_typeMap.contains(participantPosition.participantTypeId()))
-    WARNING_LOG(m_logger) << "!m_typeMap.contains(" << participantPosition.participantTypeId() << ")";
-  ParticipantManagement::TypeClass typeClass =  m_typeMap[participantPosition.participantTypeId()];
+  if (!m_typeMap.contains(participantPosition.participantTypeId))
+    WARNING_LOG(m_logger) << "!m_typeMap.contains(" << participantPosition.participantTypeId << ")";
+  ParticipantManagement::TypeClass typeClass =  m_typeMap[participantPosition.participantTypeId];

  if (handleCheating(typeClass, newVulnerabilityState))
  {
@@ -449,15 +449,15 @@ void HandlerParticipant::checkCheatingPosition(const int participantId)
  }

  // Check, if valid position is available
-  if (posMobilityKill.participantId() == 0)
+  if (posMobilityKill.participantId == 0)
  {
    DEBUG_LOG(m_logger) << "position participantId=" << participantId << " not valid";
    m_positionsCheatingMap.insert(participantId, posActual);
    return;
  }

-  QPointF posUtmMobilityKill = CentralEffectSimulation::geographic2Utm(posMobilityKill.pos());
-  QPointF posUtmActual = CentralEffectSimulation::geographic2Utm(posActual.pos());
+  QPointF posUtmMobilityKill = CentralEffectSimulation::geographic2Utm(posMobilityKill.pos);
+  QPointF posUtmActual = CentralEffectSimulation::geographic2Utm(posActual.pos);
  DEBUG_LOG(m_logger) << "posUtmMobilityKill=" << posUtmMobilityKill.rx() << "/" << posUtmMobilityKill.ry();
  DEBUG_LOG(m_logger) << "posUtmActual=" << posUtmActual.rx() << "/" << posUtmActual.ry();

@@ -488,9 +488,9 @@ void HandlerParticipant::onSendParticipantBeStillWarningReply(const Core::Functi
 void HandlerParticipant::sendBeStillWarning(const int32_t participantId)
 {
  TrainingAreaBase::SendParticipantBeStillWarningRequest pba;
-  pba.equipmentNumber(m_ddsHandler->participantId2EquipNo(participantId));
-  pba.participantId(participantId);
-  pba.data(0);
+  pba.equipmentNumber = m_ddsHandler->participantId2EquipNo(participantId);
+  pba.participantId = participantId;
+  pba.data = 0;
  m_ddsHandler->ftcTab()->sendParticipantBeStillWarningRequest(pba, this);
 }

@@ -509,10 +509,10 @@ void HandlerParticipant::modifyStateRequest(
  std::vector<int32_t> participantIds;
  participantIds.push_back(participantId);
  ParticipantManagement::ModifyStateRequest msr;
-  msr.participantIds(participantIds);
-  msr.vulnerabilityState(state);
-  msr.vulnerabilityKind(kind);
-  msr.vitality(vitality);
+  msr.participantIds = participantIds;
+  msr.vulnerabilityState = state;
+  msr.vulnerabilityKind = kind;
+  msr.vitality = vitality;
  m_ddsHandler->ftcPpm()->modifyStateRequest(msr, this);
 }

@@ -520,8 +520,8 @@ long HandlerParticipant::getDirection(int originatorParticipantId, int targetPar
 {
  CesParticipantData originatorPos = m_positionsMap[originatorParticipantId];
  CesParticipantData targetPos = m_positionsMap[targetParticipantId];
-  const Core::GeoPosition2D originatorGeoPos = originatorPos.pos();
-  const Core::GeoPosition2D targetGeoPos = targetPos.pos();
+  const Core::GeoPosition2D originatorGeoPos = originatorPos.pos;
+  const Core::GeoPosition2D targetGeoPos = targetPos.pos;

  int zone = -1;

@@ -541,8 +541,8 @@ long HandlerParticipant::getDistance(int originatorParticipantId, int targetPart
 {
  CesParticipantData originatorPos = m_positionsMap[originatorParticipantId];
  CesParticipantData targetPos = m_positionsMap[targetParticipantId];
-  const Core::GeoPosition2D originatorGeoPos = originatorPos.pos();
-  const Core::GeoPosition2D targetGeoPos = targetPos.pos();
+  const Core::GeoPosition2D originatorGeoPos = originatorPos.pos;
+  const Core::GeoPosition2D targetGeoPos = targetPos.pos;

  int zone = -1;

@@ -563,8 +563,8 @@ int HandlerParticipant::getParticipantId(int equipentNumber)
  while (i.hasNext())
  {
    i.next();
-    if (i.value().equipmentNumber() == equipentNumber)
-      return i.value().id();
+    if (i.value().equipmentNumber == equipentNumber)
+      return i.value().id;
  }
  return 0;
 }
@@ -594,12 +594,12 @@ std::ostream &operator<<(std::ostream &stream,
         << ", ltsCoordinate     = " << value.ltsCoordinate()
         << ", insideWlsArea     = " << value.insideWlsArea()
         << ", insideBuilding    = " << value.insideBuilding()
-         << ", buildingId        = " << value.buildingId()
+         << ", buildingId        = " << value.buildingId
         << ", notfightMode      = " << value.notfightMode
-         << ", partyId           = " << value.partyId()
+         << ", partyId           = " << value.partyId
         << ", vulnerabilityState= " << value.vulnerabilityState
-         << ", participantTypeId = " << value.participantTypeId()
-         << ", participantId     = " << value.participantId()
+         << ", participantTypeId = " << value.participantTypeId
+         << ", participantId     = " << value.participantId
         << ")";
  return stream;
 }
@@ -40,7 +40,7 @@ bool ConnectionHandlerTcp::init()

  connect(m_socket, &QTcpSocket::readyRead, this, &ConnectionHandlerTcp::read);
  connect(m_socket, &QTcpSocket::disconnected, this, &ConnectionHandlerTcp::open);
-  connect(m_socket, QOverload<QAbstractSocket::SocketError>::of(&QAbstractSocket::error), this, &ConnectionHandlerTcp::handleError);
+  connect(m_socket, &QAbstractSocket::errorOccurred, this, &ConnectionHandlerTcp::handleError);
  connect(m_socket, &QTcpSocket::connected, this, &ConnectionHandlerTcp::connectedToSerialConverter);
  open(); //open it and start regardless

@@ -87,7 +87,7 @@ bool DdsHandler::init(const QStringList &qosFileList)

 qint64 DdsHandler::currentPartitionTime() const
 {
-  return m_dtcCore->partitionTime().timeStamp();
+  return m_dtcCore->partitionTime().timeStamp;
 }


@@ -18,10 +18,10 @@ namespace ConvertFromTab
 //=============================================================================
 RxTelegram_e isTelegram(const TrainingAreaBase::FireSmokeMarkerData &data)
 {
-  if (data.payload().size() == 0)
+  if (data.payload.size() == 0)
    return RxTelegram_e::unknown;

-  switch (data.payload().at(0))
+  switch (data.payload.at(0))
  {
  case 150: return RxTelegram_e::EffectShowOrder;
  case 155: return RxTelegram_e::RelocationOrder;
@@ -46,14 +46,14 @@ static inline Core::GeoPosition2D convertGeoPos(const QByteArray &tele, size_t &
 EffectShowOrder_t convertEffectShowOrder(const TrainingAreaBase::FireSmokeMarkerData &data)
 {
  EffectShowOrder_t effectShowOrder;
-  if (data.payload().size() == 0)
+  if (data.payload.size() == 0)
    return effectShowOrder;

-  Q_ASSERT(data.payload().size() != 48);
+  Q_ASSERT(data.payload.size() != 48);

  const QByteArray tele(QByteArray::fromRawData(
-                          reinterpret_cast<const char *>(&data.payload().at(0)),
-                          data.payload().size()));
+                          reinterpret_cast<const char *>(&data.payload.at(0)),
+                          data.payload.size()));

  size_t k = 1;
  LtsUtils::get2Byte(tele, k, effectShowOrder.idEffectShow);
@@ -93,14 +93,14 @@ EffectShowOrder_t convertEffectShowOrder(const TrainingAreaBase::FireSmokeMarker
 RelocationOrder_t convertRelocationOrder(const TrainingAreaBase::FireSmokeMarkerData &data)
 {
  RelocationOrder_t relocationOrder;
-  if (data.payload().size() == 0)
+  if (data.payload.size() == 0)
    return relocationOrder;

-  Q_ASSERT(data.payload().size() >= 7);
+  Q_ASSERT(data.payload.size() >= 7);

  const QByteArray tele(QByteArray::fromRawData(
-                          reinterpret_cast<const char *>(&data.payload().at(0)),
-                          data.payload().size()));
+                          reinterpret_cast<const char *>(&data.payload.at(0)),
+                          data.payload.size()));

  size_t k = 1;
  LtsUtils::get2Byte(tele, k, relocationOrder.idRelocation);
@@ -122,14 +122,14 @@ RelocationOrder_t convertRelocationOrder(const TrainingAreaBase::FireSmokeMarker
 int convertEffectShowStop(const TrainingAreaBase::FireSmokeMarkerData &data)
 {
  int idEffectShow = 0;
-  if (data.payload().size() == 0)
+  if (data.payload.size() == 0)
    return idEffectShow;

-  Q_ASSERT(data.payload().size() != 3);
+  Q_ASSERT(data.payload.size() != 3);

  const QByteArray tele(QByteArray::fromRawData(
-                          reinterpret_cast<const char *>(&data.payload().at(0)),
-                          data.payload().size()));
+                          reinterpret_cast<const char *>(&data.payload.at(0)),
+                          data.payload.size()));

  size_t k = 1;
  LtsUtils::get2Byte(tele, k, idEffectShow);
@@ -140,14 +140,14 @@ int convertEffectShowStop(const TrainingAreaBase::FireSmokeMarkerData &data)
 EffectShowContinue_t convertEffectShowContinue(const TrainingAreaBase::FireSmokeMarkerData &data)
 {
  EffectShowContinue_t effectShowContinue;
-  if (data.payload().size() == 0)
+  if (data.payload.size() == 0)
    return effectShowContinue;

-  Q_ASSERT(data.payload().size() != 7);
+  Q_ASSERT(data.payload.size() != 7);

  const QByteArray tele(QByteArray::fromRawData(
-                          reinterpret_cast<const char *>(&data.payload().at(0)),
-                          data.payload().size()));
+                          reinterpret_cast<const char *>(&data.payload.at(0)),
+                          data.payload.size()));

  size_t k = 1;
  LtsUtils::get2Byte(tele, k, effectShowContinue.idEffectShow);
@@ -161,14 +161,14 @@ EffectShowContinue_t convertEffectShowContinue(const TrainingAreaBase::FireSmoke
 OrderRetract_t convertOrderRetract(const TrainingAreaBase::FireSmokeMarkerData &data)
 {
  OrderRetract_t orderRetract;
-  if (data.payload().size() == 0)
+  if (data.payload.size() == 0)
    return orderRetract;

-  Q_ASSERT(data.payload().size() != 4);
+  Q_ASSERT(data.payload.size() != 4);

  const QByteArray tele(QByteArray::fromRawData(
-                          reinterpret_cast<const char *>(&data.payload().at(0)),
-                          data.payload().size()));
+                          reinterpret_cast<const char *>(&data.payload.at(0)),
+                          data.payload.size()));

  size_t k = 1;
  LtsUtils::get1Byte(tele, k, orderRetract.orderType);
@@ -179,11 +179,11 @@ OrderRetract_t convertOrderRetract(const TrainingAreaBase::FireSmokeMarkerData &
 //=============================================================================
 bool convertStatusRequest(const TrainingAreaBase::FireSmokeMarkerData &data)
 {
-  if (data.payload().size() <2)
+  if (data.payload.size() <2)
    return false;

-  Q_ASSERT(data.payload().size() != 2);
-  const std::vector<uint8_t> &tele = data.payload();
+  Q_ASSERT(data.payload.size() != 2);
+  const std::vector<uint8_t> &tele = data.payload;

  return (tele.at(1) == 154);

@@ -192,37 +192,37 @@ bool convertStatusRequest(const TrainingAreaBase::FireSmokeMarkerData &data)
 EffectShowClient::MeteoNearVehicle convertMeteoData(const TrainingAreaBase::FireSmokeMarkerData &data)
 {
  EffectShowClient::MeteoNearVehicle meteoData;
-  if (data.payload().size() == 0)
+  if (data.payload.size() == 0)
  {
-    meteoData.isValid(false);
+    meteoData.isValid = false;
    return meteoData;
  }

-  Q_ASSERT(data.payload().size() != 11);
+  Q_ASSERT(data.payload.size() != 11);

  const QByteArray tele(QByteArray::fromRawData(
-                          reinterpret_cast<const char *>(&data.payload().at(0)),
-                          data.payload().size()));
+                          reinterpret_cast<const char *>(&data.payload.at(0)),
+                          data.payload.size()));

  qint16 word = 0;

  size_t k = 1;
  LtsUtils::get2Byte(tele, k, word);
-  meteoData.temperature(double(word) / 10.0);
+  meteoData.temperature = double(word) / 10.0;

  LtsUtils::get2Byte(tele, k, word);
-  meteoData.humidity(double(word));
+  meteoData.humidity = double(word);

  LtsUtils::get2Byte(tele, k, word);
-  meteoData.pressure(double(word));
+  meteoData.pressure = double(word);

  LtsUtils::get2Byte(tele, k, word);
-  meteoData.windDirection(double(word) * 0.01);
+  meteoData.windDirection = double(word) * 0.01;

  LtsUtils::get2Byte(tele, k, word);
-  meteoData.windSpeed(double(word));
+  meteoData.windSpeed = double(word);

-  meteoData.isValid(true);
+  meteoData.isValid = true;
  return meteoData;
 }

@@ -26,7 +26,7 @@ std::vector<uint8_t> convertOrderConfirmation(const OrderConfirmation_t &orderCo
  LtsUtils::set1Byte(120, ba);
  LtsUtils::set1Byte(int(orderConfirmation.orderType), ba);
  LtsUtils::set2Byte(orderConfirmation.orderId, ba);
-  LtsUtils::set1Byte(orderConfirmation.confirmation.underlying(), ba);
+  LtsUtils::set1Byte(static_cast<int>(orderConfirmation.confirmation), ba);

  const QByteArray txt = orderConfirmation.answerText.toUtf8();
  const int len = txt.length() > 39 ? 39 : txt.length();
@@ -64,13 +64,13 @@ void HandlerFiringExplosion::setFiringClearanceDuration()
    qint64 pre = m_firingExplosionEntity.firingClearanceTime.get();
    qint64 post = pre;
    pre -= PRE_START_TIME;
-    post += m_firingExplosionEntity.duration() + POST_END_TIME; //as we already start "duration"  earlier
-    m_firingExplosionEntity.firingClearanceTime().set(pre);
-    m_firingExplosionEntity.endOfFiringClearanceTime().set(post);
-    // m_firingExplosionEntity.firingClearanceTime().set(m_firingExplosionEntity.firingClearanceTime.get() - (2 * m_firingClearanceDuration));
+    post += m_firingExplosionEntity.duration + POST_END_TIME; //as we already start "duration"  earlier
+    m_firingExplosionEntity.firingClearanceTime.set(pre);
+    m_firingExplosionEntity.endOfFiringClearanceTime.set(post);
+    // m_firingExplosionEntity.firingClearanceTime.set(m_firingExplosionEntity.firingClearanceTime.get() - (2 * m_firingClearanceDuration));
  }
  else
-    m_firingExplosionEntity.endOfFiringClearanceTime().reset();
+    m_firingExplosionEntity.endOfFiringClearanceTime.reset();

  m_mainHandler->dds()->dts()->publish(m_firingExplosionEntity);
 }
@@ -85,41 +85,41 @@ void HandlerFiringExplosion::onStartHandlerFiring(const Database::EscOrder &escO
    return;

  //we are interrupted
-  m_firingExplosionEntity.idEffectShow(escOrder.id);
-  m_firingExplosionEntity.fireEnabled(false);
-  m_firingExplosionEntity.carriedOutEnabled(false);
-  m_firingExplosionEntity.idOrder(escOrder.idOrder);
+  m_firingExplosionEntity.idEffectShow = escOrder.id;
+  m_firingExplosionEntity.fireEnabled = false;
+  m_firingExplosionEntity.carriedOutEnabled = false;
+  m_firingExplosionEntity.idOrder = escOrder.idOrder;
  if (m_isNew)
  {
-    m_firingExplosionEntity.numberOfVolley(escOrder.numOfVolley);
-    m_firingExplosionEntity.numberOfShot(escOrder.shotsPerVolley);
-    m_firingExplosionEntity.remainingVolleys(escOrder.numOfVolley);
-    m_firingExplosionEntity.remainingShots(m_firingExplosionEntity.numberOfShot());
-    DEBUG_LOG(m_logger) << "Changed number of Shots Remain: " << m_firingExplosionEntity.numberOfShot();
+    m_firingExplosionEntity.numberOfVolley = escOrder.numOfVolley;
+    m_firingExplosionEntity.numberOfShot = escOrder.shotsPerVolley;
+    m_firingExplosionEntity.remainingVolleys = escOrder.numOfVolley;
+    m_firingExplosionEntity.remainingShots = m_firingExplosionEntity.numberOfShot;
+    DEBUG_LOG(m_logger) << "Changed number of Shots Remain: " << m_firingExplosionEntity.numberOfShot;
    m_isNew = false;
  }
-  m_firingExplosionEntity.duration(escOrder.duration * 1000);
-  m_firingExplosionEntity.remainingTime(escOrder.duration * 1000); //here to avoid traffic?
+  m_firingExplosionEntity.duration = escOrder.duration * 1000;
+  m_firingExplosionEntity.remainingTime = escOrder.duration * 1000; //here to avoid traffic?
  if (escOrder.startTime > 0)
-    m_firingExplosionEntity.firingClearanceTime().set(escOrder.startTime);
+    m_firingExplosionEntity.firingClearanceTime.set(escOrder.startTime);
  else
  {
    WARNING_LOG(m_logger) << "reset clearance time";
-    m_firingExplosionEntity.firingClearanceTime().reset();
+    m_firingExplosionEntity.firingClearanceTime.reset();
  }

-  if (m_firingExplosionEntity.duration() <= 0 ||
-      m_firingExplosionEntity.numberOfShot() <= 0 ||
-      m_firingExplosionEntity.numberOfVolley() <= 0)
+  if (m_firingExplosionEntity.duration <= 0 ||
+      m_firingExplosionEntity.numberOfShot <= 0 ||
+      m_firingExplosionEntity.numberOfVolley <= 0)
  {
    WARNING_LOG(m_logger) << "Won't start Explosion ";
    return;
  }

  setFiringClearanceDuration();
-  m_mainHandler->handlerVehicle()->setExplosionParameter(m_firingExplosionEntity.remainingVolleys(),
-                                                         m_firingExplosionEntity.remainingShots(),
-                                                         m_firingExplosionEntity.remainingTime());
+  m_mainHandler->handlerVehicle()->setExplosionParameter(m_firingExplosionEntity.remainingVolleys,
+                                                         m_firingExplosionEntity.remainingShots,
+                                                         m_firingExplosionEntity.remainingTime);
 }
 //-----------------------------------------------------------------------------
 void HandlerFiringExplosion::onEndHandlerFiring(const Database::EscOrder &escOrder)
@@ -128,23 +128,23 @@ void HandlerFiringExplosion::onEndHandlerFiring(const Database::EscOrder &escOrd
  DEBUG_LOG(m_logger) << "numOfVolley: " << escOrder.numOfVolley
                      << "shotsInTotal: " << escOrder.shotsPerVolley
                      << "duration: " << escOrder.duration;
-  if (escOrder.numOfVolley < 0 || escOrder.idOrder != m_firingExplosionEntity.idOrder())
+  if (escOrder.numOfVolley < 0 || escOrder.idOrder != m_firingExplosionEntity.idOrder)
    return;

-  m_firingExplosionEntity.idEffectShow(0);
-  m_firingExplosionEntity.fireEnabled(false);
-  m_firingExplosionEntity.isActive(false);
-  m_firingExplosionEntity.idOrder(0);
-  m_firingExplosionEntity.numberOfVolley(0);
-  m_firingExplosionEntity.numberOfShot(0);
-  m_firingExplosionEntity.remainingShots(0);
-  m_firingExplosionEntity.remainingVolleys(0);
-  m_firingExplosionEntity.duration(0);
-  m_firingExplosionEntity.firingClearanceTime(dds::core::optional<rti::core::int64>());
-  m_firingExplosionEntity.endOfFiringClearanceTime(dds::core::optional<rti::core::int64>());
-  m_firingExplosionEntity.fireEnabled(false);
-  m_firingExplosionEntity.carriedOutEnabled(false);
-  m_firingExplosionEntity.remainingTime(0); //here to avoid traffic?
+  m_firingExplosionEntity.idEffectShow = 0;
+  m_firingExplosionEntity.fireEnabled = false;
+  m_firingExplosionEntity.isActive = false;
+  m_firingExplosionEntity.idOrder = 0;
+  m_firingExplosionEntity.numberOfVolley = 0;
+  m_firingExplosionEntity.numberOfShot = 0;
+  m_firingExplosionEntity.remainingShots = 0;
+  m_firingExplosionEntity.remainingVolleys = 0;
+  m_firingExplosionEntity.duration = 0;
+  m_firingExplosionEntity.firingClearanceTime = dds::core::optional<rti::core::int64>();
+  m_firingExplosionEntity.endOfFiringClearanceTime = dds::core::optional<rti::core::int64>();
+  m_firingExplosionEntity.fireEnabled = false;
+  m_firingExplosionEntity.carriedOutEnabled = false;
+  m_firingExplosionEntity.remainingTime = 0; //here to avoid traffic?
  m_mainHandler->dds()->dts()->publish(m_firingExplosionEntity);
  m_isNew = true;
  //reset effect show
@@ -153,34 +153,34 @@ void HandlerFiringExplosion::onEndHandlerFiring(const Database::EscOrder &escOrd
 //-----------------------------------------------------------------------------
 void HandlerFiringExplosion::onEffectShowStopped(qint16 idEffectShow)
 {
-  if (idEffectShow != m_firingExplosionEntity.idEffectShow())
+  if (idEffectShow != m_firingExplosionEntity.idEffectShow)
  {
-    ERROR_LOG(m_logger) << "EffectShow IDs not consistent: " << idEffectShow << " / " << m_firingExplosionEntity.idEffectShow();
+    ERROR_LOG(m_logger) << "EffectShow IDs not consistent: " << idEffectShow << " / " << m_firingExplosionEntity.idEffectShow;
    return;
  }
-  m_firingExplosionEntity.isActive(false);
+  m_firingExplosionEntity.isActive = false;
 }
 //-----------------------------------------------------------------------------
 void HandlerFiringExplosion::onEffectShowContinued(const ConvertFromTab::EffectShowContinue_t &effectShowContinue)
 {
-  if (effectShowContinue.idEffectShow != m_firingExplosionEntity.idEffectShow())
+  if (effectShowContinue.idEffectShow != m_firingExplosionEntity.idEffectShow)
  {
-    ERROR_LOG(m_logger) << "EffectShow IDs not consistent: " << effectShowContinue.idEffectShow << " / " << m_firingExplosionEntity.idEffectShow();
+    ERROR_LOG(m_logger) << "EffectShow IDs not consistent: " << effectShowContinue.idEffectShow << " / " << m_firingExplosionEntity.idEffectShow;
    return;
  }
 }
 //-----------------------------------------------------------------------------
 void HandlerFiringExplosion::onSafetyConfirmation(const SafetyConfirmation_e &safetyConfirmation)
 {
-  m_firingExplosionEntity.safetyConfirmation(safetyConfirmation);
+  m_firingExplosionEntity.safetyConfirmation = safetyConfirmation;
  if (m_lastState == SafetyConfirmation_e::SafetyConfirmed && safetyConfirmation == SafetyConfirmation_e::SafetyNotConfirmed)
    m_mainHandler->handlerVehicle()->effectShowControl(EffectShowControl_e::StopTimer);

-  if (m_lastState != safetyConfirmation && m_firingExplosionEntity.safetyConfirmation() == EffectShowClient::SafetyConfirmation_e::SafetyNotConfirmed  &&
-      m_firingExplosionEntity.isActive() && !m_firingExplosionEntity.carriedOutEnabled())
+  if (m_lastState != safetyConfirmation && m_firingExplosionEntity.safetyConfirmation == EffectShowClient::SafetyConfirmation_e::SafetyNotConfirmed  &&
+      m_firingExplosionEntity.isActive && !m_firingExplosionEntity.carriedOutEnabled)
  {
-    if (m_firingExplosionEntity.idEffectShow() > 0)
-      m_mainHandler->handlerOrder()->updateOrderWithId(m_firingExplosionEntity.idEffectShow(), QString(), EffectShowManagement::OrderConfirmation_e::InterruptExecution);
+    if (m_firingExplosionEntity.idEffectShow > 0)
+      m_mainHandler->handlerOrder()->updateOrderWithId(m_firingExplosionEntity.idEffectShow, QString(), EffectShowManagement::OrderConfirmation_e::InterruptExecution);

    onEffectShowInterrupted();
  }
@@ -191,16 +191,16 @@ void HandlerFiringExplosion::onSafetyConfirmation(const SafetyConfirmation_e &sa
 //-----------------------------------------------------------------------------
 void HandlerFiringExplosion::onReadyForExplosionFiring(bool ready)
 {
-  m_firingExplosionEntity.fireEnabled(ready);
+  m_firingExplosionEntity.fireEnabled = ready;
  m_mainHandler->dds()->dts()->publish(m_firingExplosionEntity);
 }
 //-----------------------------------------------------------------------------
 void HandlerFiringExplosion::onStatusExplosionFiring(const StatusExplosionFiring_t &statusExplosionFiring)
 {
-  m_firingExplosionEntity.remainingTime(statusExplosionFiring.remainingTime_s);
-  m_firingExplosionEntity.remainingShots(statusExplosionFiring.remainingShots);
-  m_firingExplosionEntity.carriedOutEnabled(m_firingExplosionEntity.isActive() && (m_isInterrupted || statusExplosionFiring.remainingTime_s <= 0));
-  m_firingExplosionEntity.remainingVolleys(statusExplosionFiring.remainingVolley);
+  m_firingExplosionEntity.remainingTime = statusExplosionFiring.remainingTime_s;
+  m_firingExplosionEntity.remainingShots = statusExplosionFiring.remainingShots;
+  m_firingExplosionEntity.carriedOutEnabled = m_firingExplosionEntity.isActive && (m_isInterrupted || statusExplosionFiring.remainingTime_s <= 0);
+  m_firingExplosionEntity.remainingVolleys = statusExplosionFiring.remainingVolley;
  m_mainHandler->dds()->dts()->publish(m_firingExplosionEntity);
 }

@@ -208,14 +208,14 @@ void HandlerFiringExplosion::onEffectShowStarted()
 {

  DEBUG_LOG(m_logger) << "onEffectShowStarted";
-  m_mainHandler->handlerVehicle()->setExplosionParameter(m_firingExplosionEntity.remainingVolleys(),
-                                                         m_firingExplosionEntity.remainingShots(),
-                                                         m_firingExplosionEntity.remainingTime());
+  m_mainHandler->handlerVehicle()->setExplosionParameter(m_firingExplosionEntity.remainingVolleys,
+                                                         m_firingExplosionEntity.remainingShots,
+                                                         m_firingExplosionEntity.remainingTime);

  m_isInterrupted = false;
-  m_firingExplosionEntity.isActive(true);
-  m_firingExplosionEntity.fireEnabled(false);
-  m_firingExplosionEntity.carriedOutEnabled(false);
+  m_firingExplosionEntity.isActive = true;
+  m_firingExplosionEntity.fireEnabled = false;
+  m_firingExplosionEntity.carriedOutEnabled = false;

  m_mainHandler->dds()->dts()->publish(m_firingExplosionEntity);
 }
@@ -226,7 +226,7 @@ bool HandlerFiringExplosion::onEffectShowInterrupted()
  if (m_isInterrupted == true)
    return false;

-  if (!m_firingExplosionEntity.isActive() && m_isInterrupted == false)
+  if (!m_firingExplosionEntity.isActive && m_isInterrupted == false)
  {
    DEBUG_LOG(m_logger) << "onEffectShowInterrupted is active so return";
    return false;
@@ -236,9 +236,9 @@ bool HandlerFiringExplosion::onEffectShowInterrupted()
  m_mainHandler->handlerVehicle()->effectShowControl(EffectShowControl_e::StopTimer);

  m_isInterrupted = true;
-  m_firingExplosionEntity.isActive(true);
-  m_firingExplosionEntity.fireEnabled(true);
-  m_firingExplosionEntity.carriedOutEnabled(true);
+  m_firingExplosionEntity.isActive = true;
+  m_firingExplosionEntity.fireEnabled = true;
+  m_firingExplosionEntity.carriedOutEnabled = true;
  m_mainHandler->dds()->dts()->publish(m_firingExplosionEntity);
  return true;
 }
@@ -249,53 +249,53 @@ void HandlerFiringExplosion::onManuallyExplosionRequest(const rti::core::SampleI
 {
  DEBUG_LOG(m_logger) << "onManuallyExplosionRequest ";
  //override order!
-  if (m_firingExplosionEntity.idEffectShow() == 0)
+  if (m_firingExplosionEntity.idEffectShow == 0)
  {
-    m_firingExplosionEntity.firingClearanceTime().reset();
-    m_firingExplosionEntity.endOfFiringClearanceTime().reset();
-    m_firingExplosionEntity.fireEnabled(false);
-    m_firingExplosionEntity.carriedOutEnabled(false);
+    m_firingExplosionEntity.firingClearanceTime.reset();
+    m_firingExplosionEntity.endOfFiringClearanceTime.reset();
+    m_firingExplosionEntity.fireEnabled = false;
+    m_firingExplosionEntity.carriedOutEnabled = false;
  }
  m_isInterrupted = false;
  m_mainHandler->dds()->fts()->manuallyExplosionReply(cookie, Core::FunctionReplyObject());
-  if (request.pbInterrupt())
+  if (request.pbInterrupt)
  {
    m_mainHandler->handlerVehicle()->effectShowControl(EffectShowControl_e::Stop);
    onEffectShowInterrupted();
  }
-  if (!request.pbFire() && !request.pbAbort() && !request.pbCarriedOut())
-    m_mainHandler->handlerVehicle()->setExplosionParameter(request.numberOfVolley(), request.numberOfShot(), request.duration());
+  if (!request.pbFire && !request.pbAbort && !request.pbCarriedOut)
+    m_mainHandler->handlerVehicle()->setExplosionParameter(request.numberOfVolley, request.numberOfShot, request.duration);

-  if (request.pbAbort() || request.pbCarriedOut())
+  if (request.pbAbort || request.pbCarriedOut)
  {
-    m_firingExplosionEntity.isActive(false);
-    m_firingExplosionEntity.carriedOutEnabled(false);
-    if (request.pbAbort())
+    m_firingExplosionEntity.isActive = false;
+    m_firingExplosionEntity.carriedOutEnabled = false;
+    if (request.pbAbort)
      m_mainHandler->handlerVehicle()->effectShowControl(EffectShowControl_e::Abort);
    // m_firingExplosionEntity.numberOfVolley(0);
    // m_firingExplosionEntity.numberOfShot(0);
-    m_firingExplosionEntity.remainingShots(0);
-    m_firingExplosionEntity.remainingShots(0);
-    m_firingExplosionEntity.remainingVolleys(0);
+    m_firingExplosionEntity.remainingShots = 0;
+    m_firingExplosionEntity.remainingShots = 0;
+    m_firingExplosionEntity.remainingVolleys = 0;
    // m_firingExplosionEntity.duration(0);
-    m_firingExplosionEntity.remainingTime(0);
-    m_firingExplosionEntity.firingClearanceTime().reset();
-    m_firingExplosionEntity.endOfFiringClearanceTime().reset();
+    m_firingExplosionEntity.remainingTime = 0;
+    m_firingExplosionEntity.firingClearanceTime.reset();
+    m_firingExplosionEntity.endOfFiringClearanceTime.reset();
  }
-  else if (!request.pbInterrupt())
+  else if (!request.pbInterrupt)
  {
    // m_firingExplosionEntity.idOrder(0);
-    m_firingExplosionEntity.numberOfVolley(request.numberOfVolley());
-    m_firingExplosionEntity.numberOfShot(request.numberOfShot());
-    m_firingExplosionEntity.remainingShots(request.numberOfShot());
-    m_firingExplosionEntity.remainingVolleys(request.numberOfVolley());
-    m_firingExplosionEntity.duration(request.duration());
-    m_firingExplosionEntity.remainingTime(request.duration());
+    m_firingExplosionEntity.numberOfVolley = request.numberOfVolley;
+    m_firingExplosionEntity.numberOfShot = request.numberOfShot;
+    m_firingExplosionEntity.remainingShots = request.numberOfShot;
+    m_firingExplosionEntity.remainingVolleys = request.numberOfVolley;
+    m_firingExplosionEntity.duration = request.duration;
+    m_firingExplosionEntity.remainingTime = request.duration;
  }
-  if (request.pbFire())
+  if (request.pbFire)
  {
    m_mainHandler->handlerVehicle()->recalcEverything();
-    m_firingExplosionEntity.isActive(true);
+    m_firingExplosionEntity.isActive = true;
    m_mainHandler->handlerVehicle()->effectShowControl(EffectShowControl_e::Start);
  }

@@ -42,7 +42,7 @@ public:

  void setFiringClearanceDuration();
  bool onEffectShowInterrupted();
-  int getCurrentorderId() { return m_firingExplosionEntity.idOrder(); }
+  int getCurrentorderId() { return m_firingExplosionEntity.idOrder; }
 private Q_SLOTS:
  void onStartHandlerFiring(const Database::EscOrder &escOrder);
  void onEndHandlerFiring(const Database::EscOrder &escOrder);
@@ -57,30 +57,30 @@ void HandlerFiringSmoke::setFiringClearanceDuration()
    qint64 pre = m_firingSmokeEntity.firingClearanceTime.get();
    qint64 post = pre;
    pre -= PRE_START_TIME;
-    post += m_firingSmokeEntity.duration() + POST_END_TIME;
-    m_firingSmokeEntity.firingClearanceTime().set(pre);
-    m_firingSmokeEntity.endOfFiringClearanceTime().set(post);
+    post += m_firingSmokeEntity.duration + POST_END_TIME;
+    m_firingSmokeEntity.firingClearanceTime.set(pre);
+    m_firingSmokeEntity.endOfFiringClearanceTime.set(post);
  }
  else
-    m_firingSmokeEntity.endOfFiringClearanceTime().reset();
+    m_firingSmokeEntity.endOfFiringClearanceTime.reset();

  m_mainHandler->dds()->dts()->publish(m_firingSmokeEntity);
 }
 //-----------------------------------------------------------------------------
 void HandlerFiringSmoke::onStartHandlerFiring(const Database::EscOrder &escOrder)
 {
-  m_firingSmokeEntity.idEffectShow(escOrder.idOrder);
-  m_firingSmokeEntity.lengthOfFogZone(escOrder.areaWidth);
-  m_firingSmokeEntity.duration(escOrder.duration * 1000);
-  m_firingSmokeEntity.idOrder(escOrder.id);
+  m_firingSmokeEntity.idEffectShow = escOrder.idOrder;
+  m_firingSmokeEntity.lengthOfFogZone = escOrder.areaWidth;
+  m_firingSmokeEntity.duration = escOrder.duration * 1000;
+  m_firingSmokeEntity.idOrder = escOrder.id;
  if (escOrder.startTime > 0)
-    m_firingSmokeEntity.firingClearanceTime().set(escOrder.startTime);
+    m_firingSmokeEntity.firingClearanceTime.set(escOrder.startTime);
  else
-    m_firingSmokeEntity.firingClearanceTime().reset();
+    m_firingSmokeEntity.firingClearanceTime.reset();


-  if (m_firingSmokeEntity.lengthOfFogZone() <= 0 ||
-      m_firingSmokeEntity.duration() <= 0)
+  if (m_firingSmokeEntity.lengthOfFogZone <= 0 ||
+      m_firingSmokeEntity.duration <= 0)
  {
    WARNING_LOG(m_logger) << "Won't start Smoke ";
    DEBUG_LOG(m_logger) << "areaWidth: " << escOrder.areaWidth
@@ -95,57 +95,57 @@ void HandlerFiringSmoke::onEndHandlerFiring(const Database::EscOrder &escOrder)
 {
  Q_UNUSED(escOrder)

-  m_firingSmokeEntity.remainingDistance(0);
-  m_firingSmokeEntity.remainingTime(0);
-  m_firingSmokeEntity.carriedOutEnabled(false);
-  m_firingSmokeEntity.directionOfFogZone(0);
-  m_firingSmokeEntity.endOfFiringClearanceTime().reset();
-  m_firingSmokeEntity.idOrder(0);
-  m_firingSmokeEntity.idEffectShow(0);
-  m_firingSmokeEntity.firingClearanceTime().reset();
+  m_firingSmokeEntity.remainingDistance = 0;
+  m_firingSmokeEntity.remainingTime = 0;
+  m_firingSmokeEntity.carriedOutEnabled = false;
+  m_firingSmokeEntity.directionOfFogZone = 0;
+  m_firingSmokeEntity.endOfFiringClearanceTime.reset();
+  m_firingSmokeEntity.idOrder = 0;
+  m_firingSmokeEntity.idEffectShow = 0;
+  m_firingSmokeEntity.firingClearanceTime.reset();

  m_mainHandler->dds()->dts()->publish(m_firingSmokeEntity);
 }
 //-----------------------------------------------------------------------------
 void HandlerFiringSmoke::onEffectShowStopped(qint16 idEffectShow)
 {
-  if (idEffectShow != m_firingSmokeEntity.idEffectShow())
+  if (idEffectShow != m_firingSmokeEntity.idEffectShow)
  {
-    ERROR_LOG(m_logger) << "EffectShow IDs not consistent: " << idEffectShow << " / " << m_firingSmokeEntity.idEffectShow();
+    ERROR_LOG(m_logger) << "EffectShow IDs not consistent: " << idEffectShow << " / " << m_firingSmokeEntity.idEffectShow;
    return;
  }
 }
 //-----------------------------------------------------------------------------
 void HandlerFiringSmoke::onEffectShowContinued(const ConvertFromTab::EffectShowContinue_t &effectShowContinue)
 {
-  if (effectShowContinue.idEffectShow != m_firingSmokeEntity.idEffectShow())
+  if (effectShowContinue.idEffectShow != m_firingSmokeEntity.idEffectShow)
  {
-    ERROR_LOG(m_logger) << "EffectShow IDs not consistent: " << effectShowContinue.idEffectShow << " / " << m_firingSmokeEntity.idEffectShow();
+    ERROR_LOG(m_logger) << "EffectShow IDs not consistent: " << effectShowContinue.idEffectShow << " / " << m_firingSmokeEntity.idEffectShow;
    return;
  }
 }
 //-----------------------------------------------------------------------------
 void HandlerFiringSmoke::onSafetyConfirmation(const SafetyConfirmation_e &safetyConfirmation)
 {
-  m_firingSmokeEntity.safetyConfirmation(safetyConfirmation);
+  m_firingSmokeEntity.safetyConfirmation = safetyConfirmation;

  m_mainHandler->dds()->dts()->publish(m_firingSmokeEntity);
 }
 //-----------------------------------------------------------------------------
 void HandlerFiringSmoke::onStatusSmokeFiring(const StatusSmokeFiring_t &statusSmokeFiring)
 {
-  m_firingSmokeEntity.remainingDistance(statusSmokeFiring.remainingDistance_m);
-  m_firingSmokeEntity.remainingTime(statusSmokeFiring.remainingTime_s);
-  m_firingSmokeEntity.carriedOutEnabled(statusSmokeFiring.remainingTime_s <= 0);
+  m_firingSmokeEntity.remainingDistance = statusSmokeFiring.remainingDistance_m;
+  m_firingSmokeEntity.remainingTime = statusSmokeFiring.remainingTime_s;
+  m_firingSmokeEntity.carriedOutEnabled = statusSmokeFiring.remainingTime_s <= 0;

  m_mainHandler->dds()->dts()->publish(m_firingSmokeEntity);
 }

 void HandlerFiringSmoke::setSmoking()
 {
-  if (m_firingSmokeEntity.idOrder() > 0) //send new order change into execution
+  if (m_firingSmokeEntity.idOrder > 0) //send new order change into execution
  {
-    m_mainHandler->handlerOrder()->updateOrderWithId(m_firingSmokeEntity.idOrder(), QStringLiteral(""), EffectShowManagement::OrderConfirmation_e::Execution);
+    m_mainHandler->handlerOrder()->updateOrderWithId(m_firingSmokeEntity.idOrder, QStringLiteral(""), EffectShowManagement::OrderConfirmation_e::Execution);
  }

 }
@@ -157,25 +157,25 @@ void HandlerFiringSmoke::onManuallySmokeRequest(const rti::core::SampleIdentity
  DEBUG_LOG(m_logger) << "onManuallySmokeRequest";

  //override order!
-  if (m_firingSmokeEntity.idOrder() == 0)
+  if (m_firingSmokeEntity.idOrder == 0)
  {
-    m_firingSmokeEntity.firingClearanceTime().reset();
-    m_firingSmokeEntity.endOfFiringClearanceTime().reset();
-    m_firingSmokeEntity.carriedOutEnabled(false);
+    m_firingSmokeEntity.firingClearanceTime.reset();
+    m_firingSmokeEntity.endOfFiringClearanceTime.reset();
+    m_firingSmokeEntity.carriedOutEnabled = false;
  }

-  m_firingSmokeEntity.lengthOfFogZone(request.lengthOfFogZone());
-  m_firingSmokeEntity.directionOfFogZone(request.directionOfFogZone());
-  m_firingSmokeEntity.remainingDistance(request.lengthOfFogZone());
-  m_firingSmokeEntity.duration(m_mainHandler->handlerVehicle()->burningTimeSmokeCartridge_s());
-  m_firingSmokeEntity.remainingTime(m_firingSmokeEntity.duration());
+  m_firingSmokeEntity.lengthOfFogZone = request.lengthOfFogZone;
+  m_firingSmokeEntity.directionOfFogZone = request.directionOfFogZone;
+  m_firingSmokeEntity.remainingDistance = request.lengthOfFogZone;
+  m_firingSmokeEntity.duration = m_mainHandler->handlerVehicle()->burningTimeSmokeCartridge_s();
+  m_firingSmokeEntity.remainingTime = m_firingSmokeEntity.duration;

  m_mainHandler->dds()->fts()->manuallySmokeReply(cookie, Core::FunctionReplyObject());

-  if (!request.pbAbort() && !request.pbCarriedOut())
-    m_mainHandler->handlerVehicle()->setSmokeParameter(request.lengthOfFogZone(), request.directionOfFogZone());
+  if (!request.pbAbort && !request.pbCarriedOut)
+    m_mainHandler->handlerVehicle()->setSmokeParameter(request.lengthOfFogZone, request.directionOfFogZone);

-  if (request.pbAbort())
+  if (request.pbAbort)
    m_mainHandler->handlerVehicle()->effectShowControl(EffectShowControl_e::Abort);

 }
@@ -34,7 +34,7 @@ public:
  bool init();

  void setFiringClearanceDuration();
-  int getCurrentorderId() { return m_firingSmokeEntity.idOrder(); }
+  int getCurrentorderId() { return m_firingSmokeEntity.idOrder; }
  void setSmoking();

 private Q_SLOTS:
@@ -41,7 +41,7 @@ HandlerOperatingCondition::~HandlerOperatingCondition()
 //=============================================================================
 bool HandlerOperatingCondition::init()
 {
-  m_operatingCondition.readiness(m_isOperational);
+  m_operatingCondition.readiness = m_isOperational;
  connect(m_mainHandler->handlerVehicle().get(), &HandlerVehicle::vehicleBattery,
          this, &HandlerOperatingCondition::onVehicleBattery);
  connect(m_mainHandler->handlerVehicle().get(), &HandlerVehicle::vehicleSmokeCardridgesFireStatus,
@@ -75,7 +75,7 @@ bool HandlerOperatingCondition::init()

 void HandlerOperatingCondition::onVehicleBattery(double battery)
 {
-  m_operatingCondition.batteryVoltage(battery);
+  m_operatingCondition.batteryVoltage = battery;
  if (!m_mainHandler->dds()->dts()->publish(m_operatingCondition))
    ERROR_LOG(m_logger) << "Error publishing OperatingConditionEntity-data Battery to dds";
 }
@@ -96,8 +96,8 @@ void HandlerOperatingCondition::onVehicleSmokeCardridgesFireStatus(const CardRid
  int count = numberOfSmokingCardridgesNew - numberOfSmokingCardridgesOld;
  if (count > 0)
  {
-    m_operatingCondition.ammunitionAvailable(std::max(0, m_operatingCondition.ammunitionAvailable() - count));
-    m_operatingCondition.ammunitionMagazine(std::max(0, m_operatingCondition.ammunitionMagazine() - count));
+    m_operatingCondition.ammunitionAvailable = std::max(0, m_operatingCondition.ammunitionAvailable - count);
+    m_operatingCondition.ammunitionMagazine = std::max(0, m_operatingCondition.ammunitionMagazine - count);
    //we are burning now
    ConvertToTab::VehicleStatus_t vehicleStatus;
    getVehicleStatus(vehicleStatus);
@@ -106,15 +106,15 @@ void HandlerOperatingCondition::onVehicleSmokeCardridgesFireStatus(const CardRid
  } // if

  if (fireStatus.cardrige1)
-    m_operatingCondition.smokeCartridge1(StatusSmokeCartridge_e::Smoking);
+    m_operatingCondition.smokeCartridge1 = StatusSmokeCartridge_e::Smoking;
  if (fireStatus.cardrige2)
-    m_operatingCondition.smokeCartridge2(StatusSmokeCartridge_e::Smoking);
+    m_operatingCondition.smokeCartridge2 = StatusSmokeCartridge_e::Smoking;
  if (fireStatus.cardrige3)
-    m_operatingCondition.smokeCartridge3(StatusSmokeCartridge_e::Smoking);
+    m_operatingCondition.smokeCartridge3 = StatusSmokeCartridge_e::Smoking;
  if (fireStatus.cardrige4)
-    m_operatingCondition.smokeCartridge4(StatusSmokeCartridge_e::Smoking);
+    m_operatingCondition.smokeCartridge4 = StatusSmokeCartridge_e::Smoking;
  if (fireStatus.cardrige5)
-    m_operatingCondition.smokeCartridge5(StatusSmokeCartridge_e::Smoking);
+    m_operatingCondition.smokeCartridge5 = StatusSmokeCartridge_e::Smoking;

  if (!m_mainHandler->dds()->dts()->publish(m_operatingCondition))
    ERROR_LOG(m_logger) << "Error publishing OperatingConditionEntity-data (Somoking) to dds";
@@ -124,15 +124,15 @@ void HandlerOperatingCondition::onVehicleSmokeCardridgesStatus(const CardRidges
 {
  m_readyCardridges = fireStatus;
  if (!m_smokingCardridges.cardrige1)
-    m_operatingCondition.smokeCartridge1(m_readyCardridges.cardrige1 ? StatusSmokeCartridge_e::Ready : StatusSmokeCartridge_e::NotReady);
+    m_operatingCondition.smokeCartridge1 = m_readyCardridges.cardrige1 ? StatusSmokeCartridge_e::Ready : StatusSmokeCartridge_e::NotReady;
  if (!m_smokingCardridges.cardrige2)
-    m_operatingCondition.smokeCartridge2(m_readyCardridges.cardrige2 ? StatusSmokeCartridge_e::Ready : StatusSmokeCartridge_e::NotReady);
+    m_operatingCondition.smokeCartridge2 = m_readyCardridges.cardrige2 ? StatusSmokeCartridge_e::Ready : StatusSmokeCartridge_e::NotReady;
  if (!m_smokingCardridges.cardrige3)
-    m_operatingCondition.smokeCartridge3(m_readyCardridges.cardrige3 ? StatusSmokeCartridge_e::Ready : StatusSmokeCartridge_e::NotReady);
+    m_operatingCondition.smokeCartridge3 = m_readyCardridges.cardrige3 ? StatusSmokeCartridge_e::Ready : StatusSmokeCartridge_e::NotReady;
  if (!m_smokingCardridges.cardrige4)
-    m_operatingCondition.smokeCartridge4(m_readyCardridges.cardrige4 ? StatusSmokeCartridge_e::Ready : StatusSmokeCartridge_e::NotReady);
+    m_operatingCondition.smokeCartridge4 = m_readyCardridges.cardrige4 ? StatusSmokeCartridge_e::Ready : StatusSmokeCartridge_e::NotReady;
  if (!m_smokingCardridges.cardrige5)
-    m_operatingCondition.smokeCartridge5(m_readyCardridges.cardrige5 ? StatusSmokeCartridge_e::Ready : StatusSmokeCartridge_e::NotReady);
+    m_operatingCondition.smokeCartridge5 = m_readyCardridges.cardrige5 ? StatusSmokeCartridge_e::Ready : StatusSmokeCartridge_e::NotReady;

  if (!m_mainHandler->dds()->dts()->publish(m_operatingCondition))
    ERROR_LOG(m_logger) << "Error publishing OperatingConditionEntity-data to dds";
@@ -140,21 +140,21 @@ void HandlerOperatingCondition::onVehicleSmokeCardridgesStatus(const CardRidges

 void HandlerOperatingCondition::onVehicleFireUnits(const CardRidges   &fireStatus)
 {
-  m_operatingCondition.firingUnitReadyFwdLh(fireStatus.cardrige1);
-  m_operatingCondition.firingUnitReadyFwdRh(fireStatus.cardrige2);
-  m_operatingCondition.firingUnitReadyAftRh(fireStatus.cardrige3);
-  m_operatingCondition.firingUnitReadyAftLh(fireStatus.cardrige4);
+  m_operatingCondition.firingUnitReadyFwdLh = fireStatus.cardrige1;
+  m_operatingCondition.firingUnitReadyFwdRh = fireStatus.cardrige2;
+  m_operatingCondition.firingUnitReadyAftRh = fireStatus.cardrige3;
+  m_operatingCondition.firingUnitReadyAftLh = fireStatus.cardrige4;
  if (!m_mainHandler->dds()->dts()->publish(m_operatingCondition))
    ERROR_LOG(m_logger) << "Error publishing OperatingConditionEntity-data (fireStatus) to dds";
 }

 void HandlerOperatingCondition::onVehicleErrorStatus(const CardRidges &errorStatus)
 {
-  m_operatingCondition.errorSmoke(errorStatus.cardrige1);
-  m_operatingCondition.errorFireUnit(errorStatus.cardrige2);
-  m_operatingCondition.errorPanel(errorStatus.cardrige3);
-  m_operatingCondition.errorEquipment(errorStatus.cardrige4);
-  m_operatingCondition.errorGeneral(errorStatus.cardrige5);
+  m_operatingCondition.errorSmoke = errorStatus.cardrige1;
+  m_operatingCondition.errorFireUnit = errorStatus.cardrige2;
+  m_operatingCondition.errorPanel = errorStatus.cardrige3;
+  m_operatingCondition.errorEquipment = errorStatus.cardrige4;
+  m_operatingCondition.errorGeneral = errorStatus.cardrige5;
  if (!m_mainHandler->dds()->dts()->publish(m_operatingCondition))
    ERROR_LOG(m_logger) << "Error publishing OperatingConditionEntity-data (errorStatus) to dds";

@@ -171,40 +171,40 @@ void HandlerOperatingCondition::onOperationalStatusTimeout()
 {
  DEBUG_LOG(m_logger) << "Operational status timeout. Setting operational status to: not operational.";
  m_isOperational = false;
-  m_operatingCondition.readiness(m_isOperational);
+  m_operatingCondition.readiness = m_isOperational;

  sendStatus();
 }

 bool HandlerOperatingCondition::isErrorDmf()
 {
-  return (m_operatingCondition.errorSmoke() ||
-          m_operatingCondition.errorFireUnit() ||
-          m_operatingCondition.errorPanel() ||
-          m_operatingCondition.errorEquipment() ||
-          m_operatingCondition.errorGeneral()
+  return (m_operatingCondition.errorSmoke ||
+          m_operatingCondition.errorFireUnit ||
+          m_operatingCondition.errorPanel ||
+          m_operatingCondition.errorEquipment ||
+          m_operatingCondition.errorGeneral
         );

 }

 void HandlerOperatingCondition::onConnectionToSerial()
 {
-  DEBUG_LOG(m_logger) << "Connected to Serial: send ammunition Magazine to Control Unit Count: " << m_operatingCondition.ammunitionMagazine();
-  m_mainHandler->handlerVehicle()->setAmmunitionParameter(m_operatingCondition.ammunitionMagazine());
+  DEBUG_LOG(m_logger) << "Connected to Serial: send ammunition Magazine to Control Unit Count: " << m_operatingCondition.ammunitionMagazine;
+  m_mainHandler->handlerVehicle()->setAmmunitionParameter(m_operatingCondition.ammunitionMagazine);
 }

 void HandlerOperatingCondition::onVehicleType(const EffectShowManagement::Feature_e &type)
 {
-  m_operatingCondition.vehicleFeature(type);
+  m_operatingCondition.vehicleFeature = type;
  if (!m_mainHandler->dds()->dts()->publish(m_operatingCondition))
    ERROR_LOG(m_logger) << "Error publishing OperatingConditionEntity-data (vehicle type) to dds";
 }

 void HandlerOperatingCondition::onSafetyStatus(const SafetyStatus &status)
 {
-  m_operatingCondition.temperatureWarning(status.temperaturWarning);
-  m_operatingCondition.loadingBoardWall(status.loadingBoardWall);
-  m_operatingCondition.emergencyStop(status.emergencyStop);
+  m_operatingCondition.temperatureWarning = status.temperaturWarning;
+  m_operatingCondition.loadingBoardWall = status.loadingBoardWall;
+  m_operatingCondition.emergencyStop = status.emergencyStop;

  if (!m_mainHandler->dds()->dts()->publish(m_operatingCondition))
    ERROR_LOG(m_logger) << "Error publishing OperatingConditionEntity-data (SafetyStatus) to dds";
@@ -213,7 +213,7 @@ void HandlerOperatingCondition::onSafetyStatus(const SafetyStatus &status)
 void HandlerOperatingCondition::onVehicleRoundCount(int loadedRounds)
 {
  DEBUG_LOG(m_logger) << "Got RoundCount Reply from Unit " << loadedRounds;
-  m_operatingCondition.ammunitionMagazine(loadedRounds);
+  m_operatingCondition.ammunitionMagazine = loadedRounds;
  if (!m_mainHandler->dds()->dts()->publish(m_operatingCondition))
    ERROR_LOG(m_logger) << "Error publishing OperatingConditionEntity-data (ammunition magazine) to dds";
 }
@@ -221,12 +221,12 @@ void HandlerOperatingCondition::onVehicleRoundCount(int loadedRounds)
 void HandlerOperatingCondition::onVolleyRounds(int usedRounds)
 {
  DEBUG_LOG(m_logger) << "Got used rounds " << usedRounds;
-  m_operatingCondition.ammunitionMagazine(m_operatingCondition.ammunitionMagazine() - usedRounds);
-  if (m_operatingCondition.ammunitionMagazine() < 0)
-    m_operatingCondition.ammunitionMagazine(0);
-  m_operatingCondition.ammunitionAvailable(m_operatingCondition.ammunitionAvailable() - usedRounds);
-  if (m_operatingCondition.ammunitionAvailable() < 0)
-    m_operatingCondition.ammunitionAvailable(0);
+  m_operatingCondition.ammunitionMagazine = m_operatingCondition.ammunitionMagazine - usedRounds;
+  if (m_operatingCondition.ammunitionMagazine < 0)
+    m_operatingCondition.ammunitionMagazine = 0;
+  m_operatingCondition.ammunitionAvailable = m_operatingCondition.ammunitionAvailable - usedRounds;
+  if (m_operatingCondition.ammunitionAvailable < 0)
+    m_operatingCondition.ammunitionAvailable = 0;
  if (!m_mainHandler->dds()->dts()->publish(m_operatingCondition))
    ERROR_LOG(m_logger) << "Error publishing OperatingConditionEntity-data (ammunition magazine used) to dds";
 }
@@ -240,12 +240,12 @@ void HandlerOperatingCondition::sendStatus()

 void HandlerOperatingCondition::getVehicleStatus(ConvertToTab::VehicleStatus_t &vehicleStatus)
 {
-  vehicleStatus.ammunitionAvailable = m_operatingCondition.ammunitionAvailable();
-  vehicleStatus.ammunitionMagazine = m_operatingCondition.ammunitionMagazine();
-  vehicleStatus.feature = static_cast<int>(m_operatingCondition.vehicleFeature().underlying());
-  vehicleStatus.operational = (!m_operatingCondition.errorGeneral() && m_isOperational);
+  vehicleStatus.ammunitionAvailable = m_operatingCondition.ammunitionAvailable;
+  vehicleStatus.ammunitionMagazine = m_operatingCondition.ammunitionMagazine;
+  vehicleStatus.feature = static_cast<int>(m_operatingCondition.vehicleFeature);
+  vehicleStatus.operational = (!m_operatingCondition.errorGeneral && m_isOperational);
  vehicleStatus.magazineFail = m_oldErrorState;
-  vehicleStatus.controlComputerFail = m_operatingCondition.errorPanel();
+  vehicleStatus.controlComputerFail = m_operatingCondition.errorPanel;
 }


@@ -256,20 +256,20 @@ void HandlerOperatingCondition::onSendAmmunitionRequest(const rti::core::SampleI
  DEBUG_LOG(m_logger) << "onSendAmmunitionRequest";
  //take available ammo and send excon
  //then wait for reply from unit
-  m_operatingCondition.ammunitionAvailable(request.ammunitionAvailable());
+  m_operatingCondition.ammunitionAvailable = request.ammunitionAvailable;

  m_mainHandler->dds()->fts()->sendAmmunitionReply(cookie, Core::FunctionReplyObject());

  // provision of the control computer with the equipped shots
-  m_mainHandler->handlerVehicle()->setAmmunitionParameter(request.ammunitionMagazine());
+  m_mainHandler->handlerVehicle()->setAmmunitionParameter(request.ammunitionMagazine);

  // Sending of telegram: DMF-Einsatzbereitschafts-Status to the operating application
  ConvertToTab::VehicleStatus_t vehicleStatus;
  getVehicleStatus(vehicleStatus);
-  if (vehicleStatus.feature == EffectShowManagement::Feature_e::Smoke)
+  if (vehicleStatus.feature == static_cast<int>(EffectShowManagement::Feature_e::Smoke))
  {
    //as smoke did not answer
-    vehicleStatus.ammunitionMagazine = request.ammunitionMagazine();
+    vehicleStatus.ammunitionMagazine = request.ammunitionMagazine;
  }
  m_mainHandler->handlerTabData()->vehicleStatus(vehicleStatus);
 }
@@ -277,9 +277,9 @@ void HandlerOperatingCondition::onSendAmmunitionRequest(const rti::core::SampleI
 void HandlerOperatingCondition::onSendSafetyRevokeRequest(const rti::core::SampleIdentity &cookie,
                                                          const SendSafetyRevokeRequest &request)
 {
-  DEBUG_LOG(m_logger) << "onSendSafetyRevokeRequest with " <<  request.revoke();
+  DEBUG_LOG(m_logger) << "onSendSafetyRevokeRequest with " <<  request.revoke;
  m_mainHandler->dds()->fts()->sendSafetyRevokeReply(cookie, Core::FunctionReplyObject());
-  if (request.revoke())
+  if (request.revoke)
  {
    m_mainHandler->handlerVehicle()->effectShowControl(EffectShowControl_e::StopTimer);
    m_mainHandler->handlerControlUnit()->send(CommandSignal::FT_SE_CB_SICHERHEIT_WIDERRUFEN);
@@ -293,7 +293,7 @@ void HandlerOperatingCondition::onSendReadinessRequest(const rti::core::SampleId
  DEBUG_LOG(m_logger) << "onSendReadinessRequest";
  //Confirm or Revoke Readiness
  //send to EXCON
-  m_isOperational = request.readiness();
+  m_isOperational = request.readiness;
  m_mainHandler->dds()->fts()->sendReadinessReply(cookie, Core::FunctionReplyObject());

  // Sending of telegram: DMF-Einsatzbereitschafts-Status to the operating application
@@ -303,7 +303,7 @@ void HandlerOperatingCondition::onSendReadinessRequest(const rti::core::SampleId
  m_mainHandler->handlerTabData()->vehicleStatus(vehicleStatus);

  //now change operating condition in hope that tetra worked
-  m_operatingCondition.readiness(m_isOperational);
+  m_operatingCondition.readiness = m_isOperational;
  if (!m_mainHandler->dds()->dts()->publish(m_operatingCondition))
    ERROR_LOG(m_logger) << "Error publishing OperatingConditionEntity-data readiness) to dds";

@@ -70,9 +70,9 @@ void HandlerOrder::createOrder(const ConvertFromTab::EffectShowOrder_t &effectSh
    if (it.value()->getData().idOrder == effectShowOrder.idEffectShow)
      data = it.value()->getData();
  }
-  bool sendStart = ((data.orderConfirmation == EffectShowManagement::OrderConfirmation_e::FiringReadiness) 
-    || (data.orderConfirmation == EffectShowManagement::OrderConfirmation_e::Execution) 
-    || (data.orderConfirmation == EffectShowManagement::OrderConfirmation_e::InterruptExecution));
+  bool sendStart = ((data.orderConfirmation == static_cast<int>(EffectShowManagement::OrderConfirmation_e::FiringReadiness))
+    || (data.orderConfirmation == static_cast<int>(EffectShowManagement::OrderConfirmation_e::Execution))
+    || (data.orderConfirmation == static_cast<int>(EffectShowManagement::OrderConfirmation_e::InterruptExecution)));

  data.typeOfOrder       = 1;
  data.idOrder           = effectShowOrder.idEffectShow;
@@ -80,8 +80,8 @@ void HandlerOrder::createOrder(const ConvertFromTab::EffectShowOrder_t &effectSh
  data.duration          = effectShowOrder.duration;
  if (data.duration < 5)
    data.duration = 5;
-  data.lowerLeftPosition = QPointF(effectShowOrder.lowerLeftPosition.lon(), effectShowOrder.lowerLeftPosition.lat());
-  data.centerPosition    = QPointF(effectShowOrder.centerPosition.lon(), effectShowOrder.centerPosition.lat());
+  data.lowerLeftPosition = QPointF(effectShowOrder.lowerLeftPosition.lon, effectShowOrder.lowerLeftPosition.lat);
+  data.centerPosition    = QPointF(effectShowOrder.centerPosition.lon, effectShowOrder.centerPosition.lat);
  data.areaWidth         = effectShowOrder.areaWidth;
  data.areaDepth         = effectShowOrder.areaDepth;
  data.areaRotation      = effectShowOrder.rotation;
@@ -100,13 +100,13 @@ void HandlerOrder::createOrder(const ConvertFromTab::EffectShowOrder_t &effectSh
    return;
  }
  m_orderObjMap.insert(ifs->getId(), ifs);
-  if (data.orderConfirmation == EffectShowManagement::OrderConfirmation_e::Execution && data.startTime == 0)
+  if (data.orderConfirmation == static_cast<int>(EffectShowManagement::OrderConfirmation_e::Execution) && data.startTime == 0)
  {
    m_mainHandler->handlerControlUnit()->send(CommandSignal::FT_SE_CB_SICHERHEIT_WIDERRUFEN);
    m_mainHandler->handlerControlUnit()->send(CommandSignal::FT_SE_CB_SALVE_UNTERBRECHEN);
    m_mainHandler->handlerVehicle()->effectShowControl(EffectShowControl_e::Stop);
  }
-  bool orignalIsTimeout = ((data.orderConfirmation == EffectShowManagement::OrderConfirmation_e::Execution) &&  data.startTime > 0 && (data.startTime + data.duration < QDateTime::currentMSecsSinceEpoch())) ;
+  bool orignalIsTimeout = ((data.orderConfirmation == static_cast<int>(EffectShowManagement::OrderConfirmation_e::Execution)) &&  data.startTime > 0 && (data.startTime + data.duration < QDateTime::currentMSecsSinceEpoch())) ;
  if (sendStart && !orignalIsTimeout)
    emit startHandlerFiring(data);
 }
@@ -117,8 +117,8 @@ void HandlerOrder::createOrder(const ConvertFromTab::RelocationOrder_t &relocati
  data.typeOfOrder       = 0;
  data.idOrder           = relocationOrder.idRelocation;
  data.startTime         = relocationOrder.executionTime * 1000; // s -> msec
-  data.centerPosition    = QPointF(relocationOrder.centerPosition.lon(), relocationOrder.centerPosition.lat());
-  data.orderConfirmation = EffectShowManagement::OrderConfirmation_e::WaitingForAcceptance;
+  data.centerPosition    = QPointF(relocationOrder.centerPosition.lon, relocationOrder.centerPosition.lat);
+  data.orderConfirmation = static_cast<int>(EffectShowManagement::OrderConfirmation_e::WaitingForAcceptance);
  data.info              = relocationOrder.infoText;

  ObjectOrder *ifs(new ObjectOrder(m_mainHandler, this));
@@ -148,9 +148,9 @@ void HandlerOrder::removeOrder(const ConvertFromTab::OrderRetract_t &orderRetrac
          ERROR_LOG(m_logger) << LOGFUNCTION << ret();
        else
        {
-          if (def == EffectShowManagement::OrderConfirmation_e::Execution ||
-              def == EffectShowManagement::OrderConfirmation_e::InterruptExecution ||
-              def == EffectShowManagement::OrderConfirmation_e::FiringReadiness)
+          if (def == static_cast<int>(EffectShowManagement::OrderConfirmation_e::Execution) ||
+              def == static_cast<int>(EffectShowManagement::OrderConfirmation_e::InterruptExecution) ||
+              def == static_cast<int>(EffectShowManagement::OrderConfirmation_e::FiringReadiness))
          {
            DEBUG_LOG(m_logger) << "EndFireHandler from Remove";

@@ -180,17 +180,17 @@ void HandlerOrder::sendOrderConfirmation(const ConvertToTab::OrderConfirmation_t
 void HandlerOrder::onOrderModifyRequest(const rti::core::SampleIdentity &cookie,
                                        const OrderModifyRequest &request)
 {
-  DEBUG_LOG(m_logger) << "Order: " << request.id() << " Order: " << request.orderConfirmation();
+  DEBUG_LOG(m_logger) << "Order: " << request.id << " Order: " << request.orderConfirmation;

-  if (request.id() > 0)
+  if (request.id > 0)
  {
-    ObjectOrder *ifs = m_orderObjMap.value(request.id());
+    ObjectOrder *ifs = m_orderObjMap.value(request.id);
    if (ifs == nullptr)
-      m_mainHandler->dds()->fts()->orderModifyReply(cookie, Core::FunctionReplyObject(request.id(), tr_lts("dds", "Order with id %1 not found")).arg(request.id()));
+      m_mainHandler->dds()->fts()->orderModifyReply(cookie, Core::FunctionReplyObject(request.id, tr_lts("dds", "Order with id %1 not found")).arg(request.id));
    else
    {

-      ifs->setOrderConfirmation(request.orderConfirmation().underlying());
+      ifs->setOrderConfirmation(static_cast<int>(request.orderConfirmation));
      auto ret = ifs->updateObject();
      if (ret.error())
      {
@@ -199,15 +199,15 @@ void HandlerOrder::onOrderModifyRequest(const rti::core::SampleIdentity &cookie,
        return;
      }

-      if (updateOrder(ifs, QString::fromStdString(request.answerText()), request.orderConfirmation()))
-        m_mainHandler->dds()->fts()->orderModifyReply(cookie, Core::FunctionReplyObject(request.id()));
+      if (updateOrder(ifs, QString::fromStdString(request.answerText), request.orderConfirmation))
+        m_mainHandler->dds()->fts()->orderModifyReply(cookie, Core::FunctionReplyObject(request.id));
      else
-        m_mainHandler->dds()->fts()->orderModifyReply(cookie, Core::FunctionReplyObject(request.id(), tr_lts("dds", "Order with id %1 not found")).arg(request.id()));
+        m_mainHandler->dds()->fts()->orderModifyReply(cookie, Core::FunctionReplyObject(request.id, tr_lts("dds", "Order with id %1 not found")).arg(request.id));
    }
  }
  else
  {
-    m_mainHandler->dds()->fts()->orderModifyReply(cookie, Core::FunctionReplyObject(request.id()));
+    m_mainHandler->dds()->fts()->orderModifyReply(cookie, Core::FunctionReplyObject(request.id));
    ERROR_LOG(m_logger) << "Illegal Order ID";
  }
 }
@@ -220,11 +220,11 @@ bool HandlerOrder::updateOrder(ObjectOrder *order,
  const Database::EscOrder &escOrder = order->getData();
  oc.orderId = escOrder.idOrder;
  oc.orderType = ConvertToTab::OrderType_e(escOrder.typeOfOrder);
-  oc.confirmation = orderConf.underlying();
+  oc.confirmation = orderConf;
  oc.answerText = answerText;
  sendOrderConfirmation(oc);
  ERROR_LOG(m_logger) << "Update Order " << oc.orderId << " / ";
-  switch (orderConf.underlying())
+  switch (orderConf)
  {
  case EffectShowManagement::OrderConfirmation_e::FiringReadiness:
    emit startHandlerFiring(order->getData());
@@ -252,7 +252,7 @@ bool HandlerOrder::updateOrder(ObjectOrder *order,
  case EffectShowManagement::OrderConfirmation_e::OrderCarriedOut:
  case EffectShowManagement::OrderConfirmation_e::PositionReached:
  {
-    if (orderConf.underlying() == EffectShowManagement::OrderConfirmation_e::PositionReached &&
+    if (orderConf == EffectShowManagement::OrderConfirmation_e::PositionReached &&
        oc.orderType != ConvertToTab::OrderType_e::Relocation)
      return true;
    emit endHandlerFiring(order->getData());
@@ -277,7 +277,7 @@ void HandlerOrder::updateOrderWithId(int orderId, const QString &answerText, Eff

  if (ifs == nullptr)
    return;
-  ifs->setOrderConfirmation(orderConf.underlying());
+  ifs->setOrderConfirmation(static_cast<int>(orderConf));
  auto ret = ifs->updateObject();
  if (ret.error())
    ERROR_LOG(m_logger) << "Error Updating Order " << orderId << " / ";
@@ -57,7 +57,7 @@ void HandlerTabData::orderConfirmation(const ConvertToTab::OrderConfirmation_t &
  DEBUG_LOG(m_logger) << "Trigger Sending of Order Confirmation ";
  TrainingAreaBase::SendFireSmokeMarkerDataRequest out;

-  out.payload(ConvertToTab::convertOrderConfirmation(orderConfirmation));
+  out.payload = ConvertToTab::convertOrderConfirmation(orderConfirmation);
  m_mainHandler->dds()->ftcTab()->sendFireSmokeMarkerDataRequest(out, this);

 }
@@ -67,7 +67,7 @@ void HandlerTabData::vehicleStatus(const ConvertToTab::VehicleStatus_t &vehicleS
  DEBUG_LOG(m_logger) << "Trigger Sending of Vehicle Status ";
  TrainingAreaBase::SendFireSmokeMarkerDataRequest out;

-  out.payload(ConvertToTab::convertVehicleStatus(vehicleStatus));
+  out.payload = ConvertToTab::convertVehicleStatus(vehicleStatus);
  m_mainHandler->dds()->ftcTab()->sendFireSmokeMarkerDataRequest(out, this);
 }
 //=============================================================================
@@ -84,7 +84,7 @@ void HandlerTabData::onFireSmokeMarkerDataChanged(const TrainingAreaBase::FireSm
  if (modType == DataModification::eRemoved)
    return;

-  DEBUG_LOG(m_logger) << "Got Fire Smoke Marker " << data.sampleTime();
+  DEBUG_LOG(m_logger) << "Got Fire Smoke Marker " << data.sampleTime;

  switch (ConvertFromTab::isTelegram(data))
  {
@@ -77,21 +77,21 @@ void ObjectOrder::onPublishData()

  EffectShowClient::Order ddsData;

-  ddsData.id(m_data.id);
-  ddsData.areaDepth(m_data.areaDepth);
-  ddsData.areaWidth(m_data.areaWidth);
-  ddsData.areaRotation(m_data.areaRotation);
-  ddsData.duration(m_data.duration);
-  ddsData.idOrder(m_data.idOrder);
-  ddsData.numOfVolley(m_data.numOfVolley);
-  ddsData.shotsPerVolley(m_data.shotsPerVolley);
+  ddsData.id = m_data.id;
+  ddsData.areaDepth = m_data.areaDepth;
+  ddsData.areaWidth = m_data.areaWidth;
+  ddsData.areaRotation = m_data.areaRotation;
+  ddsData.duration = m_data.duration;
+  ddsData.idOrder = m_data.idOrder;
+  ddsData.numOfVolley = m_data.numOfVolley;
+  ddsData.shotsPerVolley = m_data.shotsPerVolley;
  EffectShowManagement::OrderConfirmation_e oc = EffectShowManagement::OrderConfirmation_e(m_data.orderConfirmation);
-  ddsData.orderConfirmation(oc);
-  ddsData.position(Core::GeoPosition2D(m_data.centerPosition.x(), m_data.centerPosition.y()));
-  ddsData.lowerLeftPosition(Core::GeoPosition2D(m_data.lowerLeftPosition.x(), m_data.lowerLeftPosition.y()));
-  ddsData.startTime(m_data.startTime);
-  ddsData.typeOfOrder(m_data.typeOfOrder);
-  ddsData.info(m_data.info.toStdString());
+  ddsData.orderConfirmation = oc;
+  ddsData.position = Core::GeoPosition2D(m_data.centerPosition.x(), m_data.centerPosition.y());
+  ddsData.lowerLeftPosition = Core::GeoPosition2D(m_data.lowerLeftPosition.x(), m_data.lowerLeftPosition.y());
+  ddsData.startTime = m_data.startTime;
+  ddsData.typeOfOrder = m_data.typeOfOrder;
+  ddsData.info = m_data.info.toStdString();
  INFO_LOG(m_logger) << "Publish EscOrder-data to dds (" << m_data.id << ") ...";

  if (oc ==  EffectShowManagement::OrderConfirmation_e::WaitingForAcceptance)
@@ -116,12 +116,12 @@ void ObjectOrder::getCreateNotificationRequestData(NotificationManagement::Creat
  if ( m_data.typeOfOrder == 1)
  {
    QString title = QString::fromUtf8(tr_lts("Notification", "DMF Order")); // deutsch Wirkdarstellungen
-    notif.title(title.toStdString());
+    notif.title = title.toStdString();
  }
  else
  {
    QString title = QString::fromUtf8(tr_lts("Notification", "Relocation Order")); // deutsch Stellungswechsel
-    notif.title(title.toStdString());
+    notif.title = title.toStdString();
  }

  QString content = QString::fromUtf8(tr_lts("Notification","<a href='lts://escOrderList/%1'>Open Dialog</a>"));
@@ -131,32 +131,32 @@ void ObjectOrder::getCreateNotificationRequestData(NotificationManagement::Creat
  const QString str = QString::number(m_data.typeOfOrder);
  args.emplace_back(str.toStdString());

-  notif.content(content.toStdString());
-  notif.contentArgs(args);
-  notif.timeStamp(m_mainHandler->dds()->currentPartitionTime());
-  notif.expiryTime(expiryTime);
-  notif.priority(NotificationManagement::Priority::High);
-  notif.processedPriority(NotificationManagement::Priority::Low);
-  notif.messageType(NotificationManagement::MessageType::Info);
-  notif.exerciseId(m_mainHandler->dds()->getExerciseId());
+  notif.content = content.toStdString();
+  notif.contentArgs = args;
+  notif.timeStamp = m_mainHandler->dds()->currentPartitionTime();
+  notif.expiryTime = expiryTime;
+  notif.priority = NotificationManagement::Priority::High;
+  notif.processedPriority = NotificationManagement::Priority::Low;
+  notif.messageType = NotificationManagement::MessageType::Info;
+  notif.exerciseId = m_mainHandler->dds()->getExerciseId();

  NotificationManagement::Address wsAddr;
-  wsAddr.addressId(addressId);
-  wsAddr.isRead(false);
+  wsAddr.addressId = addressId;
+  wsAddr.isRead = false;
  QString name = localHostName;
-  wsAddr.name(name.toStdString());
-  wsAddr.addressType(NotificationManagement::AddressType::Workstation);
+  wsAddr.name = name.toStdString();
+  wsAddr.addressType = NotificationManagement::AddressType::Workstation;

-  notif.recipientIds().reserve(1);
-  notif.recipientIds().push_back(wsAddr);
+  notif.recipientIds.reserve(1);
+  notif.recipientIds.push_back(wsAddr);

  NotificationManagement::Address addrSender;
-  addrSender.addressId(EffectShowClient::Offset);
-  addrSender.name(QStringLiteral("svcEffectShowClient").toStdString());
-  addrSender.addressType(NotificationManagement::AddressType::Service);
-  notif.sender(addrSender);
+  addrSender.addressId = EffectShowClient::Offset;
+  addrSender.name = QStringLiteral("svcEffectShowClient").toStdString();
+  addrSender.addressType = NotificationManagement::AddressType::Service;
+  notif.sender = addrSender;

-  data.notification(notif);
+  data.notification = notif;
 } // end of getCreateNotificationRequestData()

 void ObjectOrder::createNotificationRequest()
@@ -155,37 +155,37 @@ void HandlerDynamicParticipantData::tryCreateHitEvent(Database::EemEvent eData,
    return;

  // only handle 'real' hit events
-  switch (stateInfo.originatorType.underlying())
+  switch (stateInfo.originatorType)
  {
-  case ProjectDataManagement::StateChangeOriginator::AreaEffectSimulation:
-  case ProjectDataManagement::StateChangeOriginator::ImprovisedExplosiveDevice:
-  case ProjectDataManagement::StateChangeOriginator::DusMine:
+  case ProjectDataManagement::StateChangeOriginator::StateChangeOriginator_AreaEffectSimulation:
+  case ProjectDataManagement::StateChangeOriginator::StateChangeOriginator_ImprovisedExplosiveDevice:
+  case ProjectDataManagement::StateChangeOriginator::StateChangeOriginator_DusMine:
    eData.eventTypeId = ProjectDataManagement::PdmEventType::EventType_HitEffectSimulation;
    break;
-  case ProjectDataManagement::StateChangeOriginator::Participant:
-  case ProjectDataManagement::StateChangeOriginator::ObserverController:
-  case ProjectDataManagement::StateChangeOriginator::ExerciseControl:
+  case ProjectDataManagement::StateChangeOriginator::StateChangeOriginator_Participant:
+  case ProjectDataManagement::StateChangeOriginator::StateChangeOriginator_ObserverController:
+  case ProjectDataManagement::StateChangeOriginator::StateChangeOriginator_ExerciseControl:
    eData.eventTypeId = ProjectDataManagement::PdmEventType::EventType_Hit;
    break;
-  case ProjectDataManagement::StateChangeOriginator::Sanitation:
+  case ProjectDataManagement::StateChangeOriginator::StateChangeOriginator_Sanitation:
    eData.eventTypeId = ProjectDataManagement::PdmEventType::EventType_Sanitation;
    break;
-  case ProjectDataManagement::StateChangeOriginator::Unknown:
-  case ProjectDataManagement::StateChangeOriginator::WoundTreatmentDevice:
-  case ProjectDataManagement::StateChangeOriginator::MaintainanceDevice:
-  case ProjectDataManagement::StateChangeOriginator::FunctionalArea:
-  case ProjectDataManagement::StateChangeOriginator::Initialization:
-  case ProjectDataManagement::StateChangeOriginator::MedicalTimeout:
+  case ProjectDataManagement::StateChangeOriginator::StateChangeOriginator_Unknown:
+  case ProjectDataManagement::StateChangeOriginator::StateChangeOriginator_WoundTreatmentDevice:
+  case ProjectDataManagement::StateChangeOriginator::StateChangeOriginator_MaintainanceDevice:
+  case ProjectDataManagement::StateChangeOriginator::StateChangeOriginator_FunctionalArea:
+  case ProjectDataManagement::StateChangeOriginator::StateChangeOriginator_Initialization:
+  case ProjectDataManagement::StateChangeOriginator::StateChangeOriginator_MedicalTimeout:
    return;
  }

  QJsonObject obj;
-  obj[QStringLiteral("VulnerabilityState")] = vulnState.underlying();
+  obj[QStringLiteral("VulnerabilityState")] = static_cast<int>(vulnState);
  obj[QStringLiteral("OriginatorId")] = stateInfo.originatorId;
-  obj[QStringLiteral("OriginatorType")] = stateInfo.originatorType.underlying();
+  obj[QStringLiteral("OriginatorType")] = static_cast<int>(stateInfo.originatorType);
  obj[QStringLiteral("OriginatorChargeTypeId")] = stateInfo.originatorChargeTypeId;

-  if (stateInfo.originatorType == ProjectDataManagement::StateChangeOriginator::Participant)
+  if (stateInfo.originatorType == ProjectDataManagement::StateChangeOriginator::StateChangeOriginator_Participant)
  {
    ParticipantManagement::Participant originData = m_partMap.value(stateInfo.originatorId);
    if (originData.equipmentNumber.is_set())
@@ -200,7 +200,7 @@ void HandlerDynamicParticipantData::tryCreateHitEvent(Database::EemEvent eData,
  {
    DEBUG_LOG(m_logger) << "Event HitEffectSimulation from originatorId = " << stateInfo.originatorId;
    obj[QStringLiteral("AesId")] = stateInfo.originatorId;
-    obj[QStringLiteral("AesType")] = m_itemViews.value(stateInfo.originatorId).underlying();
+    obj[QStringLiteral("AesType")] = static_cast<int>(m_itemViews.value(stateInfo.originatorId));
    AreaEffectSimulation::AesItem aesItem;
    if (m_aesDtc->aesItemFromId(stateInfo.originatorId, aesItem))
      obj[QStringLiteral("AesName")] = QJsonValue(QString::fromStdString(aesItem.name));
@@ -214,8 +214,8 @@ void HandlerDynamicParticipantData::tryCreateHitEvent(Database::EemEvent eData,
    DEBUG_LOG(m_logger) << "Event sanitation ";

    obj[QStringLiteral("Vitality")] = stateInfo.vitality;
-    obj[QStringLiteral("SanitationResult")] = stateInfo.sanitationResult.underlying();
-    obj[QStringLiteral("SanitationProceduresTaken")] = stateInfo.sanitationProceduresTaken;
+    obj[QStringLiteral("SanitationResult")] = static_cast<int>(stateInfo.sanitationResult);
+    obj[QStringLiteral("SanitationProceduresTaken")] = QJsonValue(static_cast<qint64>(stateInfo.sanitationProceduresTaken));
  }

  eData.properties = QString::fromUtf8(QJsonDocument(obj).toJson(QJsonDocument::Compact));
@@ -272,7 +272,7 @@ void HandlerDynamicParticipantData::onDynamicParticipantDataChanged(const Partic
  eData.equipmentNumber = pData.equipmentNumber.is_set() ? pData.equipmentNumber.get() : -1;
  eData.partyId         = pData.partyId;
  eData.sampleTime      = data.sampleTime;
-  eData.eventTypeId     = ProjectDataManagement::PdmEventType::PdmEventType_Unknown;
+  eData.eventTypeId     = ProjectDataManagement::PdmEventType::EventType_Unknown;
  eData.position        = LtsUtils::QPoint3D(pPos.pos.lon, pPos.pos.lat, pPos.pos.z);

  if (data.stateHistory != lastDynData.stateHistory)
@@ -307,7 +307,7 @@ void HandlerDynamicParticipantData::onDynamicParticipantDataChanged(const Partic
    obj[QStringLiteral("DryFire")]    = QJsonValue(gi.chargeCounting);
    eData.properties = QString::fromUtf8(QJsonDocument(obj).toJson(QJsonDocument::Compact));
    eData.sampleTime = gi.lastUpdate;
-    eData.eventTypeId = ProjectDataManagement::PdmEventType::PdmEventType_WeaponAssignment;
+    eData.eventTypeId = ProjectDataManagement::PdmEventType::EventType_WeaponAssignment;
    eData.id = 0;
    if (!m_dbHandler->db()->insert(eData))
      ERROR_LOG(m_logger) << "Error while inserting event data for participant: " << data.participantId;
@@ -317,7 +317,7 @@ void HandlerDynamicParticipantData::onDynamicParticipantDataChanged(const Partic

  if (data.manipulation != lastDynData.manipulation)
  {
-    eData.eventTypeId = ProjectDataManagement::PdmEventType::PdmEventType_Manipulation;
+    eData.eventTypeId = ProjectDataManagement::PdmEventType::EventType_Manipulation;

    const auto isOldManipulation = [&lastDynData](const ParticipantManagement::ManipulationInformation & mani) -> bool
    {
@@ -376,7 +376,7 @@ void HandlerDynamicParticipantData::onParticipantGearEventChanged(const Particip
  eData.equipmentNumber = pData.equipmentNumber.is_set() ? pData.equipmentNumber.get() : -1;
  eData.partyId         = pData.partyId;
  eData.sampleTime      = data.sampleTime;
-  eData.eventTypeId     = ProjectDataManagement::PdmEventType::PdmEventType_FireEvent;
+  eData.eventTypeId     = ProjectDataManagement::PdmEventType::EventType_FireEvent;
  eData.position        = LtsUtils::QPoint3D(pPos.pos.lon, pPos.pos.lat, pPos.pos.z);

  QJsonObject obj;
@@ -442,7 +442,7 @@ void HandlerDynamicParticipantData::onBiteChanged(const ParticipantManagement::B
  Database::EemEvent eData;

  eData.id = 0;
-  eData.eventTypeId = ProjectDataManagement::PdmEventType::PdmEventType_BiteMessage;
+  eData.eventTypeId = ProjectDataManagement::PdmEventType::EventType_BiteMessage;
  eData.equipmentNumber = data.equipmentNumber;
  eData.participantId   = data.participantId;
  eData.sampleTime      = data.sampleTime;
@@ -495,7 +495,7 @@ void HandlerDynamicParticipantData::onBuildingStateChanged(const Buildings::Buil
  Database::EemEvent eData;

  eData.id = 0;
-  eData.eventTypeId = ProjectDataManagement::PdmEventType::PdmEventType_HitBuilding;
+  eData.eventTypeId = ProjectDataManagement::PdmEventType::EventType_HitBuilding;
  eData.sampleTime  = data.sampleTime;

  QJsonObject obj;
@@ -503,18 +503,18 @@ void HandlerDynamicParticipantData::onBuildingStateChanged(const Buildings::Buil
  obj[QStringLiteral("damagePercent")] = QJsonValue(data.damagePercent);
  obj[QStringLiteral("damagePercentOld")] = QJsonValue(data.damagePercentOld);
  //  obj[QStringLiteral("Name")] = QJsonValue(data.name());
-  obj[QStringLiteral("VulnerabilityState")] = QJsonValue(data.vulnerabilityState.underlying());
+  obj[QStringLiteral("VulnerabilityState")] = QJsonValue(static_cast<int>(data.vulnerabilityState));

-  if (data.originatorType == ProjectDataManagement::StateChangeOriginator::Participant)
+  if (data.originatorType == ProjectDataManagement::StateChangeOriginator::StateChangeOriginator_Participant)
  {
    ParticipantManagement::Participant originData = m_partMap.value(data.originatorParticipantId);
    if (originData.equipmentNumber.is_set())
      obj[QStringLiteral("OriginatorEquipmentNumber")] = originData.equipmentNumber.get();
  }
-  if (data.originatorType == ProjectDataManagement::StateChangeOriginator::AreaEffectSimulation)
+  if (data.originatorType == ProjectDataManagement::StateChangeOriginator::StateChangeOriginator_AreaEffectSimulation)
  {
    obj[QStringLiteral("AesId")] = data.aesId;
-    obj[QStringLiteral("AesType")] = m_itemViews.value(data.aesId).underlying();
+    obj[QStringLiteral("AesType")] = static_cast<int>(m_itemViews.value(data.aesId));
    AreaEffectSimulation::AesItem aesItem;
    if (m_aesDtc->aesItemFromId(data.aesId, aesItem))
      obj[QStringLiteral("AesName")] = QJsonValue(QString::fromStdString(aesItem.name));
@@ -577,7 +577,7 @@ ExerciseEventManagement::Event HandlerDynamicParticipantData::toDdsData(const Da
  ddsData.properties = data.properties.toStdString();
  ddsData.position = Core::GeoPosition(data.position.x(), data.position.y(), data.position.z());

-  if (data.eventTypeId == ProjectDataManagement::PdmEventType::PdmEventType_HitBuilding)
+  if (data.eventTypeId == ProjectDataManagement::PdmEventType::EventType_HitBuilding)
  {
    int mainStructureElementId = LtsUtils::JsonObject::fromJson(ddsData.properties).valueOr<int>(QStringLiteral("MainStructureElementId"), 0);
    DEBUG_LOG(m_logger) << "MainStructureElementId=" << mainStructureElementId;
@@ -85,7 +85,7 @@ void HandlerEquipmentErrorRegistration::onEquipmentErrorRegistrationChanged(cons
  Database::EemEvent eData;
  eData.sampleTime      = data.sampleTime;
  eData.equipmentNumber = data.equipmentNumber;
-  eData.eventTypeId     = ProjectDataManagement::PdmEventType::PdmEventType_EquipmentErrorReport;
+  eData.eventTypeId     = ProjectDataManagement::PdmEventType::EventType_EquipmentErrorReport;

  QJsonObject obj;
  obj[QStringLiteral("text")]        = QString::fromStdString(data.text);
@@ -100,7 +100,7 @@ void HandlerParticipantEvent::onAesItemViewChanged(const AreaEffectSimulation::A
    DEBUG_LOG(m_logger) << "eAdded: AesItemId: " << data.aesItemId << ", effectState: " << data.effectStateId;
    m_aesEffectState.insert(data.aesItemId, data.effectStateId);

-    if (data.aesTypeId == AreaEffectSimulation::AesType::AesType_AtBorderline)
+    if (data.aesTypeId == AreaEffectSimulation::AesType::AtBorderline)
    {
      AreaEffectSimulation::AesItem aesItem;
      m_aesDtc->aesItemFromId(data.aesItemId, aesItem);
@@ -108,7 +108,7 @@ void HandlerParticipantEvent::onAesItemViewChanged(const AreaEffectSimulation::A
      QJsonObject obj;
      obj[QStringLiteral("AesId")] = QJsonValue(aesItem.id);
      obj[QStringLiteral("AesName")] = QJsonValue(QString::fromStdString(aesItem.name));
-      obj[QStringLiteral("AesType")] = QJsonValue(data.aesTypeId.underlying());
+      obj[QStringLiteral("AesType")] = QJsonValue(static_cast<int>(data.aesTypeId));

      eData.properties = QString::fromUtf8(QJsonDocument(obj).toJson(QJsonDocument::Compact));
      eData.eventTypeId = ProjectDataManagement::PdmEventType::EventType_Borderline;
@@ -130,7 +130,7 @@ void HandlerParticipantEvent::onAesItemViewChanged(const AreaEffectSimulation::A

    // insert event only once
    if (effectState != AreaEffectSimulation::AesEffectState::EsPrepared &&
-       (effectState == AreaEffectSimulation::AesEffectState::AesEffectState_EsActivated && data.effectStateId != AreaEffectSimulation::AesEffectState::AesEffectState_EsExpired))
+       (effectState == AreaEffectSimulation::AesEffectState::EsActivated && data.effectStateId != AreaEffectSimulation::AesEffectState::EsExpired))
      return;

    INFO_LOG(m_logger) << "new/update event: aesId: " << data.aesItemId;
@@ -142,7 +142,7 @@ void HandlerParticipantEvent::onAesItemViewChanged(const AreaEffectSimulation::A

    INFO_LOG(m_logger) << "aesType: " << data.aesTypeId;

-    switch (data.aesTypeId.underlying())
+    switch (data.aesTypeId)
    {
    case AreaEffectSimulation::AesType::AtMineArea:
      eData.eventTypeId = ProjectDataManagement::PdmEventType::EventType_MineArea;
@@ -182,7 +182,7 @@ void HandlerParticipantEvent::onAesItemViewChanged(const AreaEffectSimulation::A
      // No ExerciseEvent for AesType
    default:
    {
-      INFO_LOG(m_logger) << "No ExerciseEvent for AesType:" << data.aesTypeId.underlying();
+      INFO_LOG(m_logger) << "No ExerciseEvent for AesType:" << data.aesTypeId;
      return;
    }
    }
@@ -200,12 +200,12 @@ void HandlerParticipantEvent::onAesItemViewChanged(const AreaEffectSimulation::A
    QJsonObject obj;
    obj[QStringLiteral("AesId")] = QJsonValue(aesItem.id);
    obj[QStringLiteral("AesName")] = QJsonValue(QString::fromStdString(aesItem.name));
-    obj[QStringLiteral("AesType")] = QJsonValue(data.aesTypeId.underlying());
-    if (data.aesTypeId.underlying() !=  AreaEffectSimulation::AesType::AtBorderline)
+    obj[QStringLiteral("AesType")] = QJsonValue(static_cast<int>(data.aesTypeId));
+    if (data.aesTypeId !=  AreaEffectSimulation::AesType::AtBorderline)
    {
      obj[QStringLiteral("duration")] = QJsonValue(aesItem.effectDuration);
      obj[QStringLiteral("ChargeTypeId")] = QJsonValue(data.chargeStruct.chargeTypeId);
-      obj[QStringLiteral("endTime")] = QJsonValue(data.effectStart + aesItem.effectDuration);
+      obj[QStringLiteral("endTime")] = QJsonValue(static_cast<qint64>(data.effectStart + aesItem.effectDuration));
    }
    eData.properties = QString::fromUtf8(QJsonDocument(obj).toJson(QJsonDocument::Compact));

@@ -263,7 +263,7 @@ void HandlerParticipantEvent::onExplosionSingleChanged(const AreaEffectSimulatio

    // insert event only once
    if (effectState != AreaEffectSimulation::AesEffectState::EsPrepared &&
-       (effectState == AreaEffectSimulation::AesEffectState::AesEffectState_EsActivated && data.effectStateId != AreaEffectSimulation::AesEffectState::AesEffectState_EsExpired))
+       (effectState == AreaEffectSimulation::AesEffectState::EsActivated && data.effectStateId != AreaEffectSimulation::AesEffectState::EsExpired))
      return;

    m_aesEffectState.insert(data.id, data.effectStateId);
@@ -277,10 +277,10 @@ void HandlerParticipantEvent::onExplosionSingleChanged(const AreaEffectSimulatio
    QJsonObject obj;
    obj[QStringLiteral("AesId")] = QJsonValue(aesItem.id);
    obj[QStringLiteral("AesName")] = QJsonValue(QString::fromStdString(aesItem.name));
-    obj[QStringLiteral("AesType")] = QJsonValue(AreaEffectSimulation::AesType::AtExplosionSingle);
+    obj[QStringLiteral("AesType")] = QJsonValue(static_cast<int>(AreaEffectSimulation::AesType::AtExplosionSingle));
    obj[QStringLiteral("ChargeTypeId")] = QJsonValue(data.chargeStruct.chargeTypeId);
    obj[QStringLiteral("duration")] = QJsonValue(aesItem.effectDuration);
-    obj[QStringLiteral("endTime")] = QJsonValue(data.effectStart.get() + aesItem.effectDuration);
+    obj[QStringLiteral("endTime")] = QJsonValue(static_cast<qint64>(data.effectStart.get() + aesItem.effectDuration));
    eData.properties = QString::fromUtf8(QJsonDocument(obj).toJson(QJsonDocument::Compact));

    //const Core::GeoPosition geoPosition ( data.impactPosition().lon(), data.impactPosition().lat(), 0);
@@ -328,68 +328,68 @@ void HandlerParticipantEvent::onParticipantEventChanged(const CentralEffectSimul
                       << " position=" << data.position
                       << " eData.position=" << eData.position;

-  eData.eventTypeId     = ProjectDataManagement::PdmEventType::PdmEventType_Unknown;
+  eData.eventTypeId     = ProjectDataManagement::PdmEventType::EventType_Unknown;

  QJsonObject obj;
  obj[QStringLiteral("AesId")] = QJsonValue(data.aesItemId);
-  obj[QStringLiteral("AesType")] = QJsonValue(m_itemViews.value(data.aesItemId).underlying());
+  obj[QStringLiteral("AesType")] = QJsonValue(static_cast<int>(m_itemViews.value(data.aesItemId)));
  obj[QStringLiteral("AesName")] = QJsonValue(QString::fromStdString(data.aesName));
  obj[QStringLiteral("FriendlyFire")] = QJsonValue(data.friendlyFire);

-  switch(data.eventTypeId.underlying())
+  switch(data.eventTypeId)
  {
-  case ProjectDataManagement::PdmEventType::PdmEventType_HitEffectSimulation:
-    eData.eventTypeId = ProjectDataManagement::PdmEventType::PdmEventType_HitEffectSimulation;
+  case ProjectDataManagement::PdmEventType::EventType_HitEffectSimulation:
+    eData.eventTypeId = ProjectDataManagement::PdmEventType::EventType_HitEffectSimulation;
    break;
-  case ProjectDataManagement::PdmEventType::PdmEventType_HitMine:
-    eData.eventTypeId = ProjectDataManagement::PdmEventType::PdmEventType_HitMine;
+  case ProjectDataManagement::PdmEventType::EventType_HitMine:
+    eData.eventTypeId = ProjectDataManagement::PdmEventType::EventType_HitMine;
    break;
-  case ProjectDataManagement::PdmEventType::PdmEventType_HitN:
-    eData.eventTypeId = ProjectDataManagement::PdmEventType::PdmEventType_HitN;
+  case ProjectDataManagement::PdmEventType::EventType_HitN:
+    eData.eventTypeId = ProjectDataManagement::PdmEventType::EventType_HitN;
    break;
-  case ProjectDataManagement::PdmEventType::PdmEventType_HitC:
-    eData.eventTypeId = ProjectDataManagement::PdmEventType::PdmEventType_HitC;
+  case ProjectDataManagement::PdmEventType::EventType_HitC:
+    eData.eventTypeId = ProjectDataManagement::PdmEventType::EventType_HitC;
    break;
-  case ProjectDataManagement::PdmEventType::PdmEventType_EnterDangerArea:
-    eData.eventTypeId = ProjectDataManagement::PdmEventType::PdmEventType_EnterDangerArea;
+  case ProjectDataManagement::PdmEventType::EventType_EnterDangerArea:
+    eData.eventTypeId = ProjectDataManagement::PdmEventType::EventType_EnterDangerArea;
    break;
-  case ProjectDataManagement::PdmEventType::PdmEventType_LeaveDangerArea:
-    eData.eventTypeId = ProjectDataManagement::PdmEventType::PdmEventType_LeaveDangerArea;
+  case ProjectDataManagement::PdmEventType::EventType_LeaveDangerArea:
+    eData.eventTypeId = ProjectDataManagement::PdmEventType::EventType_LeaveDangerArea;
    break;
-  case ProjectDataManagement::PdmEventType::PdmEventType_EnterMineArea:
-    eData.eventTypeId = ProjectDataManagement::PdmEventType::PdmEventType_EnterMineArea;
+  case ProjectDataManagement::PdmEventType::EventType_EnterMineArea:
+    eData.eventTypeId = ProjectDataManagement::PdmEventType::EventType_EnterMineArea;
    break;
-  case ProjectDataManagement::PdmEventType::PdmEventType_LeaveMineArea:
-    eData.eventTypeId = ProjectDataManagement::PdmEventType::PdmEventType_LeaveMineArea;
+  case ProjectDataManagement::PdmEventType::EventType_LeaveMineArea:
+    eData.eventTypeId = ProjectDataManagement::PdmEventType::EventType_LeaveMineArea;
    break;
-  case ProjectDataManagement::PdmEventType::PdmEventType_EnterNuclear:
-    eData.eventTypeId = ProjectDataManagement::PdmEventType::PdmEventType_EnterNuclear;
+  case ProjectDataManagement::PdmEventType::EventType_EnterNuclear:
+    eData.eventTypeId = ProjectDataManagement::PdmEventType::EventType_EnterNuclear;
    break;
-  case ProjectDataManagement::PdmEventType::PdmEventType_LeaveNuclear:
-    eData.eventTypeId = ProjectDataManagement::PdmEventType::PdmEventType_LeaveNuclear;
+  case ProjectDataManagement::PdmEventType::EventType_LeaveNuclear:
+    eData.eventTypeId = ProjectDataManagement::PdmEventType::EventType_LeaveNuclear;
    break;
-  case ProjectDataManagement::PdmEventType::PdmEventType_CrossLocalBorderline:
-    eData.eventTypeId = ProjectDataManagement::PdmEventType::PdmEventType_CrossLocalBorderline;
+  case ProjectDataManagement::PdmEventType::EventType_CrossLocalBorderline:
+    eData.eventTypeId = ProjectDataManagement::PdmEventType::EventType_CrossLocalBorderline;
    obj[QStringLiteral("Global")] = QJsonValue(false);
    break;
-  case ProjectDataManagement::PdmEventType::PdmEventType_CrossGlobalBorderline:
-    eData.eventTypeId = ProjectDataManagement::PdmEventType::PdmEventType_CrossGlobalBorderline;
+  case ProjectDataManagement::PdmEventType::EventType_CrossGlobalBorderline:
+    eData.eventTypeId = ProjectDataManagement::PdmEventType::EventType_CrossGlobalBorderline;
    obj[QStringLiteral("Global")] = QJsonValue(true);
    break;
-  case ProjectDataManagement::PdmEventType::PdmEventType_EnterFunctionalArea:
-    eData.eventTypeId = ProjectDataManagement::PdmEventType::PdmEventType_EnterFunctionalArea;
+  case ProjectDataManagement::PdmEventType::EventType_EnterFunctionalArea:
+    eData.eventTypeId = ProjectDataManagement::PdmEventType::EventType_EnterFunctionalArea;
    break;
-  case ProjectDataManagement::PdmEventType::PdmEventType_LeaveFunctionalArea:
-    eData.eventTypeId = ProjectDataManagement::PdmEventType::PdmEventType_LeaveFunctionalArea;
+  case ProjectDataManagement::PdmEventType::EventType_LeaveFunctionalArea:
+    eData.eventTypeId = ProjectDataManagement::PdmEventType::EventType_LeaveFunctionalArea;
    break;
-  case ProjectDataManagement::PdmEventType::PdmEventType_EnterHazardDistance:
-    eData.eventTypeId = ProjectDataManagement::PdmEventType::PdmEventType_EnterHazardDistance;
+  case ProjectDataManagement::PdmEventType::EventType_EnterHazardDistance:
+    eData.eventTypeId = ProjectDataManagement::PdmEventType::EventType_EnterHazardDistance;
    break;
-  case ProjectDataManagement::PdmEventType::PdmEventType_LeaveHazardDistance:
-    eData.eventTypeId = ProjectDataManagement::PdmEventType::PdmEventType_LeaveHazardDistance;
+  case ProjectDataManagement::PdmEventType::EventType_LeaveHazardDistance:
+    eData.eventTypeId = ProjectDataManagement::PdmEventType::EventType_LeaveHazardDistance;
    break;
-  case ProjectDataManagement::PdmEventType::PdmEventType_AirSupport:
-    eData.eventTypeId = ProjectDataManagement::PdmEventType::PdmEventType_AirSupport;
+  case ProjectDataManagement::PdmEventType::EventType_AirSupport:
+    eData.eventTypeId = ProjectDataManagement::PdmEventType::EventType_AirSupport;
    break;
  default:
    return;
@@ -131,7 +131,7 @@ AvsData WebSocketAvs::jsonObjectToAvsData(const QJsonObject &obj)
    ERROR_LOG(m_logger) << "Unknown avsEventType: " << avsEventType;
    break;
  }
-  data.eventType  = eventType.underlying();
+  data.eventType  = eventType;

  int mountingPointId = 0;
  if (m_avmDtc->mountingPointForStreamName(data.streamName, mountingPointId))
@@ -148,7 +148,7 @@ Database::EemEvent WebSocketAvs::avsDataToEemEvent(const AvsData &data)
 {
  Database::EemEvent eemEvent;
  eemEvent.id          = data.id;
-  eemEvent.eventTypeId = data.eventType.underlying();
+  eemEvent.eventTypeId = data.eventType;
  eemEvent.sampleTime  = data.eventTime;

  QJsonObject obj;
@@ -107,14 +107,14 @@ bool HandlerIed::init()
  for (auto it = latestPositions.begin(); it != latestPositions.end(); ++it)
  {
    const auto &pos = it.value();
-    ObjectIed *currentIed = m_iedObjMap.value(pos.id());
+    ObjectIed *currentIed = m_iedObjMap.value(pos.id);

    if (currentIed == nullptr)
    {
-      INFO_LOG(m_logger) << "Got position for non existing IED-Id: " << pos.id();
+      INFO_LOG(m_logger) << "Got position for non existing IED-Id: " << pos.id;
      continue;
    }
-    DEBUG_LOG(m_logger) << "Setting position for IED-Id " << pos.id();
+    DEBUG_LOG(m_logger) << "Setting position for IED-Id " << pos.id;
    currentIed->setPosition(it.value());
  }

@@ -166,10 +166,10 @@ static inline IedTacticalState toTacticalState(int tacticalState)

 static void assignBaseData(const TrainingAreaBase::IedBaseData &inData, Database::GimIed &outData)
 {
-  outData.equipmentNumber = inData.iedId();
-  outData.tacticalStateId = toTacticalState(inData.tacticalState());
-  outData.pyrotechnics = inData.statePyrotechnics();
-  outData.sampleTime = inData.sampleTime();
+  outData.equipmentNumber = inData.iedId;
+  outData.tacticalStateId = toTacticalState(inData.tacticalState);
+  outData.pyrotechnics = inData.statePyrotechnics;
+  outData.sampleTime = inData.sampleTime;
 }

 void HandlerIed::onDefinitionIed(const TrainingAreaBase::DefinitionIed &data, DataModification modType)
@@ -182,26 +182,26 @@ void HandlerIed::onDefinitionIed(const TrainingAreaBase::DefinitionIed &data, Da
  Database::GimIed newData;

  assignBaseData(data, newData);
-  newData.typeId = static_cast<IedType>(data.type());
-  newData.remoteTrigger = data.remoteTrigger();
-  newData.switchTrigger = data.switchTrigger();
-  newData.lightBarrierTrigger = data.lightBarrierTrigger();
-  newData.tautWireTrigger = data.tautWireTrigger();
-  newData.explosiveForce = data.explosiveForce();
+  newData.typeId = static_cast<IedType>(data.type);
+  newData.remoteTrigger = data.remoteTrigger;
+  newData.switchTrigger = data.switchTrigger;
+  newData.lightBarrierTrigger = data.lightBarrierTrigger;
+  newData.tautWireTrigger = data.tautWireTrigger;
+  newData.explosiveForce = data.explosiveForce;

-  if (m_ppmDtc->party(data.partyId()).id() > 0)
-    newData.partyId = data.partyId(); // use party from telegram
+  if (m_ppmDtc->party(data.partyId).id > 0)
+    newData.partyId = data.partyId; // use party from telegram
  else
-    newData.partyId = getPartyIdFromParticipantEquipmentNumber(data.equipmentNumber()); // use party from equipmentNumber
+    newData.partyId = getPartyIdFromParticipantEquipmentNumber(data.equipmentNumber); // use party from equipmentNumber

-  newData.pairingStateId = static_cast<IedPairingState>(data.pairingState());
-  switch (newData.pairingStateId.underlying())
+  newData.pairingStateId = static_cast<IedPairingState>(data.pairingState);
+  switch (newData.pairingStateId)
  {
  case IedPairingState::PairedToParticipant:
-    newData.pairedParticipantId.setValue(data.pairedId().get());
+    newData.pairedParticipantId.setValue(data.pairedId.get());
    break;
  case IedPairingState::PairedToOps:
-    newData.pairedOpsId.setValue(data.pairedId().get());
+    newData.pairedOpsId.setValue(data.pairedId.get());
    break;
  case IedPairingState::NotPaired:
    break;
@@ -215,7 +215,7 @@ void HandlerIed::onDefinitionIed(const TrainingAreaBase::DefinitionIed &data, Da
  //                           ^
  //                           | -> Therefore suppress Injury
  // handled at guez_ied_to_map.cpp and gim_info_dialog.cpp
-  switch (newData.typeId.underlying())
+  switch (newData.typeId)
  {
  case IedType::SuicideIed:
    newData.symbol = QStringLiteral("AP6D|CMPL|10014000001103040000"); //SIDC for suicide bomber
@@ -241,21 +241,21 @@ void HandlerIed::onDefinitionIed(const TrainingAreaBase::DefinitionIed &data, Da
      return;
    }
    m_iedObjMap.insert(ifs->getId(), ifs);
-    auto it = m_orphanedStateIed.find(data.iedId());
+    auto it = m_orphanedStateIed.find(data.iedId);
    if (it != m_orphanedStateIed.end())
    {
      auto defState = it.value();
      m_orphanedStateIed.erase(it);

-      defState.tacticalState(data.tacticalState());
-      defState.statePyrotechnics(data.statePyrotechnics());
-      defState.sampleTime(data.sampleTime());
+      defState.tacticalState = data.tacticalState;
+      defState.statePyrotechnics = data.statePyrotechnics;
+      defState.sampleTime = data.sampleTime;
      onStateIed(defState, DataModification::eAdded);
    }
    id = ifs->getId();
  }

-  m_iedObjMap[id]->setPosition(newData.sampleTime, Core::GeoPosition(data.position().lon(), data.position().lat(), 0));
+  m_iedObjMap[id]->setPosition(newData.sampleTime, Core::GeoPosition(data.position.lon, data.position.lat, 0));
 }

 static inline IedError toIedError(int err)
@@ -279,23 +279,23 @@ void HandlerIed::onStateIed(const TrainingAreaBase::StateIed &data, DataModifica
  DEBUG_LOG(m_logger) << "onStateIed: " << data;

  // only overwrite state for existing IEDs
-  if (m_iedObjMap.contains(getIdByEquipmentnumber(data.iedId())))
+  if (m_iedObjMap.contains(getIdByEquipmentnumber(data.iedId)))
  {
    Database::GimIed newData;

    assignBaseData(data, newData);
-    newData.batterywarnings = data.batteryWarnings();
-    newData.electronicsErrorStateId = toIedError(data.errorStateElectronics());
-    newData.pyrotechnics1ErrorStateId = toIedError(data.errorStatePyrotechnics1());
-    newData.pyrotechnics2ErrorStateId = toIedError(data.errorStatePyrotechnics2());
-    newData.pyrotechnics3ErrorStateId = toIedError(data.errorStatePyrotechnics3());
+    newData.batterywarnings = data.batteryWarnings;
+    newData.electronicsErrorStateId = toIedError(data.errorStateElectronics);
+    newData.pyrotechnics1ErrorStateId = toIedError(data.errorStatePyrotechnics1);
+    newData.pyrotechnics2ErrorStateId = toIedError(data.errorStatePyrotechnics2);
+    newData.pyrotechnics3ErrorStateId = toIedError(data.errorStatePyrotechnics3);

    m_iedObjMap[getIdByEquipmentnumber(newData.equipmentNumber)]->updateState(newData);
  }
  else
  {
    WARNING_LOG(m_logger) << "StateIed without an existing IED - got no DefinitionIED? " << data;
-    m_orphanedStateIed.insert(data.iedId(), data);
+    m_orphanedStateIed.insert(data.iedId, data);
  }
 }

@@ -304,25 +304,25 @@ void HandlerIed::onPairIedRequest(const rti::core::SampleIdentity &cookie,
 {
  Core::FunctionReplyObject ret;

-  INFO_LOG(m_logger) << "onPairIedRequest id = " << request.id();
+  INFO_LOG(m_logger) << "onPairIedRequest id = " << request.id;

-  ObjectIed *ifs = m_iedObjMap.value(request.id());
+  ObjectIed *ifs = m_iedObjMap.value(request.id);
  if (ifs == nullptr)
  {
-    ret = Core::FunctionReplyObject(request.id(), tr_lts("dds", "IED with id %1 not found")).arg(request.id());
+    ret = Core::FunctionReplyObject(request.id, tr_lts("dds", "IED with id %1 not found")).arg(request.id);
    m_ddsHandler->fts()->pairIedReply(cookie, ret);
    return;
  }

  Database::GimIed data;
-  data.pairingStateId = request.pairingState();
+  data.pairingStateId = request.pairingState;

-  switch (request.pairingState().underlying())
+  switch (request.pairingState)
  {
  case IedPairingState::PairedToParticipant:
  {
    data.pairedParticipantId.setValue(request.pairedParticipantId.get());
-    data.partyId = m_ppmDtc->participant(request.pairedParticipantId.get()).partyId();
+    data.partyId = m_ppmDtc->participant(request.pairedParticipantId.get()).partyId;
    break;
  }
  case IedPairingState::PairedToOps:
@@ -357,8 +357,8 @@ int HandlerIed::getPartyIdFromParticipantEquipmentNumber(const int equipmentNumb

  for (const auto &participant : participants)
  {
-    if (participant.equipmentNumber() == equipmentNumber)
-      return participant.partyId();
+    if (participant.equipmentNumber == equipmentNumber)
+      return participant.partyId;
  }

  return 0;
@@ -120,28 +120,28 @@ void ObjectIed::onPublishData()
 {
  GuezIedManagement::Ied ddsData;

-  ddsData.id(m_data.id);
-  ddsData.equipmentNumber(m_data.equipmentNumber);
-  ddsData.type(IedType(m_data.typeId));
-  ddsData.remoteTrigger(m_data.remoteTrigger);
-  ddsData.switchTrigger(m_data.switchTrigger);
-  ddsData.lightBarrierTrigger(m_data.lightBarrierTrigger);
-  ddsData.tautWireTrigger(m_data.tautWireTrigger);
-  ddsData.explosiveForce(m_data.explosiveForce);
-  ddsData.partyId(m_data.partyId);
-  ddsData.pairingState(IedPairingState(m_data.pairingStateId));
+  ddsData.id = m_data.id;
+  ddsData.equipmentNumber = m_data.equipmentNumber;
+  ddsData.type = IedType(m_data.typeId);
+  ddsData.remoteTrigger = m_data.remoteTrigger;
+  ddsData.switchTrigger = m_data.switchTrigger;
+  ddsData.lightBarrierTrigger = m_data.lightBarrierTrigger;
+  ddsData.tautWireTrigger = m_data.tautWireTrigger;
+  ddsData.explosiveForce = m_data.explosiveForce;
+  ddsData.partyId = m_data.partyId;
+  ddsData.pairingState = IedPairingState(m_data.pairingStateId);

-  switch(ddsData.pairingState().underlying())
+  switch(ddsData.pairingState)
  {
    case IedPairingState::PairedToParticipant:
    {
-      ddsData.pairedParticipantId().set(m_data.pairedParticipantId.toInt());
+      ddsData.pairedParticipantId.set(m_data.pairedParticipantId.toInt());
      connect(m_ppmDtc.get(), &ParticipantManagement::Interface::Dtc::participantPositionChanged, this, &ObjectIed::onParticipantPositionChanged);
      break;
    }
    case IedPairingState::PairedToOps:
    {
-      ddsData.pairedOpsId().set(m_data.pairedOpsId.toInt());
+      ddsData.pairedOpsId.set(m_data.pairedOpsId.toInt());
      //todo: connect to ISM for OPS-Position
      disconnect(m_ppmDtc.get(), &ParticipantManagement::Interface::Dtc::participantPositionChanged, this, &ObjectIed::onParticipantPositionChanged);
      break;
@@ -154,15 +154,15 @@ void ObjectIed::onPublishData()
    }
  }

-  ddsData.tacticalState(IedTacticalState(m_data.tacticalStateId));
-  ddsData.pyrotechnics(m_data.pyrotechnics);
-  ddsData.batteryWarnings(m_data.batterywarnings);
-  ddsData.electronicsError(IedError(m_data.electronicsErrorStateId));
-  ddsData.pyrotechnics1Error(IedError(m_data.pyrotechnics1ErrorStateId));
-  ddsData.pyrotechnics2Error(IedError(m_data.pyrotechnics2ErrorStateId));
-  ddsData.pyrotechnics3Error(IedError(m_data.pyrotechnics3ErrorStateId));
-  ddsData.symbol(m_data.symbol.toStdString());
-  ddsData.sampleTime(m_data.sampleTime);
+  ddsData.tacticalState = IedTacticalState(m_data.tacticalStateId);
+  ddsData.pyrotechnics = m_data.pyrotechnics;
+  ddsData.batteryWarnings = m_data.batterywarnings;
+  ddsData.electronicsError = IedError(m_data.electronicsErrorStateId);
+  ddsData.pyrotechnics1Error = IedError(m_data.pyrotechnics1ErrorStateId);
+  ddsData.pyrotechnics2Error = IedError(m_data.pyrotechnics2ErrorStateId);
+  ddsData.pyrotechnics3Error = IedError(m_data.pyrotechnics3ErrorStateId);
+  ddsData.symbol = m_data.symbol.toStdString();
+  ddsData.sampleTime = m_data.sampleTime;

  INFO_LOG(m_logger) << "Publish IED-data to dds (" << m_data.id << ") ...";

@@ -175,8 +175,8 @@ void ObjectIed::onParticipantPositionChanged(const ParticipantManagement::Partic
  if (modType != DataModification::eAdded && modType != DataModification::eModified)
    return;

-  if (data.participantId() == m_data.pairedParticipantId.toInt())
-    setPosition(data.sampleTime(), data.pos());
+  if (data.participantId == m_data.pairedParticipantId.toInt())
+    setPosition(data.sampleTime, data.pos);
 }

 void ObjectIed::assignBaseData(const Database::GimIed &data)
@@ -193,12 +193,12 @@ void ObjectIed::assignPairingState(const Database::GimIed &data)
  m_data.pairedOpsId = data.pairedOpsId;
  m_data.partyId = data.partyId;

-  switch(data.pairingStateId.underlying())
+  switch(data.pairingStateId)
  {
    case IedPairingState::PairedToParticipant:
    {
      ParticipantManagement::ParticipantPosition position = m_ppmDtc->participantPosition(m_data.pairedParticipantId.toInt());
-      setPosition(position.sampleTime(), position.pos());
+      setPosition(position.sampleTime, position.pos);
      break;
    }
    case IedPairingState::PairedToOps:
@@ -67,7 +67,7 @@ bool DdsHandler::init(const QStringList &qosFileList)

 qint64 DdsHandler::currentPartitionTime() const
 {
-  return m_dtcCore->partitionTime().timeStamp();
+  return m_dtcCore->partitionTime().timeStamp;
 }
 //-----------------------------------------------------------------------------

@@ -80,13 +80,13 @@ bool HandlerInfrastructureData::init()
 void HandlerInfrastructureData::onAssetChanged(const InfrastructureManagement::InstrumentationAsset &data, DataModification modType)
 {
  // nur die MountingPointType::MeteoDataUnit bearbeiten...
-  if (data.mountingPointTypeId() != InfrastructureManagement::MountingPointType::MeteoDataUnit)
+  if (data.mountingPointTypeId != InfrastructureManagement::MountingPointType::MeteoDataUnit)
    return;

  INFO_LOG(m_logger) << "onAssetChanged()"
-                     << " assetId: " << data.id()
-                     << " mountingPointTypeId: " << data.mountingPointTypeId()
-                     << " name: " << data.name();
+                     << " assetId: " << data.id
+                     << " mountingPointTypeId: " << data.mountingPointTypeId
+                     << " name: " << data.name;

  switch (modType)
  {
@@ -108,10 +108,10 @@ void HandlerInfrastructureData::onMountingPointAssetChanged(const Infrastructure
  {
  case DataModification::eAdded:
  case DataModification::eModified:
-    m_mountingPointAssetsMap.insert(data.assetId(), data.structureElementId());
+    m_mountingPointAssetsMap.insert(data.assetId, data.structureElementId);
    break;
  case DataModification::eRemoved:
-    m_mountingPointAssetsMap.remove(data.assetId());
+    m_mountingPointAssetsMap.remove(data.assetId);
    break;
  }
 } // end of onMountingPointAssetChanged()
@@ -123,10 +123,10 @@ void HandlerInfrastructureData::onMainStructureElementChanged(const Infrastructu
  {
  case DataModification::eAdded:
  case DataModification::eModified:
-    m_mainStructureElements.insert(data.id(), data);
+    m_mainStructureElements.insert(data.id, data);
    break;
  case DataModification::eRemoved:
-    m_mainStructureElements.remove(data.id());
+    m_mainStructureElements.remove(data.id);
    break;
  }
 } // end of onMountingPointAssetChanged()
@@ -143,10 +143,10 @@ Core::GeoPosition HandlerInfrastructureData::getStructureElementPosition(int ass
  // Go through all MainStructureElements and search structureElementId
  for (const InfrastructureManagement::MainStructureElement &mse : m_mainStructureElements)
  {
-    for (const InfrastructureManagement::StructureElement &se : mse.elements())
+    for (const InfrastructureManagement::StructureElement &se : mse.elements)
    {
-      if (se.id() == seId)
-        return mse.geoPosition();
+      if (se.id == seId)
+        return mse.geoPosition;
    }
  }
  return Core::GeoPosition();
@@ -40,12 +40,12 @@ bool HandlerMeteoDataUnit::init()
 {
  delete m_tcpWS;
  QJsonParseError jError;
-  QJsonDocument doc(QJsonDocument::fromJson(m_asset.properties().c_str(), &jError));
+  QJsonDocument doc(QJsonDocument::fromJson(m_asset.properties.c_str(), &jError));
  if (jError.error != QJsonParseError::NoError ||
      !doc.isObject())
  {
    ERROR_LOG(m_logger) << "Can not initialize meteo data unit - properties are not parsable: "
-                        << jError.errorString() << " - '" << m_asset.properties() << "'";
+                        << jError.errorString() << " - '" << m_asset.properties << "'";
    return false;
  }
  QJsonObject obj(doc.object());
@@ -54,35 +54,35 @@ bool HandlerMeteoDataUnit::init()
  if (climatePort == 0 || windPort == 0)
  {
    ERROR_LOG(m_logger) << "Can not parse climate and/or wind port from properties: '" <<
-                        m_asset.properties() << "'";
+                        m_asset.properties << "'";
    return false;
  }

-  m_tcpWS = new TcpWeatherStation(m_asset.id(),
-                                  QString::fromStdString(m_asset.hostname()),
+  m_tcpWS = new TcpWeatherStation(m_asset.id,
+                                  QString::fromStdString(m_asset.hostname),
                                  climatePort,
                                  windPort);

  // init local MeteoData Values for compare
-  m_newMeteoData.id(m_asset.id());
-  m_newMeteoData.weatherStationId(m_asset.id());
-  m_newMeteoData.note(m_asset.name());
-  m_newMeteoData.isStaticMeteoData(false);
+  m_newMeteoData.id = m_asset.id;
+  m_newMeteoData.weatherStationId = m_asset.id;
+  m_newMeteoData.note = m_asset.name;
+  m_newMeteoData.isStaticMeteoData = false;

  // Position der MDU eintragen (GeoPosition2D)
  if (m_mainHandler->ism())
  {
-    const Core::GeoPosition geoPos = m_mainHandler->ism()->getStructureElementPosition(m_asset.id());
+    const Core::GeoPosition geoPos = m_mainHandler->ism()->getStructureElementPosition(m_asset.id);
    //GeoPos->GeoPos2D
-    m_newMeteoData.pos(Core::GeoPosition2D(geoPos.lon(), geoPos.lat()));
+    m_newMeteoData.pos = Core::GeoPosition2D(geoPos.lon, geoPos.lat);
  }


-  m_newMeteoData.pressure(800.0);
-  m_newMeteoData.humidity(0.0);
-  m_newMeteoData.temperature(0.0);
-  m_newMeteoData.windSpeed(0.0);
-  m_newMeteoData.windDirection(0.0);
+  m_newMeteoData.pressure = 800.0;
+  m_newMeteoData.humidity = 0.0;
+  m_newMeteoData.temperature = 0.0;
+  m_newMeteoData.windSpeed = 0.0;
+  m_newMeteoData.windDirection = 0.0;

  m_lastMeteoData = m_newMeteoData;

@@ -98,22 +98,22 @@ void HandlerMeteoDataUnit::onMeteoDataChanged(int id,
                                              float pressure, float temperature, float humidity,
                                              float direction, float speed, bool climateOk, bool windOk)
 {
-  m_newMeteoData.id(id);
-  m_newMeteoData.pressure(pressure);           // in hPa
-  m_newMeteoData.temperature(temperature);     // in Grad Celsius
-  m_newMeteoData.humidity(humidity);           // % rel. Feuchte
-  m_newMeteoData.windDirection(direction);     // Grad, Nordbezogen mathem. negativ
-  m_newMeteoData.windSpeed(speed);             // in m/s
-  m_newMeteoData.climateOk(climateOk);
-  m_newMeteoData.windOk(windOk);
+  m_newMeteoData.id = id;
+  m_newMeteoData.pressure = pressure;           // in hPa
+  m_newMeteoData.temperature = temperature;     // in Grad Celsius
+  m_newMeteoData.humidity = humidity;           // % rel. Feuchte
+  m_newMeteoData.windDirection = direction;     // Grad, Nordbezogen mathem. negativ
+  m_newMeteoData.windSpeed = speed;             // in m/s
+  m_newMeteoData.climateOk = climateOk;
+  m_newMeteoData.windOk = windOk;

  // Position der MDU eintragen (falls sie noch nicht beim init() ermittelt werden konnte)
-  if (m_lastMeteoData.pos() == Core::GeoPosition2D())
+  if (m_lastMeteoData.pos == Core::GeoPosition2D())
  {
    if (m_mainHandler->ism())
    {
-      const Core::GeoPosition geoPos = m_mainHandler->ism()->getStructureElementPosition(m_asset.id());
-      m_newMeteoData.pos(Core::GeoPosition2D(geoPos.lon(), geoPos.lat()));
+      const Core::GeoPosition geoPos = m_mainHandler->ism()->getStructureElementPosition(m_asset.id);
+      m_newMeteoData.pos = Core::GeoPosition2D(geoPos.lon, geoPos.lat);
    }
  }

@@ -134,7 +134,7 @@ void HandlerMeteoDataUnit::onPublishData()
  MeteoDataManagement::MeteoData ddsData;

  ddsData = m_newMeteoData;
-  ddsData.timeStamp(m_mainHandler->dds()->currentPartitionTime());
+  ddsData.timeStamp = m_mainHandler->dds()->currentPartitionTime();

  INFO_LOG(m_logger) << "Publish dynamic MeteoData to dds: " << ddsData;

@@ -41,7 +41,7 @@ bool HandlerMeteoDataUnits::addMeteoDataUnit(const InfrastructureManagement::Ins
  removeMeteoDataUnit(asset); // just to be sure

  HandlerMeteoDataUnit *hMDU = new HandlerMeteoDataUnit(m_mainHandler, asset);
-  m_handlerMeteoDataUnitsMap.insert(asset.id(), hMDU);
+  m_handlerMeteoDataUnitsMap.insert(asset.id, hMDU);

  return false;
 } // end of addMeteoDataUnit()
@@ -50,7 +50,7 @@ bool HandlerMeteoDataUnits::addMeteoDataUnit(const InfrastructureManagement::Ins
 bool HandlerMeteoDataUnits::removeMeteoDataUnit(const InfrastructureManagement::InstrumentationAsset &asset)
 {
  INFO_LOG(m_logger) << "removeMeteoDataUnit: " << asset;
-  auto it = m_handlerMeteoDataUnitsMap.find(asset.id());
+  auto it = m_handlerMeteoDataUnitsMap.find(asset.id);
  if (it == m_handlerMeteoDataUnitsMap.end())
    return false;

@@ -73,11 +73,11 @@ void HandlerStaticMeteoData::onStaticMeteoDataModifyRequest(const rti::core::Sam
 {
  INFO_LOG(m_logger) << "onStaticMeteoDataModifyRequest: " << request;

-  Core::FunctionReplyObject rep(request.id());
+  Core::FunctionReplyObject rep(request.id);

  if (!updateStaticMeteoDatainDB(request))
  {
-    rep = Core::FunctionReplyObject(request.id(), tr_lts("dds", "Update database failed"));
+    rep = Core::FunctionReplyObject(request.id, tr_lts("dds", "Update database failed"));
    m_ddsHandler->fts()->staticMeteoDataModifyReply(cookie, rep);
    return;
  }
@@ -92,7 +92,7 @@ void HandlerStaticMeteoData::onStaticMeteoDataModifyRequest(const rti::core::Sam

 bool HandlerStaticMeteoData::updateStaticMeteoDatainDB(const StaticMeteoDataModifyRequest &request)
 {
-  if (request.id() != m_dbStaticMeteoData.id)
+  if (request.id != m_dbStaticMeteoData.id)
  {
    WARNING_LOG(m_logger) << "Invalid id for db-table 'mdm_static_meteo_data'"
                          << m_dbStaticMeteoData.id
@@ -116,9 +116,9 @@ void HandlerStaticMeteoData::onPublishData()

  const auto note(tr_lts("dds", "static data"));

-  ddsData.isStaticMeteoData(true);
-  ddsData.note(note);
-  ddsData.weatherStationId(ddsData.id());  // MDUid == dbId
+  ddsData.isStaticMeteoData = true;
+  ddsData.note = note;
+  ddsData.weatherStationId = ddsData.id;  // MDUid == dbId

  INFO_LOG(m_logger) << "Publish static MeteoData to dds: " << ddsData;

@@ -153,13 +153,13 @@ Database::MdmStaticMeteoData HandlerStaticMeteoData::ddsInputDataToDbData(const
 {
  Database::MdmStaticMeteoData dbData;

-  dbData.id             = ddsData.id();
-  dbData.timeStamp      = ddsData.timeStamp();
-  dbData.windDirection  = ddsData.windDirection();
-  dbData.windSpeed      = ddsData.windSpeed();
-  dbData.temperature    = ddsData.temperature();
-  dbData.pressure       = ddsData.pressure();
-  dbData.humidity       = ddsData.humidity();
+  dbData.id             = ddsData.id;
+  dbData.timeStamp      = ddsData.timeStamp;
+  dbData.windDirection  = ddsData.windDirection;
+  dbData.windSpeed      = ddsData.windSpeed;
+  dbData.temperature    = ddsData.temperature;
+  dbData.pressure       = ddsData.pressure;
+  dbData.humidity       = ddsData.humidity;

  return dbData;
 } // end of toDbData()
@@ -169,13 +169,13 @@ MeteoData HandlerStaticMeteoData::toDdsData(const Database::MdmStaticMeteoData &
 {
  MeteoData ddsData;

-  ddsData.id(dbData.id);
-  ddsData.timeStamp(dbData.timeStamp);
-  ddsData.windDirection(dbData.windDirection);
-  ddsData.windSpeed(dbData.windSpeed);
-  ddsData.temperature(dbData.temperature);
-  ddsData.pressure(dbData.pressure);
-  ddsData.humidity(dbData.humidity);
+  ddsData.id = dbData.id;
+  ddsData.timeStamp = dbData.timeStamp;
+  ddsData.windDirection = dbData.windDirection;
+  ddsData.windSpeed = dbData.windSpeed;
+  ddsData.temperature = dbData.temperature;
+  ddsData.pressure = dbData.pressure;
+  ddsData.humidity = dbData.humidity;

  return ddsData;
 } // end of toDdsData()
@@ -53,7 +53,7 @@ void TcpSocket::doConnect()
          this, &TcpSocket::onConnected);
  connect(m_socket, &QTcpSocket::disconnected,
          this, &TcpSocket::onDisonnected);
-  connect(m_socket, QOverload<QAbstractSocket::SocketError>::of(&QTcpSocket::error),
+  connect(m_socket, &QTcpSocket::errorOccurred,
          this, &TcpSocket::onError);
  connect(m_socket, &QTcpSocket::readyRead,
          this, &TcpSocket::onReadyRead);
@@ -9,6 +9,7 @@
 #include "central_aes_byte_reader.h"

 #include <LtsUtilsCore/qbytearray_byteaccess.h>
+#include <AreaEffectSimulation/aes_enums.hpp>

 #include "main_handler.h"
 #include "settings.h"
@@ -387,7 +388,7 @@ bool CentralAesByteReader::getDdsEnumVal(size_t &pos, T &ddsEnumVal) const

  bool result = LtsUtils::get4Byte(m_data, pos, tempVal);

-  ddsEnumVal = static_cast<typename T::inner_enum>(tempVal);
+  ddsEnumVal = static_cast<T>(tempVal);

  return result;
 }
@@ -329,9 +329,9 @@ void HandlerOcSituationData::sendParticipantData(int requestId)
  }

  ParticipantManagement::ModifyParticipantDataRequest *newRequest = new ParticipantManagement::ModifyParticipantDataRequest();
-  newRequest->requestId(requestId);
-  newRequest->data(LtsUtils::convert<std::vector<ParticipantManagement::ParticipantData>>(m_participantData));
-  newRequest->forceAddWithId(true);
+  newRequest->requestId = requestId;
+  newRequest->data = LtsUtils::convert<std::vector<ParticipantManagement::ParticipantData>>(m_participantData);
+  newRequest->forceAddWithId = true;
  m_modifiyRequests.insert(requestId, newRequest);
  m_participantData.clear();

@@ -26,12 +26,12 @@ bool HandlerReportData::generateChargeAdminResult(const CreateModifyReportReques
  q.prepare(QLatin1String("INSERT INTO rep_charge_administration (report_id, effect_source_id, charge_type_id ) VALUES (:reportId, :effectSourceId, :chargeTypeId )"));
  q.bindValue(QLatin1String(":reportId"), reportId);

-  for (auto it1 = request.effectSources().begin(); it1 != request.effectSources().end(); ++it1)
+  for (auto it1 = request.effectSources.begin(); it1 != request.effectSources.end(); ++it1)
  {
    ProjectDataManagement::EffectSource effectSourceId = *it1;
-    q.bindValue(QLatin1String(":effectSourceId"), effectSourceId.underlying());
+    q.bindValue(QLatin1String(":effectSourceId"), static_cast<int>(effectSourceId));

-    for (auto it2 = request.chargeTypeIds().begin(); it2 != request.chargeTypeIds().end(); ++it2)
+    for (auto it2 = request.chargeTypeIds.begin(); it2 != request.chargeTypeIds.end(); ++it2)
    {
      int chargeTypeId = *it2;
      if (chargeTypeId == 0)
@@ -45,7 +45,7 @@ bool HandlerReportData::generateChargeAdminResult(const CreateModifyReportReques
        return false;
      }

-      if (!calculateStock(chargeTypeId, effectSourceId, request.startTime(), request.endTime(), request.partyId(), reportId))
+      if (!calculateStock(chargeTypeId, effectSourceId, request.startTime, request.endTime, request.partyId, reportId))
        return false;
    }
  }
@@ -69,7 +69,7 @@ bool HandlerReportData::calculateStock(int chargeTypeId, const ProjectDataManage
  QString stmt = QLatin1String("SELECT amount, planned, used, sample_time, charge_type_id "
                               " FROM rec_charge_administration "
                               " WHERE effect_source_id = ")
-                 + QString::number(es.underlying()) + QLatin1String(" AND sample_time > 0 AND sample_time < ") + QString::number(startTime)
+                 + QString::number(static_cast<int>(es)) + QLatin1String(" AND sample_time > 0 AND sample_time < ") + QString::number(startTime)
                 + QLatin1String(" AND party_id = ") + QString::number(partyId) + QLatin1String(" AND charge_type_id = ") + QString::number(chargeTypeId)
                 + QLatin1String(" ORDER BY sample_time DESC LIMIT 1");

@@ -112,7 +112,7 @@ bool HandlerReportData::calculateStock(int chargeTypeId, const ProjectDataManage
                       " FROM rec_charge_administration "
                       " WHERE sample_time >= ")
         + QString::number(startTime) + QLatin1String(" AND sample_time <= ") + QString::number(endTime) + QLatin1String(" AND party_id = ") + QString::number(partyId)
-         + QLatin1String(" AND charge_type_id = ") + QString::number(chargeTypeId) + QLatin1String(" AND effect_source_id = ") + QString::number(es.underlying())
+         + QLatin1String(" AND charge_type_id = ") + QString::number(chargeTypeId) + QLatin1String(" AND effect_source_id = ") + QString::number(static_cast<int>(es))
         + QLatin1String(" ORDER BY sample_time ");

  if (!qSelect.exec(stmt))
@@ -151,7 +151,7 @@ bool HandlerReportData::calculateStock(int chargeTypeId, const ProjectDataManage
         + QString::number(chargeData.chargePlanned) + QLatin1String(", ") + QLatin1String(" charge_available = ")
         + QString::number(chargeData.chargeQuantity - chargeData.chargePlanned) + QLatin1String(" WHERE report_id = ") + QString::number(reportId)
         + QLatin1String(" AND charge_type_id = ") + QString::number(chargeData.chargeTypeId) + QLatin1String(" AND effect_source_id = ")
-         + QString::number(es.underlying());
+         + QString::number(static_cast<int>(es));

  DEBUG_LOG(m_logger) << "Update statement: " << stmt;

@@ -21,8 +21,8 @@ bool HandlerReportData::generateMedevacNineLinerResult(const CreateModifyReportR
 {
  INFO_LOG(m_logger) <<  "Start generateMedevacNineLinerResult ";

-  LtsCoordTrans::UtmCoordinate coord(LtsCoordTrans::UtmCoordinate::fromGeographic(request.cornerBottomLeft().lon(),
-                                                                                  request.cornerBottomLeft().lat()));
+  LtsCoordTrans::UtmCoordinate coord(LtsCoordTrans::UtmCoordinate::fromGeographic(request.cornerBottomLeft.lon,
+                                                                                  request.cornerBottomLeft.lat));

  DBTransaction trans(m_db->database());

@@ -38,16 +38,16 @@ bool HandlerReportData::generateMedevacNineLinerResult(const CreateModifyReportR
  NSqlQuery q(m_db->database());  
  q.setForwardOnly(false);

-  QString stmt = QLatin1String("SELECT id FROM san_nine_liner WHERE last_modified >= ") + QString::number(request.startTime()) +
-                 QLatin1String(" AND last_modified <= ") + QString::number(request.endTime());
+  QString stmt = QLatin1String("SELECT id FROM san_nine_liner WHERE last_modified >= ") + QString::number(request.startTime) +
+                 QLatin1String(" AND last_modified <= ") + QString::number(request.endTime);


-  if (request.width() > 0 && request.height() > 0)
+  if (request.width > 0 && request.height > 0)
  {
    DEBUG_LOG(m_logger) << "#### Filtering data on geographic position";

-    double x1 = coord.x + request.height();
-    double y1 = coord.y + request.width();
+    double x1 = coord.x + request.height;
+    double y1 = coord.y + request.width;
    DEBUG_LOG(m_logger) << "#### (x,x1,y,y1) = (" << coord.x << "," << x1 << "," << coord.y << "," << y1 << ")";

    stmt += QLatin1String(" AND position_x_m >= ") + QString::number(coord.x);
@@ -65,8 +65,8 @@ bool HandlerReportData::generateMedevacNineLinerResult(const CreateModifyReportR

  if (!q.exec(stmt))
  {
-    ERROR_LOG(m_logger) << "Error while selecting sanNineLiners for area (x) " << request.cornerBottomLeft().lon() << ", (y)" << request.cornerBottomLeft().lat()
-                        << " width: " << request.width() << ", height: " << request.height();
+    ERROR_LOG(m_logger) << "Error while selecting sanNineLiners for area (x) " << request.cornerBottomLeft.lon << ", (y)" << request.cornerBottomLeft.lat
+                        << " width: " << request.width << ", height: " << request.height;
    ERROR_LOG(m_logger) << "stmt: " << stmt;
    return false;
  }
@@ -17,11 +17,11 @@ bool HandlerReportData::generateAirSupportResult(const CreateModifyReportRequest
 {
  INFO_LOG(m_logger) <<  "Start  generateAirSupportResult - reportId: " << reportId;

-  if (request.chargeTypeIds().size() <= 0 || request.participantTypes().size() <= 0)
+  if (request.chargeTypeIds.size() <= 0 || request.participantTypes.size() <= 0)
  {
    ERROR_LOG(m_logger) << "No elements selected to generate the report";
-    DEBUG_LOG(m_logger) << "request.chargeTypeIds().size()" << request.chargeTypeIds().size();    
-    DEBUG_LOG(m_logger) << "request.participantTypes().size()" << request.participantTypes().size();
+    DEBUG_LOG(m_logger) << "request.chargeTypeIds().size()" << request.chargeTypeIds.size();
+    DEBUG_LOG(m_logger) << "request.participantTypes().size()" << request.participantTypes.size();
    return false;
  }

@@ -49,9 +49,9 @@ bool HandlerReportData::generateAirSupportResult(const CreateModifyReportRequest
                              " (event_time BETWEEN :startTime AND :endTime) AND "
                              " charge_type_id = :chargeId AND ");

-  if (request.participantTypes().size() > 0)
+  if (request.participantTypes.size() > 0)
  {
-    const QString pTypeIdsStr = intVecToString(request.participantTypes());
+    const QString pTypeIdsStr = intVecToString(request.participantTypes);
    stmtSelect2 += QStringLiteral(" participant_type_id IN (%1) ").arg(pTypeIdsStr);
  }

@@ -75,9 +75,9 @@ bool HandlerReportData::generateAirSupportResult(const CreateModifyReportRequest

  qInsert.bindValue(QStringLiteral(":reportId"), reportId);

-  qSelect1.bindValue(QStringLiteral(":partyId"),   request.partyId());
-  qSelect1.bindValue(QStringLiteral(":startTime"), request.startTime());
-  qSelect1.bindValue(QStringLiteral(":endTime"),   request.endTime());
+  qSelect1.bindValue(QStringLiteral(":partyId"),   request.partyId);
+  qSelect1.bindValue(QStringLiteral(":startTime"), static_cast<qint64>(request.startTime));
+  qSelect1.bindValue(QStringLiteral(":endTime"),   static_cast<qint64>(request.endTime));

  if (!qSelect1.exec())
  {
@@ -86,9 +86,9 @@ bool HandlerReportData::generateAirSupportResult(const CreateModifyReportRequest
  }

  DEBUG_LOG(m_logger) << "stmtSelect1: " << stmtSelect1;
-  DEBUG_LOG(m_logger) << "partyId: " << request.partyId();
-  DEBUG_LOG(m_logger) << "startTime: " << request.startTime();
-  DEBUG_LOG(m_logger) << "endTime: " << request.endTime();
+  DEBUG_LOG(m_logger) << "partyId: " << request.partyId;
+  DEBUG_LOG(m_logger) << "startTime: " << request.startTime;
+  DEBUG_LOG(m_logger) << "endTime: " << request.endTime;

  // QMap<chargeTypeId, impacts>
  QMap<int,int> impactDataMap;
@@ -114,9 +114,9 @@ bool HandlerReportData::generateAirSupportResult(const CreateModifyReportRequest
    return false;
  }

-  qSelect1.bindValue(QStringLiteral(":partyId"),   request.partyId());
-  qSelect1.bindValue(QStringLiteral(":startTime"), request.startTime());
-  qSelect1.bindValue(QStringLiteral(":endTime"),   request.endTime());
+  qSelect1.bindValue(QStringLiteral(":partyId"),   request.partyId);
+  qSelect1.bindValue(QStringLiteral(":startTime"), static_cast<qint64>(request.startTime));
+  qSelect1.bindValue(QStringLiteral(":endTime"),   static_cast<qint64>(request.endTime));

  if (!qSelect1.exec())
  {
@@ -125,9 +125,9 @@ bool HandlerReportData::generateAirSupportResult(const CreateModifyReportRequest
  }

  DEBUG_LOG(m_logger) << "stmtSelect1: " << stmtSelect1;
-  DEBUG_LOG(m_logger) << "partyId: " << request.partyId();
-  DEBUG_LOG(m_logger) << "startTime: " << request.startTime();
-  DEBUG_LOG(m_logger) << "endTime: " << request.endTime();
+  DEBUG_LOG(m_logger) << "partyId: " << request.partyId;
+  DEBUG_LOG(m_logger) << "startTime: " << request.startTime;
+  DEBUG_LOG(m_logger) << "endTime: " << request.endTime;

  // QMap<chargeTypeId, eventTime>
  QMap<int,qint64> minEventTimeMap;
@@ -152,9 +152,9 @@ bool HandlerReportData::generateAirSupportResult(const CreateModifyReportRequest
    return false;
  }

-  qSelect1.bindValue(QStringLiteral(":partyId"),   request.partyId());
-  qSelect1.bindValue(QStringLiteral(":startTime"), request.startTime());
-  qSelect1.bindValue(QStringLiteral(":endTime"),   request.endTime());
+  qSelect1.bindValue(QStringLiteral(":partyId"),   request.partyId);
+  qSelect1.bindValue(QStringLiteral(":startTime"), static_cast<qint64>(request.startTime));
+  qSelect1.bindValue(QStringLiteral(":endTime"),   static_cast<qint64>(request.endTime));

  if (!qSelect1.exec())
  {
@@ -163,9 +163,9 @@ bool HandlerReportData::generateAirSupportResult(const CreateModifyReportRequest
  }

  DEBUG_LOG(m_logger) << "stmtSelect1: " << stmtSelect1;
-  DEBUG_LOG(m_logger) << "partyId: " << request.partyId();
-  DEBUG_LOG(m_logger) << "startTime: " << request.startTime();
-  DEBUG_LOG(m_logger) << "endTime: " << request.endTime();
+  DEBUG_LOG(m_logger) << "partyId: " << request.partyId;
+  DEBUG_LOG(m_logger) << "startTime: " << request.startTime;
+  DEBUG_LOG(m_logger) << "endTime: " << request.endTime;

  // QMap<chargeTypeId, eventTime>
  QMap<int,qint64> maxEventTimeMap;
@@ -187,7 +187,7 @@ bool HandlerReportData::generateAirSupportResult(const CreateModifyReportRequest
    DEBUG_LOG(m_logger) << "Impacts = " << impacts;

    // use only requested chargeTypeIds
-    if (std::find(request.chargeTypeIds().begin(), request.chargeTypeIds().end(), chargeTypeId) == request.chargeTypeIds().end() || chargeTypeId == 0)
+    if (std::find(request.chargeTypeIds.begin(), request.chargeTypeIds.end(), chargeTypeId) == request.chargeTypeIds.end() || chargeTypeId == 0)
    {
      WARNING_LOG(m_logger) << "ChargeTypeId " << chargeTypeId << " not found in list";
      continue;
@@ -197,22 +197,22 @@ bool HandlerReportData::generateAirSupportResult(const CreateModifyReportRequest
    timeoutTimer.start();

    qint64 t1;
-    t1 = request.startTime();
-    while (t1 <= request.endTime())
+    t1 = request.startTime;
+    while (t1 <= request.endTime)
    {
      checkElapsedTimer(timeoutTimer);
-      qint64 t2 = qMin(qMax(t1, t1 + request.intervalTime() - 1), request.endTime());
-      if (request.intervalTime() == 0) // || request.visualisationType() == VisualisationType::Table)
-        t2 = request.endTime();
+      qint64 t2 = qMin(qMax(t1, t1 + request.intervalTime - 1), request.endTime);
+      if (request.intervalTime == 0) // || request.visualisationType == VisualisationType::Table)
+        t2 = request.endTime;

      qInsert.bindValue(QStringLiteral(":start"),        t1);
      qInsert.bindValue(QStringLiteral(":end"),          t2);      
      qInsert.bindValue(QStringLiteral(":chargeTypeId"), chargeTypeId);

      DEBUG_LOG(m_logger) << " Inserting: reportId, start, end, interval, name = " << reportId << " , " << t1 << " , " << t2 << " , "
-                          << request.intervalTime();
+                          << request.intervalTime;

-      qSelect2.bindValue(QStringLiteral(":aesPartyId"), request.partyId());
+      qSelect2.bindValue(QStringLiteral(":aesPartyId"), request.partyId);
      qSelect2.bindValue(QStringLiteral(":chargeId"),   chargeTypeId);
      qSelect2.bindValue(QStringLiteral(":startTime"),  t1);
      qSelect2.bindValue(QStringLiteral(":endTime"),    t2);
@@ -220,7 +220,7 @@ bool HandlerReportData::generateAirSupportResult(const CreateModifyReportRequest
      DEBUG_LOG(m_logger) << "stmtSelect2: " << stmtSelect2;
      DEBUG_LOG(m_logger) << "startTime: " << t1;
      DEBUG_LOG(m_logger) << "endTime: " << t2;
-      DEBUG_LOG(m_logger) << "aesPartyId: " << request.partyId();
+      DEBUG_LOG(m_logger) << "aesPartyId: " << request.partyId;
      DEBUG_LOG(m_logger) << "chargeTypeId: " << chargeTypeId;

      QMap<int, QVector<int>> vbgMap;
@@ -238,9 +238,9 @@ bool HandlerReportData::generateAirSupportResult(const CreateModifyReportRequest

        if (!vbgMap.contains(vbg))
          vbgMap.insert(vbg, {0, 0, 0});
-        if (vbg == ProjectDataManagement::VulnerabilityState::CombatReady ||
-            vbg == ProjectDataManagement::VulnerabilityState::NearMiss ||
-            vbg == ProjectDataManagement::VulnerabilityState::HitWithNoEffect)
+        if (vbg == static_cast<int>(ProjectDataManagement::VulnerabilityState::VulnerabilityState_CombatReady) ||
+            vbg == static_cast<int>(ProjectDataManagement::VulnerabilityState::VulnerabilityState_NearMiss) ||
+            vbg == static_cast<int>(ProjectDataManagement::VulnerabilityState::VulnerabilityState_HitWithNoEffect))
          continue;

        vbgMap[vbg][0] += qSelect2.value(1).toInt(); // hits
@@ -274,7 +274,7 @@ bool HandlerReportData::generateAirSupportResult(const CreateModifyReportRequest

      if (vbgMap.isEmpty())
      {
-        qInsert.bindValue(QStringLiteral(":vbg"),ProjectDataManagement::VulnerabilityState::NearMiss);
+        qInsert.bindValue(QStringLiteral(":vbg"),static_cast<int>(ProjectDataManagement::VulnerabilityState::VulnerabilityState_NearMiss));
        qInsert.bindValue(QStringLiteral(":impacts"), impacts);
        qInsert.bindValue(QStringLiteral(":hit"), 0);
        qInsert.bindValue(QStringLiteral(":hit_ff"), 0);
@@ -289,8 +289,8 @@ bool HandlerReportData::generateAirSupportResult(const CreateModifyReportRequest
        }
      }

-      t1 += request.intervalTime();
-      if (request.intervalTime() == 0) // || request.visualisationType() == VisualisationType::Table)
+      t1 += request.intervalTime;
+      if (request.intervalTime == 0) // || request.visualisationType == VisualisationType::Table)
        break;
    }
  }
@@ -40,7 +40,7 @@ bool HandlerReportData::generateBuildingDamageResult(const CreateModifyReportReq
  m_buildingDamageData.clear();

  // in chargeTypeIds are saved buildingIds
-  for (auto it = request.chargeTypeIds().begin(); it != request.chargeTypeIds().end(); ++it)
+  for (auto it = request.chargeTypeIds.begin(); it != request.chargeTypeIds.end(); ++it)
  {
    BuildingDamageData bdDataStart, bdDataEnd;
    int buildingId = *it;
@@ -50,10 +50,10 @@ bool HandlerReportData::generateBuildingDamageResult(const CreateModifyReportReq
      continue;

    bdDataStart.buildingId = buildingId;
-    bdDataStart.timePoint  = request.startTime();
+    bdDataStart.timePoint  = request.startTime;

    bdDataEnd.buildingId   = buildingId;
-    bdDataEnd.timePoint    = request.endTime();
+    bdDataEnd.timePoint    = request.endTime;

    qSelect.bindValue(QStringLiteral(":buildingId"), bdDataStart.buildingId);

@@ -33,19 +33,19 @@ bool HandlerReportData::generateChargeResupplyResult(const CreateModifyReportReq
  QSet<int> usedGears;
  {
    QString stmt = QLatin1String("SELECT DISTINCT gear_id FROM rep_charge_resupply_data "
-                                 " WHERE (event_time BETWEEN ") + QString::number(request.startTime()) + QLatin1String(" AND ") + QString::number(request.endTime()) + QLatin1String(") ");
+                                 " WHERE (event_time BETWEEN ") + QString::number(request.startTime) + QLatin1String(" AND ") + QString::number(request.endTime) + QLatin1String(") ");

    stmt += QLatin1String(" AND charge_type_id != 0");

-    if (request.chargeTypeIds().size() > 0)
+    if (request.chargeTypeIds.size() > 0)
    {
-      const QString chargeTypeIds = intVecToString(request.chargeTypeIds());
+      const QString chargeTypeIds = intVecToString(request.chargeTypeIds);
      stmt += QLatin1String(" AND (charge_type_id IN (") + chargeTypeIds + QLatin1String(") OR charge_type_id < 0) ");
    }

-    if (request.participantIds().size() > 0)
+    if (request.participantIds.size() > 0)
    {
-      const QString participants = intVecToString(request.participantIds());
+      const QString participants = intVecToString(request.participantIds);
      stmt += QStringLiteral(" AND participant_id IN (%1)").arg(participants);
    }

@@ -70,14 +70,14 @@ bool HandlerReportData::generateChargeResupplyResult(const CreateModifyReportReq
  {
    QString stmt = QLatin1String("SELECT party_id, event_time, participant_id, participant_type_id, charge_type_id, gear_type_id, "
                                 "gear_id, charge_fired, charge_remain FROM rep_charge_resupply_data "
-                                 " WHERE (event_time BETWEEN ") + QString::number(request.startTime()) + QLatin1String(" AND ") + QString::number(request.endTime()) + QLatin1String(") ");
+                                 " WHERE (event_time BETWEEN ") + QString::number(request.startTime) + QLatin1String(" AND ") + QString::number(request.endTime) + QLatin1String(") ");

    stmt += QLatin1String(" AND charge_type_id != 0 ");

    // for gears with more than one possible charge
-    if (request.chargeTypeIds().size() > 0)
+    if (request.chargeTypeIds.size() > 0)
    {
-      const QString chargeTypeIds = intVecToString(request.chargeTypeIds());
+      const QString chargeTypeIds = intVecToString(request.chargeTypeIds);
      stmt += QLatin1String(" AND (charge_type_id IN (") + chargeTypeIds + QLatin1String(") OR charge_type_id < 0) ");
    }

@@ -91,9 +91,9 @@ bool HandlerReportData::generateChargeResupplyResult(const CreateModifyReportReq
      stmt += QLatin1String(" AND gear_id IN (") + gears + QLatin1String(")");
    }

-    if (request.participantIds().size() > 0)
+    if (request.participantIds.size() > 0)
    {
-      const QString participants = intVecToString(request.participantIds());
+      const QString participants = intVecToString(request.participantIds);
      stmt += QStringLiteral(" AND participant_id IN (%1)").arg(participants);
    }

@@ -170,13 +170,13 @@ bool HandlerReportData::generateChargeResupplyResult(const CreateModifyReportReq

  // Alle Teilnehmer, die in der angegebenen Zeit kein Telegramm erzeugt haben, hier
  // hinzufügen
-  for (const int participantId : request.participantIds())
+  for (const int participantId : request.participantIds)
  {
    if (!m_crPartMap.contains(participantId))
    {
      checkElapsedTimer(timeoutTimer);
      // letzte Waffenzuordnung & Munitionsvorat holen und in m_crPartMap / m_crGear eintragen
-      getLastGearSetting(participantId, request.chargeTypeIds(), request.startTime());
+      getLastGearSetting(participantId, request.chargeTypeIds, request.startTime);
    }
  }

@@ -308,7 +308,7 @@ bool HandlerReportData::generateChargeResupplyResult(const CreateModifyReportReq
          }
          else
          {
-            start = getStart(x.participantId, x.gearId, x.chargeTypeId, request.startTime(), 0);
+            start = getStart(x.participantId, x.gearId, x.chargeTypeId, request.startTime, 0);
            DEBUG_LOG(m_logger) << "### ChargeType changed - 1st: MunV, therefore, START = " << start;
          }
        }
@@ -435,7 +435,7 @@ bool HandlerReportData::generateChargeResupplyResult(const CreateModifyReportReq
  {
    for (const ChargeResupplyResult &res : qAsConst(ctmap)) // Per ChargeType
    {
-      if (request.participantIds().size() > 0 && !contains(request.participantIds(), res.participantId))
+      if (request.participantIds.size() > 0 && !contains(request.participantIds, res.participantId))
        continue;

      finalMap[res.participantTypeId][res.chargeTypeId].chargeTypeId      = res.chargeTypeId;
@@ -102,21 +102,21 @@ void HandlerReportData::onCreateModifyReportRequest(const rti::core::SampleIdent

  m_updateReportCookie = cookie;

-  m_reply.errorString(std::string());
-  m_reply.replyState(Core::FtReplyState::InProgress);
-  m_reply.currentTime(QDateTime::currentMSecsSinceEpoch());
+  m_reply.errorString = std::string();
+  m_reply.replyState = Core::FtReplyState::InProgress;
+  m_reply.currentTime = QDateTime::currentMSecsSinceEpoch();

  m_ddsHandler->fts()->createModifyReportReply(m_updateReportCookie, m_reply);

  qint32 reportId;
  bool ok = true;

-  if (request.id() == 0) // add
+  if (request.id == 0) // add
    reportId = 0;
  else // modify
  {
-    reportId = request.id();
-    ReportType repType = request.reportType(); // assuming this cannot be changed by this request
+    reportId = request.id;
+    ReportType repType = request.reportType; // assuming this cannot be changed by this request
    ok = removeReportData(reportId, repType); // remove old data
    if (!ok)
      WARNING_LOG(m_logger) << "Cannot remove old data for report id = " << reportId;
@@ -125,17 +125,17 @@ void HandlerReportData::onCreateModifyReportRequest(const rti::core::SampleIdent
  if (!insertReportData(request, reportId))
  {
    ERROR_LOG(m_logger) << "Error while creating report!";
-    m_reply.errorString(tr_lts("dds","Error while creating report"));
-    m_reply.replyState(Core::FtReplyState::Error);
-    m_reply.currentTime(QDateTime::currentMSecsSinceEpoch());
+    m_reply.errorString = tr_lts("dds","Error while creating report");
+    m_reply.replyState = Core::FtReplyState::Error;
+    m_reply.currentTime = QDateTime::currentMSecsSinceEpoch();
    m_ddsHandler->fts()->createModifyReportReply(m_updateReportCookie, m_reply);
    return;
  }

-  m_reply.id(reportId);
+  m_reply.id = reportId;

  // Generate data per reportType
-  switch (request.reportType().underlying())
+  switch (request.reportType)
  {
  case ReportManagement::ReportType::UnitPower:
  {
@@ -226,16 +226,16 @@ void HandlerReportData::onCreateModifyReportRequest(const rti::core::SampleIdent
    objRep->removeObject();
    m_objReportMap.remove(reportId);

-    ERROR_LOG(m_logger) << "Error generating report with type " << request.reportType();
-    m_reply.errorString(tr_lts("dds", "Error generating report"));
-    m_reply.replyState(Core::FtReplyState::Error);
-    m_reply.currentTime(QDateTime::currentMSecsSinceEpoch());
+    ERROR_LOG(m_logger) << "Error generating report with type " << request.reportType;
+    m_reply.errorString = tr_lts("dds", "Error generating report");
+    m_reply.replyState = Core::FtReplyState::Error;
+    m_reply.currentTime = QDateTime::currentMSecsSinceEpoch();
  }
  else
  {
-    m_reply.errorString(std::string());
-    m_reply.replyState(Core::FtReplyState::Completed);
-    m_reply.currentTime(QDateTime::currentMSecsSinceEpoch());
+    m_reply.errorString = std::string();
+    m_reply.replyState = Core::FtReplyState::Completed;
+    m_reply.currentTime = QDateTime::currentMSecsSinceEpoch();
  }

  m_ddsHandler->fts()->createModifyReportReply(m_updateReportCookie, m_reply);
@@ -247,13 +247,13 @@ void HandlerReportData::onRemoveReportRequest(const rti::core::SampleIdentity &c
 {
  DEBUG_LOG(m_logger) << "onRemoveReportRequest " << request;

-  int reportId = request.id();
+  int reportId = request.id;

  Core::FunctionReplyObject ret;
  ObjectReportInfo *ifs = m_objReportMap.value(reportId);
  if (ifs == nullptr)
  {
-    ret = Core::FunctionReplyObject(request.id(), tr_lts("dds", "Report with id %1 not found")).arg(reportId);
+    ret = Core::FunctionReplyObject(request.id, tr_lts("dds", "Report with id %1 not found")).arg(reportId);
    m_ddsHandler->fts()->removeReportReply(cookie, ret);
    return;
  }
@@ -286,7 +286,7 @@ bool HandlerReportData::removeReportData(int reportId, ReportType repType)

  bool ok = true;

-  switch (repType.underlying())
+  switch (repType)
  {
  case ReportManagement::ReportType::UnitPower:
  {
@@ -380,10 +380,10 @@ void HandlerReportData::onReportChangeStatusRequest(const rti::core::SampleIdent
                                                    const ReportChangeStatusRequest &request)
 {
  DEBUG_LOG(m_logger) << "onReportChangeStatusRequest " << request;
-  ObjectReportInfo *ifs = m_objReportMap.value(request.id());
+  ObjectReportInfo *ifs = m_objReportMap.value(request.id);
  if (ifs == nullptr)
  {
-    Core::FunctionReplyObject ret = Core::FunctionReplyObject(request.id(), tr_lts("dds", "Report with id %1 not found")).arg(request.id());
+    Core::FunctionReplyObject ret = Core::FunctionReplyObject(request.id, tr_lts("dds", "Report with id %1 not found")).arg(request.id);
    m_ddsHandler->fts()->reportChangeStatusReply(cookie, ret);
    return;
  }
@@ -399,26 +399,26 @@ bool HandlerReportData::insertReportData(const CreateModifyReportRequest &reques
 {
  Database::RepReport data;

-  data.name              = QString::fromStdString(request.name());
-  data.description       = QString::fromStdString(request.description());
-  data.partyId           = request.partyId();
-  data.startTime         = request.startTime();
-  data.endTime           = request.endTime();
-  data.reportTypeId      = request.reportType();
-  data.visualisationType = request.visualisationType();
-  data.intervalTime      = request.intervalTime();
-  data.lastModified      = request.lastModified();
-  data.operatorId        = request.operatorId();
-  data.fileStatusId      = request.fileStatus();
+  data.name              = QString::fromStdString(request.name);
+  data.description       = QString::fromStdString(request.description);
+  data.partyId           = request.partyId;
+  data.startTime         = request.startTime;
+  data.endTime           = request.endTime;
+  data.reportTypeId      = request.reportType;
+  data.visualisationType = request.visualisationType;
+  data.intervalTime      = request.intervalTime;
+  data.lastModified      = request.lastModified;
+  data.operatorId        = request.operatorId;
+  data.fileStatusId      = request.fileStatus;
  // area
-  data.width             = request.width();
-  data.height            = request.height();
-  data.position          = QPointF(request.cornerBottomLeft().lon(), request.cornerBottomLeft().lat());
+  data.width             = request.width;
+  data.height            = request.height;
+  data.position          = QPointF(request.cornerBottomLeft.lon, request.cornerBottomLeft.lat);

  const auto participants = m_ppmDtc->participants();
  QJsonArray participantIdArray;
  QJsonArray participantNamesArray;
-  for (int id : request.participantIds())
+  for (int id : request.participantIds)
  {
    participantIdArray.append(QJsonValue(id));
    QJsonValue name = QJsonValue(m_ppmDtc->hierarchyFromParticipant(id, participants));
@@ -426,17 +426,17 @@ bool HandlerReportData::insertReportData(const CreateModifyReportRequest &reques
  }

  QJsonArray superiorIdsArray;
-  for (Superior sup : request.superiorIds())
+  for (Superior sup : request.superiorIds)
  {
    QJsonObject jsonData;
-    jsonData[QStringLiteral("participantId")] = sup.participantId();
-    jsonData[QStringLiteral("superiorId")]    = sup.superiorId();
+    jsonData[QStringLiteral("participantId")] = sup.participantId;
+    jsonData[QStringLiteral("superiorId")]    = sup.superiorId;
    superiorIdsArray.append(jsonData);
  }

  QJsonArray unitIdArray;
  QJsonArray unitNamesArray;
-  for (int id : request.unitIds())
+  for (int id : request.unitIds)
  {
    unitIdArray.append(QJsonValue(id));
    QJsonValue name = QJsonValue(m_ppmDtc->hierarchyFromParticipant(id, participants));
@@ -444,34 +444,34 @@ bool HandlerReportData::insertReportData(const CreateModifyReportRequest &reques
  }

  QJsonArray partTypeArray;
-  for (int id : request.participantTypes())
+  for (int id : request.participantTypes)
    partTypeArray.append(QJsonValue(id));

  QJsonArray chargeTypeIdsArray;
-  for (int id : request.chargeTypeIds())
+  for (int id : request.chargeTypeIds)
    chargeTypeIdsArray.append(QJsonValue(id));

  QJsonArray mineAreaIdsArray;
  QJsonArray mineAreaNamesArray;
-  for (int id : request.mineAreaIds())
+  for (int id : request.mineAreaIds)
  {
    mineAreaIdsArray.append(QJsonValue(id));
-    QJsonValue name = QJsonValue(QString::fromStdString(m_aesDtc->mineArea(id).name()));
+    QJsonValue name = QJsonValue(QString::fromStdString(m_aesDtc->mineArea(id).name));
    mineAreaNamesArray.append(name);
  }

  QJsonArray nbcIdsArray;
  QJsonArray nbcNamesArray;
-  for (int id : request.nbcIds())
+  for (int id : request.nbcIds)
  {
    nbcIdsArray.append(QJsonValue(id));
-    QJsonValue name = QJsonValue(QString::fromStdString(m_aesDtc->bCContamination(id).name()));
+    QJsonValue name = QJsonValue(QString::fromStdString(m_aesDtc->bCContamination(id).name));
    nbcNamesArray.append(name);
  }

  QJsonArray effectSourceArray;
-  for (const ProjectDataManagement::EffectSource &es : request.effectSources())
-    effectSourceArray.append(QJsonValue(es.underlying()));
+  for (const ProjectDataManagement::EffectSource &es : request.effectSources)
+    effectSourceArray.append(QJsonValue(static_cast<int>(es)));

  QJsonObject obj;
  obj[QStringLiteral("participantIds")]   = participantIdArray;
@@ -480,7 +480,7 @@ bool HandlerReportData::insertReportData(const CreateModifyReportRequest &reques
  obj[QStringLiteral("superiorIds")]      = superiorIdsArray;
  obj[QStringLiteral("unitNames")]        = unitNamesArray;
  obj[QStringLiteral("participantTypes")] = partTypeArray;
-  obj[QStringLiteral("groupByParty")]     = request.groupByParty();
+  obj[QStringLiteral("groupByParty")]     = request.groupByParty;
  obj[QStringLiteral("chargeTypeIds")]    = chargeTypeIdsArray;
  obj[QStringLiteral("mineAreaIds")]      = mineAreaIdsArray;
  obj[QStringLiteral("mineAreaNames")]    = mineAreaNamesArray;
@@ -567,7 +567,7 @@ void HandlerReportData::checkElapsedTimer(QElapsedTimer &t)
 void HandlerReportData::updateReportReply()
 {
  DEBUG_LOG(m_logger) << "updateReportReply: " << m_reply;
-  m_reply.currentTime(QDateTime::currentMSecsSinceEpoch());
+  m_reply.currentTime = QDateTime::currentMSecsSinceEpoch();
  m_ddsHandler->fts()->createModifyReportReply(m_updateReportCookie, m_reply);
  m_ddsHandler->pacemaker()->publishState();
 }
@@ -88,7 +88,7 @@ struct AirSupportImpactData
 struct ChargeTypeData
 {
  int chargeTypeId = 0;
-  ProjectDataManagement::EffectSource effectSourceId = ProjectDataManagement::EffectSource::get_default();
+  ProjectDataManagement::EffectSource effectSourceId = ProjectDataManagement::EffectSource::ES_Unknown;
  int chargeQuantity = 0;
  int usedCharge = 0;
  int chargeAddition = 0;
@@ -17,12 +17,12 @@ bool HandlerReportData::generateFiringsResult(const CreateModifyReportRequest &r
 {
  INFO_LOG(m_logger) <<  "Start  generateFiringsResult - reportId: " << reportId;

-  if (request.chargeTypeIds().size() <= 0 || request.participantIds().size() <= 0 || request.participantTypes().size() <= 0)
+  if (request.chargeTypeIds.size() <= 0 || request.participantIds.size() <= 0 || request.participantTypes.size() <= 0)
  {
    ERROR_LOG(m_logger) << "No elements selected to generate the report";
-    DEBUG_LOG(m_logger) << "request.chargeTypeIds().size()" << request.chargeTypeIds().size();
-    DEBUG_LOG(m_logger) << "request.participantIds().size()" << request.participantIds().size();
-    DEBUG_LOG(m_logger) << "request.participantTypes().size()" << request.participantTypes().size();
+    DEBUG_LOG(m_logger) << "request.chargeTypeIds().size()" << request.chargeTypeIds.size();
+    DEBUG_LOG(m_logger) << "request.participantIds().size()" << request.participantIds.size();
+    DEBUG_LOG(m_logger) << "request.participantTypes().size()" << request.participantTypes.size();
    return false;
  }

@@ -37,9 +37,9 @@ bool HandlerReportData::generateFiringsResult(const CreateModifyReportRequest &r
                              "(event_time BETWEEN :startTime AND :endTime) AND "
                              " charge_type_id = :chargeId AND ");

-  if (request.participantTypes().size() > 0)
+  if (request.participantTypes.size() > 0)
  {
-    const QString pTypeIdsStr = intVecToString(request.participantTypes());
+    const QString pTypeIdsStr = intVecToString(request.participantTypes);
    stmtSelect += QStringLiteral(" participant_type_id IN (%1) ").arg(pTypeIdsStr);
  }

@@ -64,7 +64,7 @@ bool HandlerReportData::generateFiringsResult(const CreateModifyReportRequest &r

  QElapsedTimer timeoutTimer;
  timeoutTimer.start();
-  for (const int &chargeId : qAsConst(request.chargeTypeIds()))
+  for (const int &chargeId : qAsConst(request.chargeTypeIds))
  {
    if (chargeId == 0) continue; // skip 0

@@ -73,21 +73,21 @@ bool HandlerReportData::generateFiringsResult(const CreateModifyReportRequest &r
    DEBUG_LOG(m_logger) << "Charge id = " << chargeId;

    qint64 t1;
-    t1 = request.startTime();
-    while (t1 <= request.endTime())
+    t1 = request.startTime;
+    while (t1 <= request.endTime)
    {
      checkElapsedTimer(timeoutTimer);
-      qint64 t2 = qMin(qMax(t1, t1 + request.intervalTime() - 1), request.endTime());
-      if (request.intervalTime() == 0) // || request.visualisationType() == VisualisationType::Table)
-        t2 = request.endTime();
+      qint64 t2 = qMin(qMax(t1, t1 + request.intervalTime - 1), request.endTime);
+      if (request.intervalTime == 0) // || request.visualisationType == VisualisationType::Table)
+        t2 = request.endTime;

      qInsert.bindValue(QStringLiteral(":start"), t1);
      qInsert.bindValue(QStringLiteral(":end"), t2);

      DEBUG_LOG(m_logger) << " Inserting: reportId, start, end, interval = " << reportId << " , " << t1 << " , " << t2 << " , "
-                          << request.intervalTime();
+                          << request.intervalTime;

-      qSelect.bindValue(QStringLiteral(":partyId"), request.partyId());
+      qSelect.bindValue(QStringLiteral(":partyId"), request.partyId);
      qSelect.bindValue(QStringLiteral(":chargeId"), chargeId);
      qSelect.bindValue(QStringLiteral(":startTime"), t1);
      qSelect.bindValue(QStringLiteral(":endTime"), t2);
@@ -105,9 +105,9 @@ bool HandlerReportData::generateFiringsResult(const CreateModifyReportRequest &r
        int vbg = qSelect.value(0).toInt();
        if (!vbgMap.contains(vbg))
          vbgMap.insert(vbg, {0, 0, 0});
-        if (vbg == ProjectDataManagement::VulnerabilityState::CombatReady ||
-            vbg == ProjectDataManagement::VulnerabilityState::NearMiss ||
-            vbg == ProjectDataManagement::VulnerabilityState::HitWithNoEffect)
+        if (vbg == static_cast<int>(ProjectDataManagement::VulnerabilityState::VulnerabilityState_CombatReady) ||
+            vbg == static_cast<int>(ProjectDataManagement::VulnerabilityState::VulnerabilityState_NearMiss) ||
+            vbg == static_cast<int>(ProjectDataManagement::VulnerabilityState::VulnerabilityState_HitWithNoEffect))
          vbgMap[vbg][0] ++; // firings

        vbgMap[vbg][1] += qSelect.value(1).toInt(); // hits
@@ -131,8 +131,8 @@ bool HandlerReportData::generateFiringsResult(const CreateModifyReportRequest &r
        }
      }

-      t1 += request.intervalTime();
-      if (request.intervalTime() == 0) // || request.visualisationType() == VisualisationType::Table)
+      t1 += request.intervalTime;
+      if (request.intervalTime == 0) // || request.visualisationType == VisualisationType::Table)
        break;
    }
  }
@@ -40,9 +40,9 @@ bool HandlerReportGetData::init() { return true; }
 void HandlerReportGetData::onGetReportDataRequest(const rti::core::SampleIdentity &cookie, const GetReportDataRequest &request)
 {
  GetReportDataReply ret = getReportDataRequest(request);
-  if (ret.errorString().size() != 0)
+  if (ret.errorString.size() != 0)
  {
-    Core::FunctionReplyObject fro(ret.id(), ret.errorString(), ret.errorParams());
+    Core::FunctionReplyObject fro(ret.id, ret.errorString, ret.errorParams);
    WARNING_LOG(m_logger) << "error: " << fro();
  }
  m_ddsHandler->fts()->getReportDataReply(cookie, ret);
@@ -55,54 +55,54 @@ GetReportDataReply HandlerReportGetData::getReportDataRequest(const GetReportDat

  // Get data per reportType
  QByteArray reportData;
-  switch (request.reportType().underlying())
+  switch (request.reportType)
  {
    case ReportManagement::ReportType::UnitPower:
-      reportData = getUnitPowerResult(request.reportId());
+      reportData = getUnitPowerResult(request.reportId);
      break;
    case ReportManagement::ReportType::ParticipantDistance:
-      reportData = getParticipantDistanceResult(request.reportId());
+      reportData = getParticipantDistanceResult(request.reportId);
      break;
    case ReportManagement::ReportType::MineArea:
-      reportData = getMineAreaResult(request.reportId());
+      reportData = getMineAreaResult(request.reportId);
      break;
    case ReportManagement::ReportType::Nbc:
-      reportData = getNbcResult(request.reportId());
+      reportData = getNbcResult(request.reportId);
      break;
    case ReportManagement::ReportType::Firings:
    case ReportManagement::ReportType::ExplosiveDevice:
-      reportData = getFiringsResult(request.reportId());
+      reportData = getFiringsResult(request.reportId);
      break;
    case ReportManagement::ReportType::AirSupport:
-      reportData = getAirSupportResult(request.reportId());
+      reportData = getAirSupportResult(request.reportId);
      break;

    case ReportManagement::ReportType::ChargeResupply:
-      reportData = getChargeResupplyResult(request.reportId());
+      reportData = getChargeResupplyResult(request.reportId);
      break;
    case ReportManagement::ReportType::ChargeAdministration:
-      reportData = getChargeAdminResult(request.reportId());
+      reportData = getChargeAdminResult(request.reportId);
      break;
    case ReportManagement::ReportType::VehicleRepair:
    case ReportManagement::ReportType::Decontamination:
-      reportData = getMaintenanceResult(request.reportId());
+      reportData = getMaintenanceResult(request.reportId);
      break;
    case ReportManagement::ReportType::BuildingDamage:
-      reportData = getBuildingDamageResult(request.reportId());
+      reportData = getBuildingDamageResult(request.reportId);
      break;
    case ReportManagement::ReportType::SanitationMaterial:
-      reportData = getSanitationMaterialResult(request.reportId());
+      reportData = getSanitationMaterialResult(request.reportId);
      break;
    case ReportManagement::ReportType::MedevacNineLiner:
-      reportData = getSanNineLinerResult(request.reportId());
+      reportData = getSanNineLinerResult(request.reportId);
      break;
    case ReportManagement::ReportType::Treatment:
    case ReportManagement::ReportType::TreatmentPriority:
    case ReportManagement::ReportType::TreatmentChain:
-      reportData = getTreatmentResult(request.reportId());
+      reportData = getTreatmentResult(request.reportId);
      break;
    case ReportManagement::ReportType::TreatmentTimeline:
-      reportData = getTreatmentTimelineResult(request.reportId());
+      reportData = getTreatmentTimelineResult(request.reportId);
      break;
    default:
      WARNING_LOG(m_logger) << "Report Type unknown, no generating.";
@@ -110,16 +110,16 @@ GetReportDataReply HandlerReportGetData::getReportDataRequest(const GetReportDat
  }

  GetReportDataReply ret;
-  ret.id(request.reportId());
+  ret.id = request.reportId;

  if (reportData.isEmpty())
  {
-    Core::FunctionReplyObject fro = Core::FunctionReplyObject(tr_lts("dds", "No data for this report (report type: %1)")).arg(request.reportType().underlying());
-    ret.errorString(fro.str());
-    ret.errorParams(fro.args());
+    Core::FunctionReplyObject fro = Core::FunctionReplyObject(tr_lts("dds", "No data for this report (report type: %1)")).arg(static_cast<int>(request.reportType));
+    ret.errorString = fro.str();
+    ret.errorParams = fro.args();
  }
  else
-    ret.reportData(LtsUtils::convert<std::vector<uint8_t>>(reportData));
+    ret.reportData = LtsUtils::convert<std::vector<uint8_t>>(reportData);
  return ret;
 }

@@ -326,7 +326,7 @@ QByteArray HandlerReportGetData::getChargeAdminResult(int reportId) const

    object.insert(QLatin1String("id"), data.id);
    object.insert(QLatin1String("charge_type_id"), data.chargeTypeId);
-    object.insert(QLatin1String("effect_source_id"), data.effectSourceId.underlying());
+    object.insert(QLatin1String("effect_source_id"), static_cast<int>(data.effectSourceId));
    object.insert(QLatin1String("charge_start"), data.chargeStart);
    object.insert(QLatin1String("charge_resupplied"), data.chargeResupplied);
    object.insert(QLatin1String("charge_end"), data.chargeEnd);
@@ -536,7 +536,7 @@ QByteArray HandlerReportGetData::getTreatmentTimelineResult(int reportId) const
    object.insert(QLatin1String("vulnerability"), data.vulnerability);
    object.insert(QLatin1String("vulnerability_state"), data.vulnerabilityState);
    object.insert(QLatin1String("vitality"), data.vitality);
-    object.insert(QLatin1String("event_type_id"), data.eventTypeId.underlying());
+    object.insert(QLatin1String("event_type_id"), static_cast<int>(data.eventTypeId));
    object.insert(QLatin1String("event_time"), data.eventTime);
    object.insert(QLatin1String("properties"), data.properties);

@@ -28,27 +28,27 @@ bool HandlerReportData::generateMaintenanceResult(const CreateModifyReportReques
  QString stmtSelect = QStringLiteral("SELECT participant_type_id, participant_id, time_event, time_position_changed, time_vulnerability "
                                      "FROM rep_maintenance_data "
                                      "WHERE party_id = :partyId AND (time_event between :startTime and :endTime) ");
-  if (request.participantTypes().size() > 0)
+  if (request.participantTypes.size() > 0)
  {
-    const QString pTypeIdsStr = intVecToString(request.participantTypes());
+    const QString pTypeIdsStr = intVecToString(request.participantTypes);
    stmtSelect += QStringLiteral(" AND participant_type_id IN (%1) ").arg(pTypeIdsStr);
  }
-  if (request.participantIds().size() > 0)
+  if (request.participantIds.size() > 0)
  {
-    const QString pIdsStr = intVecToString(request.participantIds());
+    const QString pIdsStr = intVecToString(request.participantIds);
    stmtSelect += QStringLiteral(" AND participant_id IN (%1) ").arg(pIdsStr);
  }
  stmtSelect += QStringLiteral(" ORDER by participant_type_id, participant_id, time_event");

  DEBUG_LOG(m_logger) << "Statement: " << stmtSelect;
-  DEBUG_LOG(m_logger) << "Party Id = " << request.partyId();
-  DEBUG_LOG(m_logger) << "Start Time = " << request.startTime();
-  DEBUG_LOG(m_logger) << "End Time = " << request.endTime();
+  DEBUG_LOG(m_logger) << "Party Id = " << request.partyId;
+  DEBUG_LOG(m_logger) << "Start Time = " << request.startTime;
+  DEBUG_LOG(m_logger) << "End Time = " << request.endTime;

  qSelect.prepare(stmtSelect);
-  qSelect.bindValue(QStringLiteral(":startTime"), request.startTime());
-  qSelect.bindValue(QStringLiteral(":endTime"),   request.endTime());
-  qSelect.bindValue(QStringLiteral(":partyId"),   request.partyId());
+  qSelect.bindValue(QStringLiteral(":startTime"), static_cast<qint64>(request.startTime));
+  qSelect.bindValue(QStringLiteral(":endTime"),   static_cast<qint64>(request.endTime));
+  qSelect.bindValue(QStringLiteral(":partyId"),   request.partyId);

  if (!qSelect.exec())
  {
@@ -27,12 +27,12 @@ bool HandlerReportData::generateMineAreaResult(const CreateModifyReportRequest &
  NSqlQuery qSelect(m_db->database());
  NSqlQuery qInsert(m_db->database());

-  const QString mineAreaIdsStr = intVecToString(request.mineAreaIds());
+  const QString mineAreaIdsStr = intVecToString(request.mineAreaIds);

  QString stmtSelect = QStringLiteral("SELECT mine_area_id, participant_type_id, SUM(hit) as hit, SUM(hit_friendly_fire) as hit_friendly_fire "
                                      " FROM rep_mine_area_data "
                                      " WHERE party_id = :partyId AND (event_time between :startTime and :endTime ) ");
-  if (request.mineAreaIds().size() > 0)
+  if (request.mineAreaIds.size() > 0)
    stmtSelect += QStringLiteral(" AND mine_area_id IN (%1)").arg(mineAreaIdsStr);
  stmtSelect += QStringLiteral(" GROUP BY mine_area_id, participant_type_id ");
  stmtSelect += QStringLiteral(" ORDER by mine_area_id, participant_type_id ");
@@ -45,9 +45,9 @@ bool HandlerReportData::generateMineAreaResult(const CreateModifyReportRequest &
    return false;
  }

-  qSelect.bindValue(QStringLiteral(":startTime"), request.startTime());
-  qSelect.bindValue(QStringLiteral(":endTime"),   request.endTime());
-  qSelect.bindValue(QStringLiteral(":partyId"),   request.partyId());
+  qSelect.bindValue(QStringLiteral(":startTime"), static_cast<qint64>(request.startTime));
+  qSelect.bindValue(QStringLiteral(":endTime"),   static_cast<qint64>(request.endTime));
+  qSelect.bindValue(QStringLiteral(":partyId"),   request.partyId);

  if (!qSelect.exec())
  {
@@ -79,7 +79,7 @@ bool HandlerReportData::generateMineAreaResult(const CreateModifyReportRequest &
    INFO_LOG(m_logger) << "hit_ff: " << hitFriendlyFire;

    qInsert.bindValue(QStringLiteral(":mineAreaId")   , mineAreaId);
-    QString mineAreaName = QString::fromStdString(aesDtc->mineArea(mineAreaId).name());
+    QString mineAreaName = QString::fromStdString(aesDtc->mineArea(mineAreaId).name);
    qInsert.bindValue(QStringLiteral(":mineAreaName") , mineAreaName);
    qInsert.bindValue(QStringLiteral(":pTypeId")      , participantTypeId);
    qInsert.bindValue(QStringLiteral(":hit")          , hit);
@@ -21,14 +21,14 @@ bool HandlerReportData::generateNbcResult(const CreateModifyReportRequest &reque
 {
  INFO_LOG(m_logger) <<  "Start generateNbcResult - reportId: " << reportId;

-  if (request.nbcIds().size() <= 0)
+  if (request.nbcIds.size() <= 0)
  {
    ERROR_LOG(m_logger) << "No elements selected to generate the report";
-    DEBUG_LOG(m_logger) << "request.nbcIds().size()" << request.nbcIds().size();
+    DEBUG_LOG(m_logger) << "request.nbcIds().size()" << request.nbcIds.size();
    return false;
  }

-  const QString nbcIdsStr = intVecToString(request.nbcIds());
+  const QString nbcIdsStr = intVecToString(request.nbcIds);

  DBTransaction trans(m_db->database());
  NSqlQuery qSelect(m_db->database());
@@ -48,8 +48,8 @@ bool HandlerReportData::generateNbcResult(const CreateModifyReportRequest &reque
    ERROR_LOG(m_logger) << "Error preparing select statement: " << stmtSelect;
    return false;
  }
-  qSelect.bindValue(QStringLiteral(":startTime"), request.startTime());
-  qSelect.bindValue(QStringLiteral(":endTime"),   request.endTime());
+  qSelect.bindValue(QStringLiteral(":startTime"), static_cast<qint64>(request.startTime));
+  qSelect.bindValue(QStringLiteral(":endTime"),   static_cast<qint64>(request.endTime));

  if (!qSelect.exec())
  {
@@ -86,7 +86,7 @@ bool HandlerReportData::generateNbcResult(const CreateModifyReportRequest &reque

    qInsert.bindValue(QStringLiteral(":reportId"), reportId);
    qInsert.bindValue(QStringLiteral(":nbcId"), nbcId);
-    QString nbcName = QString::fromStdString(aesDtc->bCContamination(nbcId).name());
+    QString nbcName = QString::fromStdString(aesDtc->bCContamination(nbcId).name);
    qInsert.bindValue(QStringLiteral(":nbcName"), nbcName);
    qInsert.bindValue(QStringLiteral(":aesType"), aesType);
    qInsert.bindValue(QStringLiteral(":chargeId"), chargeTypeId);
@@ -32,15 +32,15 @@ bool HandlerReportData::generateParticipantDistanceResult(const CreateModifyRepo
                                      "WHERE party_id = :partyId AND (sample_time between :startTime and :endTime) "
                                      "AND (pos_lon > 0 OR pos_lat > 0)"); // ignore (0,0)

-  if (request.participantTypes().size() > 0)
+  if (request.participantTypes.size() > 0)
  {
-    const QString pTypeIdsStr = intVecToString(request.participantTypes());
+    const QString pTypeIdsStr = intVecToString(request.participantTypes);
    stmtSelect += QStringLiteral(" AND participant_type_id IN (%1) ").arg(pTypeIdsStr);
  }

-  if (request.participantIds().size() > 0)
+  if (request.participantIds.size() > 0)
  {
-    const QString participants = intVecToString(request.participantIds());
+    const QString participants = intVecToString(request.participantIds);
    stmtSelect += QStringLiteral(" AND participant_id IN (%1)").arg(participants);
  }

@@ -48,14 +48,14 @@ bool HandlerReportData::generateParticipantDistanceResult(const CreateModifyRepo

  qSelect.prepare(stmtSelect);

-  qSelect.bindValue(QStringLiteral(":startTime"), request.startTime());
-  qSelect.bindValue(QStringLiteral(":endTime"),   request.endTime());
-  qSelect.bindValue(QStringLiteral(":partyId"),   request.partyId());
+  qSelect.bindValue(QStringLiteral(":startTime"), static_cast<qint64>(request.startTime));
+  qSelect.bindValue(QStringLiteral(":endTime"),   static_cast<qint64>(request.endTime));
+  qSelect.bindValue(QStringLiteral(":partyId"),   request.partyId);

  DEBUG_LOG(m_logger) << "Select statement: " << stmtSelect;
-  DEBUG_LOG(m_logger) << "Party id = " << request.partyId();
-  DEBUG_LOG(m_logger) << "StartTime = " << request.startTime();
-  DEBUG_LOG(m_logger) << "EndTime = " << request.endTime();
+  DEBUG_LOG(m_logger) << "Party id = " << request.partyId;
+  DEBUG_LOG(m_logger) << "StartTime = " << request.startTime;
+  DEBUG_LOG(m_logger) << "EndTime = " << request.endTime;

  if (!qSelect.exec())
  {
@@ -137,7 +137,7 @@ bool HandlerReportData::generateParticipantDistanceResult(const CreateModifyRepo
  }

  qInsert.bindValue(QStringLiteral(":reportId"), reportId);
-  qInsert.bindValue(QStringLiteral(":partyId"), request.partyId());
+  qInsert.bindValue(QStringLiteral(":partyId"), request.partyId);

  for (auto it = m_distanceMapType.cbegin(); it != m_distanceMapType.cend(); ++it)
  {
@@ -32,25 +32,25 @@ bool HandlerReportData::generateTreatmentResult(const CreateModifyReportRequest
                                      "FROM rep_treatment_data "
                                     // "WHERE party_id = :partyId AND (time_treatment between :startTime and :endTime) ");
                                      "WHERE party_id = :partyId AND (time_vulnerability between :startTime and :endTime) ");
-  if (request.participantTypes().size() > 0)
+  if (request.participantTypes.size() > 0)
  {
-    const QString pTypeIdsStr = intVecToString(request.participantTypes());
+    const QString pTypeIdsStr = intVecToString(request.participantTypes);
    stmtSelect += QStringLiteral(" AND participant_type_id IN (%1) ").arg(pTypeIdsStr);
  }
-  if (request.participantIds().size() > 0)
+  if (request.participantIds.size() > 0)
  {
-    const QString pIdsStr = intVecToString(request.participantIds());
+    const QString pIdsStr = intVecToString(request.participantIds);
    stmtSelect += QStringLiteral(" AND participant_id IN (%1) ").arg(pIdsStr);
  }

-  if (request.width() > 0 && request.height() > 0)
+  if (request.width > 0 && request.height > 0)
  {
    DEBUG_LOG(m_logger) << "#### Filtering data on geographic position";
-    LtsCoordTrans::UtmCoordinate coord(LtsCoordTrans::UtmCoordinate::fromGeographic(request.cornerBottomLeft().lon(),
-                                                                                    request.cornerBottomLeft().lat()));
+    LtsCoordTrans::UtmCoordinate coord(LtsCoordTrans::UtmCoordinate::fromGeographic(request.cornerBottomLeft.lon,
+                                                                                    request.cornerBottomLeft.lat));

-    double x1 = coord.x + request.height();
-    double y1 = coord.y + request.width();
+    double x1 = coord.x + request.height;
+    double y1 = coord.y + request.width;
    DEBUG_LOG(m_logger) << "#### (x,x1,y,y1) = (" << coord.x << "," << x1 << "," << coord.y << "," << y1 << ")";

    stmtSelect += QLatin1String(" AND position_x_m >= ") + QString::number(coord.x);
@@ -63,14 +63,14 @@ bool HandlerReportData::generateTreatmentResult(const CreateModifyReportRequest
  stmtSelect += QStringLiteral(" ORDER by time_vulnerability");

  DEBUG_LOG(m_logger) << "Statement: " << stmtSelect;
-  DEBUG_LOG(m_logger) << "Party Id = " << request.partyId();
-  DEBUG_LOG(m_logger) << "Start Time = " << request.startTime();
-  DEBUG_LOG(m_logger) << "End Time = " << request.endTime();
+  DEBUG_LOG(m_logger) << "Party Id = " << request.partyId;
+  DEBUG_LOG(m_logger) << "Start Time = " << request.startTime;
+  DEBUG_LOG(m_logger) << "End Time = " << request.endTime;

  qSelect.prepare(stmtSelect);
-  qSelect.bindValue(QStringLiteral(":startTime"), request.startTime());
-  qSelect.bindValue(QStringLiteral(":endTime"),   request.endTime());
-  qSelect.bindValue(QStringLiteral(":partyId"),   request.partyId());
+  qSelect.bindValue(QStringLiteral(":startTime"), static_cast<qint64>(request.startTime));
+  qSelect.bindValue(QStringLiteral(":endTime"),   static_cast<qint64>(request.endTime));
+  qSelect.bindValue(QStringLiteral(":partyId"),   request.partyId);

  if (!qSelect.exec())
  {
@@ -105,7 +105,7 @@ bool HandlerReportData::generateTreatmentResult(const CreateModifyReportRequest
    tData.pos_y_m               = qSelect.value(19).toDouble();

    tData.area_id               = qSelect.value(20).toInt();
-    tData.area_name             = qSelect.value(21).toInt();
+    tData.area_name             = qSelect.value(21).toString();

    m_treatmentData.append(tData);
  }
@@ -147,7 +147,7 @@ bool HandlerReportData::generateTreatmentResult(const CreateModifyReportRequest

    bool kiaAfterWia = false;
    // Check if KIA is also KIA after WIA
-    if (tData.vulnerabilityState == ProjectDataManagement::VulnerabilityState::CatastrophicKill)
+    if (tData.vulnerabilityState == static_cast<int>(ProjectDataManagement::VulnerabilityState::VulnerabilityState_CatastrophicKill))
      kiaAfterWia = checkVulnerabilityStateWIA(tData.participantId, tData.time_vulnerability);

    qInsert.bindValue(QStringLiteral(":kia_after_wia"), kiaAfterWia);
@@ -197,7 +197,7 @@ bool HandlerReportData::generateTreatmentResult(const CreateModifyReportRequest
      QString area_name;
      if (area_id > 0)
      {
-         area_name = QString::fromStdString(m_aesDtc->functionalArea(area_id).name());
+         area_name = QString::fromStdString(m_aesDtc->functionalArea(area_id).name);
         qInsert.bindValue(QStringLiteral(":area_id"), area_id);
         qInsert.bindValue(QStringLiteral(":area_name"), area_name);
      }
@@ -231,7 +231,7 @@ bool HandlerReportData::generateTreatmentResult(const CreateModifyReportRequest
    if (tData.time_treatment > 0)
    {
      bool pCorrect = false;
-      pCorrect = getPriorityCorrect(participant.id(), tData.time_treatment, tData.priority);
+      pCorrect = getPriorityCorrect(participant.id, tData.time_treatment, tData.priority);
      qInsert.bindValue(QStringLiteral(":pCorrect"), pCorrect);
    }

@@ -549,8 +549,8 @@ bool HandlerReportData::checkVulnerabilityStateWIA(int participantId, qint64 cur

  qSelect.prepare(stmtSelect);
  qSelect.bindValue(QStringLiteral(":currTime"),           currTime);
-  qSelect.bindValue(QStringLiteral(":eventTypeId"),        ReportManagement::EventType::VBGSet);
-  qSelect.bindValue(QStringLiteral(":vulnerabilityState"), ProjectDataManagement::VulnerabilityState::CatastrophicKill);
+  qSelect.bindValue(QStringLiteral(":eventTypeId"),        static_cast<int>(ReportManagement::EventType::VBGSet));
+  qSelect.bindValue(QStringLiteral(":vulnerabilityState"), static_cast<int>(ProjectDataManagement::VulnerabilityState::VulnerabilityState_CatastrophicKill));
  qSelect.bindValue(QStringLiteral(":participantId"),      participantId);

  if (!qSelect.exec())
@@ -30,28 +30,28 @@ bool HandlerReportData::generateTreatmentTimelineResult(const CreateModifyReport
  QString stmtSelect = QStringLiteral("SELECT participant_type_id, participant_id, vitality, vulnerability, vulnerability_state, event_time, event_type_id, properties "
                                      "FROM rep_treatment_timeline_data "
                                      "WHERE party_id = :partyId AND (event_time between :startTime and :endTime) ");
-  if (request.participantTypes().size() > 0)
+  if (request.participantTypes.size() > 0)
  {
-    const QString pTypeIdsStr = intVecToString(request.participantTypes());
+    const QString pTypeIdsStr = intVecToString(request.participantTypes);
    stmtSelect += QStringLiteral(" AND participant_type_id IN (%1) ").arg(pTypeIdsStr);
  }
-  if (request.participantIds().size() > 0)
+  if (request.participantIds.size() > 0)
  {
-    const QString pIdsStr = intVecToString(request.participantIds());
+    const QString pIdsStr = intVecToString(request.participantIds);
    stmtSelect += QStringLiteral(" AND participant_id IN (%1) ").arg(pIdsStr);
  }

  stmtSelect += QStringLiteral(" ORDER by participant_type_id, participant_id, event_time, event_type_id");

  DEBUG_LOG(m_logger) << "Statement: " << stmtSelect;
-  DEBUG_LOG(m_logger) << "Party Id = " << request.partyId();
-  DEBUG_LOG(m_logger) << "Start Time = " << request.startTime();
-  DEBUG_LOG(m_logger) << "End Time = " << request.endTime();
+  DEBUG_LOG(m_logger) << "Party Id = " << request.partyId;
+  DEBUG_LOG(m_logger) << "Start Time = " << request.startTime;
+  DEBUG_LOG(m_logger) << "End Time = " << request.endTime;

  qSelect.prepare(stmtSelect);
-  qSelect.bindValue(QStringLiteral(":startTime"), request.startTime());
-  qSelect.bindValue(QStringLiteral(":endTime"),   request.endTime());
-  qSelect.bindValue(QStringLiteral(":partyId"),   request.partyId());
+  qSelect.bindValue(QStringLiteral(":startTime"), static_cast<qint64>(request.startTime));
+  qSelect.bindValue(QStringLiteral(":endTime"),   static_cast<qint64>(request.endTime));
+  qSelect.bindValue(QStringLiteral(":partyId"),   request.partyId);

  if (!qSelect.exec())
  {
@@ -80,8 +80,8 @@ bool HandlerReportData::generateTreatmentTimelineResult(const CreateModifyReport
    tData.properties            = qSelect.value(7).toString();

    // 2 events TransportInitiated one after another, we save only first one
-    if (oldData.eventTypeId == ReportManagement::EventType::TransportInitiated &&
-        tData.eventTypeId == ReportManagement::EventType::TransportInitiated)
+    if (oldData.eventTypeId == static_cast<int>(ReportManagement::EventType::TransportInitiated) &&
+        tData.eventTypeId == static_cast<int>(ReportManagement::EventType::TransportInitiated))
      continue;

    m_treatmentTimelineData.append(tData);
Author	SHA1	Message	Date
berrux-dev	9c1ac7cbef	Merge feature/lts-viewer-validation-testing-phase into feature/qt6-migration-basis-modules-merge Resolves 1 conflict (new_docker_build.sh, union of viewer-only + codification options); folds in fixes for pre-existing defects surfaced by the validation runs (KDReports-qt6 wiring, LtsSession RTI linking, LtsFileDialog/WLS/BSM Qt6/RTI API migration, GROUP4 target list, new --cmake_build_flags option); validated with BUILD_RTI=ON BUILD_GRANTLEE=ON in 3 Docker runs (run 3: build green, 6 base-state first-run CTest failures documented).	2026-09-27 07:33:29 +02:00
berrux-dev	36f077bce4	Emit record_replay fromQVariant for plain enums; document PPM MOC exclusion	2026-09-26 00:49:47 +02:00
berrux-dev	a410019553	Complete Qt6/rtiddsgen migration of residual Lts service sources	2026-09-25 20:23:37 +02:00
torsten	c664611b80	Migrates non-ArcGIS built successfully (tbc)	2026-09-24 16:49:49 +02:00
torstenandCopilot	b6a97c39e5	Fix KDReports detection and add codification support for viewer-only builds - Update FindKDReports.cmake to always use CONFIG mode first with explicit search paths - Add --codification/--no-codification CLI options to new_docker_build.sh - Add BUILD_CODIFICATION to cmake invocation and Docker environment variables - Fix BUILD_GROUP5=ON when BUILD_VIEWER_ONLY is enabled - Exclude LtsFileDialog from viewer-only builds (depends on Group 4 services) - Fix KDReports git clone to use default branch (removed non-existent branch) - Add KDReports symlink creation to Dockerfile for include path compatibility Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>	2026-09-23 17:37:56 +02:00
torstenandCopilot	fd3e5e8380	Add --build-viewer-only option to skip Groups 1-4 and build Viewer targets only - Add --build-viewer-only command-line option to argument parsing - Add BUILD_VIEWER_ONLY environment variable handling - Add conditional build logic to skip Groups 1-4 when enabled - Update usage() documentation with new option - Enable CTest when --build-viewer-only is specified - Allows bypassing pre-existing Group 3/4 build errors Tested: Successfully skips Groups 1-4 and builds Group 5 Viewer targets Validated: situationMapCommon, advancedSymbologyXML, LtsDataView build without errors No Qt5→Qt6 deprecation warnings in Viewer module targets Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>	2026-09-23 13:36:37 +02:00