Migrates residual Lts sources to generated rtiddsgen API

Adds NmeaManagement tests, fixes codegen includes and Qt6 SerialPort CMake target.

qt6-after/qt6-migrated-legatus/Lts/Services/AudioVideoManagement/frequency_planning_handler.cpp

@@ -29,9 +29,9 @@ FrequencyPlanningData toDds(const Database::AvmFrequencyPlanningData &dbEntry)
 {
   FrequencyPlanningData ddsEntry;
 
-  ddsEntry.cnrConfigId(dbEntry.cnrConfigId);
-  ddsEntry.frequencyPlanningId(dbEntry.frequencyPlanningId);
-  ddsEntry.properties(dbEntry.properties.toStdString());
+  ddsEntry.cnrConfigId = dbEntry.cnrConfigId;
+  ddsEntry.frequencyPlanningId = dbEntry.frequencyPlanningId;
+  ddsEntry.properties = dbEntry.properties.toStdString();
 
   return ddsEntry;
 }
@@ -41,14 +41,14 @@ FrequencyPlanning toDds(const Database::AvmFrequencyPlanning &dbPlan,
 {
   FrequencyPlanning ddsPlan;
 
-  ddsPlan.id(dbPlan.id);
-  ddsPlan.date(dbPlan.dateOfCreation);
+  ddsPlan.id = dbPlan.id;
+  ddsPlan.date = dbPlan.dateOfCreation;
 
   if (!dbPlan.exerciseId.isNull())
-    ddsPlan.exerciseId(dbPlan.exerciseId.value<int>());
+    ddsPlan.exerciseId = dbPlan.exerciseId.value<int>();
 
-  ddsPlan.frequencySetId(dbPlan.frequencySetId);
-  ddsPlan.name(dbPlan.name.toStdString());
+  ddsPlan.frequencySetId = dbPlan.frequencySetId;
+  ddsPlan.name = dbPlan.name.toStdString();
 
   std::vector<FrequencyPlanningData> ddsEntries;
   ddsEntries.reserve(dbEntries.size());
@@ -57,7 +57,7 @@ FrequencyPlanning toDds(const Database::AvmFrequencyPlanning &dbPlan,
     ddsEntries.push_back(toDds(dbEntry));
   }
 
-  ddsPlan.data(ddsEntries);
+  ddsPlan.data = ddsEntries;
 
   return ddsPlan;
 }
@@ -72,12 +72,12 @@ Database::AvmFrequencyPlanning toDb(const ModifyFrequencyPlanningRequest &reques
 {
   Database::AvmFrequencyPlanning result;
 
-  result.id = request.id();
-  result.name = QString::fromStdString(request.name());
-  if(request.exerciseId() != 0)
-    result.exerciseId = request.exerciseId();
-  result.dateOfCreation = request.date();
-  result.frequencySetId = request.frequencySetId();
+  result.id = request.id;
+  result.name = QString::fromStdString(request.name);
+  if(request.exerciseId != 0)
+    result.exerciseId = request.exerciseId;
+  result.dateOfCreation = request.date;
+  result.frequencySetId = request.frequencySetId;
 
   return result;
 }
@@ -85,11 +85,11 @@ Database::AvmFrequencyPlanning toDb(const ModifyFrequencyPlanningRequest &reques
 Database::AvmFrequencyPlanning toDb(const FrequencyPlanning &ddsPlan)
 {
   Database::AvmFrequencyPlanning   dbPlan;
-  dbPlan.id = ddsPlan.id();
+  dbPlan.id = ddsPlan.id;
   if (ddsPlan.exerciseId.is_set())
     dbPlan.exerciseId = ddsPlan.exerciseId.get();
-  dbPlan.dateOfCreation = ddsPlan.date();
-  dbPlan.frequencySetId = ddsPlan.frequencySetId();
+  dbPlan.dateOfCreation = ddsPlan.date;
+  dbPlan.frequencySetId = ddsPlan.frequencySetId;
 
   return dbPlan;
 }
@@ -99,8 +99,8 @@ Database::AvmFrequencyPlanningData toDb(const FrequencyPlanningData &data, int32
   Database::AvmFrequencyPlanningData result;
 
   result.frequencyPlanningId = frequencyPlanningId;
-  result.cnrConfigId = data.cnrConfigId();
-  result.properties = QString::fromStdString(data.properties());
+  result.cnrConfigId = data.cnrConfigId;
+  result.properties = QString::fromStdString(data.properties);
 
   return result;
 }
@@ -183,7 +183,7 @@ bool FrequencyPlanningHandler::init()
 void FrequencyPlanningHandler::onModifyFrequencyPlanningRequest(const rti::core::SampleIdentity &cookie,
                                                                 const ModifyFrequencyPlanningRequest &request)
 {
-  auto ret = request.id() > 0 ? handleModify(request) : handleCreate(request);
+  auto ret = request.id > 0 ? handleModify(request) : handleCreate(request);
   if (ret.error())
     WARNING_LOG(m_logger) << ret();
   m_fts->modifyFrequencyPlanningReply(cookie, ret);
@@ -229,9 +229,9 @@ bool FrequencyPlanningHandler::isReferencedByActivePlan(int32_t exerciseId, int3
 
   Q_ASSERT(m_cache.contains(found->frequencyPlanningId));
   const FrequencyPlanning   &activePlan = m_cache.value(found->frequencyPlanningId);
-  for (const FrequencyPlanningData &entry : activePlan.data())
+  for (const FrequencyPlanningData &entry : activePlan.data)
   {
-    if (entry.cnrConfigId() == cnrConfigId)
+    if (entry.cnrConfigId == cnrConfigId)
       return true;
   }
 
@@ -240,7 +240,7 @@ bool FrequencyPlanningHandler::isReferencedByActivePlan(int32_t exerciseId, int3
 
 Core::FunctionReplyObject FrequencyPlanningHandler::handleCreate(const ModifyFrequencyPlanningRequest &request)
 {
-  Q_ASSERT(request.id() <= 0);
+  Q_ASSERT(request.id <= 0);
 
   Core::FunctionReplyObject   reply = validateRequest(request);
   if (reply.error())
@@ -256,7 +256,7 @@ Core::FunctionReplyObject FrequencyPlanningHandler::handleCreate(const ModifyFre
 
   bool   status = false;
   std::vector<Database::AvmFrequencyPlanningData>   dbEntries;
-  for(auto data = request.data().begin(); data != request.data().end(); data++)
+  for(auto data = request.data.begin(); data != request.data.end(); data++)
   {
     Database::AvmFrequencyPlanningData dbEntry = toDb((*data), dbPlanning.id);
 
@@ -273,9 +273,9 @@ Core::FunctionReplyObject FrequencyPlanningHandler::handleCreate(const ModifyFre
   trans.commit();
 
   addPlan(toDds(dbPlanning, dbEntries));
-  if(request.exerciseId() == 0) //set global as active
+  if(request.exerciseId == 0) //set global as active
   {
-    ModifyActiveFrequencyPlanningRequest modRequest(request.exerciseId() , dbPlanning.id);
+    ModifyActiveFrequencyPlanningRequest modRequest(request.exerciseId , dbPlanning.id);
     modifyActiveFrequencyPlanningRequest(modRequest);
   }
 
@@ -284,7 +284,7 @@ Core::FunctionReplyObject FrequencyPlanningHandler::handleCreate(const ModifyFre
 
 Core::FunctionReplyObject FrequencyPlanningHandler::handleModify(const ModifyFrequencyPlanningRequest &request)
 {
-Q_ASSERT(request.id() > 0);
+Q_ASSERT(request.id > 0);
 
   Core::FunctionReplyObject   reply = validateRequest(request);
   if (reply.error())
@@ -294,13 +294,13 @@ Q_ASSERT(request.id() > 0);
 
   DBTransaction trans(m_db->database());
 
-  if (!m_db->removeAvmFrequencyPlanningDataByFrequencyPlanningId(request.id()) ||
+  if (!m_db->removeAvmFrequencyPlanningDataByFrequencyPlanningId(request.id) ||
       !m_db->update(dbPlanning))
-    return reply.setStr(tr_lts("dds", "Error updating FrequencyPlanning data with id %1")).arg(request.id());
+    return reply.setStr(tr_lts("dds", "Error updating FrequencyPlanning data with id %1")).arg(request.id);
 
   bool   status = false;
   std::vector<Database::AvmFrequencyPlanningData>   dbEntries;
-  for(auto data = request.data().begin(); data != request.data().end(); data++)
+  for(auto data = request.data.begin(); data != request.data.end(); data++)
   {
     Database::AvmFrequencyPlanningData dbEntry = toDb((*data), dbPlanning.id);
 
@@ -329,13 +329,13 @@ Core::FunctionReplyObject FrequencyPlanningHandler::handleRemove(const Core::Rem
 
   // first remove the data
   // removeAvmFrequencyPlanningDataByFrequencyPlanningId not really needed to due FK
-  if (!m_db->removeAvmFrequencyPlanningDataByFrequencyPlanningId(request.id()) ||
-      !m_db->removeAvmFrequencyPlanning(request.id()))
-    return reply.setStr(tr_lts("dds", "Error removing FrequencyPlanningRequest data with id %1 from database")).arg(request.id());
+  if (!m_db->removeAvmFrequencyPlanningDataByFrequencyPlanningId(request.id) ||
+      !m_db->removeAvmFrequencyPlanning(request.id))
+    return reply.setStr(tr_lts("dds", "Error removing FrequencyPlanningRequest data with id %1 from database")).arg(request.id);
 
   trans.commit();
 
-  removePlan(request.id());
+  removePlan(request.id);
 
   return reply;
 }
@@ -344,7 +344,7 @@ Core::FunctionReplyObject FrequencyPlanningHandler::validateRequest(const Modify
 {
   Core::FunctionReplyObject   reply;
 
-  if (request.id() > 0)
+  if (request.id > 0)
   {
     reply = validateModifyRequest(request);
     if (reply.error())
@@ -357,13 +357,13 @@ Core::FunctionReplyObject FrequencyPlanningHandler::validateRequest(const Modify
 
     // Validate that the FrequencySet-entries actually belong to the referenced FrequencySet.
 
-  for (const FrequencyPlanningData &entry : request.data())
+  for (const FrequencyPlanningData &entry : request.data)
   {
-    QSet<int> frequencySetEntries = AudioVideoManagement::frequencySetDataIds(entry.properties());
+    QSet<int> frequencySetEntries = AudioVideoManagement::frequencySetDataIds(entry.properties);
     for(const int &setEntry : qAsConst(frequencySetEntries))
     {
-      if (setEntry != 0 && !m_frequencySetHandler->isValid(request.frequencySetId(), setEntry))
-        return reply.setStr(tr_lts("dds", "FrequencySetData %1 does not belong to FrequencySet %2")).arg(setEntry).arg(request.frequencySetId());
+      if (setEntry != 0 && !m_frequencySetHandler->isValid(request.frequencySetId, setEntry))
+        return reply.setStr(tr_lts("dds", "FrequencySetData %1 does not belong to FrequencySet %2")).arg(setEntry).arg(request.frequencySetId);
     }
   }
   return reply;
@@ -374,54 +374,54 @@ Core::FunctionReplyObject FrequencyPlanningHandler::validateRequest(const Modify
  */
 Core::FunctionReplyObject FrequencyPlanningHandler::validateModifyRequest(const ModifyFrequencyPlanningRequest &request) const
 {
-  Q_ASSERT(request.id() > 0);
+  Q_ASSERT(request.id > 0);
 
-  Core::FunctionReplyObject   reply(request.id());
+  Core::FunctionReplyObject   reply(request.id);
 
-  auto   found = m_cache.constFind(request.id());
+  auto   found = m_cache.constFind(request.id);
   if (found == m_cache.constEnd())
-    return reply.setStr(tr_lts("dds", "FrequencyPlan %1 does not exist")).arg(request.id());
+    return reply.setStr(tr_lts("dds", "FrequencyPlan %1 does not exist")).arg(request.id);
 
   const FrequencyPlanning   &oldPlan = *found;
 
-  if ((oldPlan.exerciseId.is_set() && oldPlan.exerciseId.get() != request.exerciseId())
-      || (!oldPlan.exerciseId.is_set() && request.exerciseId() != 0))
+  if ((oldPlan.exerciseId.is_set() && oldPlan.exerciseId.get() != request.exerciseId)
+      || (!oldPlan.exerciseId.is_set() && request.exerciseId != 0))
     return reply.setStr(tr_lts("dds", "Exercise may not be changed"));
 
-  if (request.frequencySetId() != oldPlan.frequencySetId())
+  if (request.frequencySetId != oldPlan.frequencySetId)
     return reply.setStr(tr_lts("dds", "FrequencySet may not be changed"));
 
   // In case the plan is already active (in an active Exercise), we need to check for conflicts with active FrequencyPlans of other active Exercises.
-  if (!m_activeExercises->isActive(ExerciseContext(request.exerciseId())))
+  if (!m_activeExercises->isActive(ExerciseContext(request.exerciseId)))
     return reply;
 
-  auto   foundActivePlan = m_activePlannings.constFind(request.exerciseId());
+  auto   foundActivePlan = m_activePlannings.constFind(request.exerciseId);
   if (foundActivePlan == m_activePlannings.constEnd())
     return reply;
 
-  bool   currentlyActive = foundActivePlan->frequencyPlanningId == request.id();
+  bool   currentlyActive = foundActivePlan->frequencyPlanningId == request.id;
   if (!currentlyActive)
     return reply;
 
-  const std::vector<int>   activePlans = otherActivePlans(request.exerciseId());
-  return testActivation(request.data(), activePlans, request.id());
+  const std::vector<int>   activePlans = otherActivePlans(request.exerciseId);
+  return testActivation(request.data, activePlans, request.id);
 }
 
 Core::FunctionReplyObject FrequencyPlanningHandler::validateRequest(const Core::RemoveElementRequest &request) const
 {
-  Q_ASSERT(request.id() > 0);
-  Core::FunctionReplyObject   reply(request.id());
+  Q_ASSERT(request.id > 0);
+  Core::FunctionReplyObject   reply(request.id);
 
-  auto   foundPlan = m_cache.constFind(request.id());
+  auto   foundPlan = m_cache.constFind(request.id);
   if (foundPlan == m_cache.constEnd())
-    return reply.setStr(tr_lts("dds", "FrequencyPlanning %1 does not exist")).arg(request.id());
+    return reply.setStr(tr_lts("dds", "FrequencyPlanning %1 does not exist")).arg(request.id);
 
   const FrequencyPlanning   &plan = *foundPlan;
   int exerciseId = plan.exerciseId.is_set() ? plan.exerciseId.get() : 0;
   auto   foundActivePlan = m_activePlannings.constFind(exerciseId);
-  bool   isActive = foundActivePlan != m_activePlannings.constEnd() && foundActivePlan->frequencyPlanningId == plan.id();
+  bool   isActive = foundActivePlan != m_activePlannings.constEnd() && foundActivePlan->frequencyPlanningId == plan.id;
   if (isActive)
-    return reply.setStr(tr_lts("dds", "FrequencyPlanning %1 cannot be removed because it is active")).arg(request.id());
+    return reply.setStr(tr_lts("dds", "FrequencyPlanning %1 cannot be removed because it is active")).arg(request.id);
 
   return reply;
 }
@@ -451,27 +451,27 @@ Core::FunctionReplyObject FrequencyPlanningHandler::modifyActiveFrequencyPlannin
     return reply;
 
   Database::AvmActiveFrequencyPlanning dbData;
-  dbData.frequencyPlanningId = request.frequencyPlanningId();
-  if(request.exerciseId() != 0)
-    dbData.exerciseId = request.exerciseId();
+  dbData.frequencyPlanningId = request.frequencyPlanningId;
+  if(request.exerciseId != 0)
+    dbData.exerciseId = request.exerciseId;
 
-  if (!m_activePlannings.contains(request.exerciseId())) // create
+  if (!m_activePlannings.contains(request.exerciseId)) // create
   {
     if (!m_db->insert(dbData))
-      return reply.setStr(tr_lts("dds", "Error inserting ActiveFrequencyPlanning data with id %1 into DB")).arg(request.exerciseId());
+      return reply.setStr(tr_lts("dds", "Error inserting ActiveFrequencyPlanning data with id %1 into DB")).arg(request.exerciseId);
   }
   else // modify
   {
-    dbData.id = m_activePlannings.value(request.exerciseId()).id;
+    dbData.id = m_activePlannings.value(request.exerciseId).id;
     if (!m_db->update(dbData))
-      return reply.setStr(tr_lts("dds", "Error updating ActiveFrequencyPlanning data with id %1 in DB")).arg(request.exerciseId());
+      return reply.setStr(tr_lts("dds", "Error updating ActiveFrequencyPlanning data with id %1 in DB")).arg(request.exerciseId);
   }
 
   int  exerciseId = dbData.exerciseId.isNull() ? 0 : dbData.exerciseId.value<int>();
   m_activePlannings[exerciseId] = dbData;
 
   if (!m_dts->publish(toDds(dbData)))
-    return reply.setStr(tr_lts("dds", "Error publishing ActiveFrequencyPlanning data with id %1 to DDS")).arg(request.exerciseId());
+    return reply.setStr(tr_lts("dds", "Error publishing ActiveFrequencyPlanning data with id %1 to DDS")).arg(request.exerciseId);
 
   emit planningChanged();
 
@@ -482,22 +482,22 @@ Core::FunctionReplyObject FrequencyPlanningHandler::removeActiveFrequencyPlannin
 {
   DEBUG_LOG(m_logger) << "RemoveActiveFrequencyPlanningRequest: " << request;
 
-  Core::FunctionReplyObject   reply(request.exerciseId());
+  Core::FunctionReplyObject   reply(request.exerciseId);
 
-  if (!m_activePlannings.contains(request.exerciseId()))
-    return reply.setStr(tr_lts("dds", "No ActiveFrequencyPlanning for exercise %1")).arg(request.exerciseId());
+  if (!m_activePlannings.contains(request.exerciseId))
+    return reply.setStr(tr_lts("dds", "No ActiveFrequencyPlanning for exercise %1")).arg(request.exerciseId);
 
-  Database::AvmActiveFrequencyPlanning activePlanning = m_activePlannings.value(request.exerciseId());
-  if (activePlanning.exerciseId != request.exerciseId())
-    return reply.setStr(tr_lts("dds", "Error removing ActiveFrequencyPlanning data with exercise id %1 - not found")).arg(request.exerciseId());
+  Database::AvmActiveFrequencyPlanning activePlanning = m_activePlannings.value(request.exerciseId);
+  if (activePlanning.exerciseId != request.exerciseId)
+    return reply.setStr(tr_lts("dds", "Error removing ActiveFrequencyPlanning data with exercise id %1 - not found")).arg(request.exerciseId);
 
-  if (!m_dts->removeActiveFrequencyPlanningByKey(request.exerciseId()))
-    return reply.setStr(tr_lts("dds", "Error removing ActiveFrequencyPlanning data with exercise id %1 from DDS")).arg(request.exerciseId());
+  if (!m_dts->removeActiveFrequencyPlanningByKey(request.exerciseId))
+    return reply.setStr(tr_lts("dds", "Error removing ActiveFrequencyPlanning data with exercise id %1 from DDS")).arg(request.exerciseId);
 
   if (!m_db->removeAvmActiveFrequencyPlanning(activePlanning.id))
-    return reply.setStr(tr_lts("dds", "Error removing ActiveFrequencyPlanning data with exercise id %1 from DB")).arg(request.exerciseId());
+    return reply.setStr(tr_lts("dds", "Error removing ActiveFrequencyPlanning data with exercise id %1 from DB")).arg(request.exerciseId);
 
-  m_activePlannings.remove(request.exerciseId());
+  m_activePlannings.remove(request.exerciseId);
 
   emit planningChanged();
 
@@ -509,25 +509,25 @@ Core::FunctionReplyObject FrequencyPlanningHandler::removeActiveFrequencyPlannin
  */
 Core::FunctionReplyObject FrequencyPlanningHandler::validateRequest(const ModifyActiveFrequencyPlanningRequest &request) const
 {
-  Core::FunctionReplyObject   reply(request.exerciseId());
+  Core::FunctionReplyObject   reply(request.exerciseId);
 
-  auto   foundPlan = m_cache.constFind(request.frequencyPlanningId());
+  auto   foundPlan = m_cache.constFind(request.frequencyPlanningId);
   if (foundPlan == m_cache.constEnd())
-    return reply.setStr(tr_lts("dds", "FrequencyPlanning %1 does not exist")).arg(request.frequencyPlanningId());
+    return reply.setStr(tr_lts("dds", "FrequencyPlanning %1 does not exist")).arg(request.frequencyPlanningId);
 
-  if (!m_activeExercises->isActive(ExerciseContext(request.exerciseId())))
+  if (!m_activeExercises->isActive(ExerciseContext(request.exerciseId)))
     return reply;
 
   const FrequencyPlanning   &planToActivate = *foundPlan;
 
-  const std::vector<int>   activePlans = otherActivePlans(request.exerciseId());
+  const std::vector<int>   activePlans = otherActivePlans(request.exerciseId);
   if (activePlans.empty())
     return reply;
 
   if (!hasSameFrequencySet(planToActivate, *m_cache.constFind(activePlans.front())))
-    return reply.setStr(tr_lts("dds", "FrequencyPlanning %1 cannot be activated because another FrequencyPlanning with a different FrequencySet is active already")).arg(request.frequencyPlanningId());
+    return reply.setStr(tr_lts("dds", "FrequencyPlanning %1 cannot be activated because another FrequencyPlanning with a different FrequencySet is active already")).arg(request.frequencyPlanningId);
 
-  return testActivation(planToActivate.data(), activePlans, request.exerciseId());
+  return testActivation(planToActivate.data, activePlans, request.exerciseId);
 }
 
 Core::FunctionReplyObject FrequencyPlanningHandler::testActivation(const std::vector<FrequencyPlanningData> &entries, const std::vector<int> &activePlans, int requestId) const
@@ -541,27 +541,27 @@ Core::FunctionReplyObject FrequencyPlanningHandler::testActivation(const std::ve
   const std::vector<int>   takenCnrConfigs = takenGlobalCnrConfigs(activePlans);
   for (const FrequencyPlanningData &entry : entries)
   {
-    const CnrConfig   &cnrConfig = m_cnrHandler->config(entry.cnrConfigId());
+    const CnrConfig   &cnrConfig = m_cnrHandler->config(entry.cnrConfigId);
     bool   isGlobal = !cnrConfig.exerciseId.is_set();
     if (!isGlobal)
       continue;
 
-    auto found = std::find(takenCnrConfigs.begin(), takenCnrConfigs.end(), cnrConfig.id());
+    auto found = std::find(takenCnrConfigs.begin(), takenCnrConfigs.end(), cnrConfig.id);
     if (found != takenCnrConfigs.end())
-      return reply.setStr(tr_lts("dds", "FrequencyPlanning cannot be activated because CnrConfig \"%1\" is used by some other active FrequencyPlanning")).arg(cnrConfig.radioCircuit());
+      return reply.setStr(tr_lts("dds", "FrequencyPlanning cannot be activated because CnrConfig \"%1\" is used by some other active FrequencyPlanning")).arg(cnrConfig.radioCircuit);
   }
 
   // Check that the FrequencyPlanning does not reference an entry from the FrequencySet wich is already referenced by some other active FrequencyPlanning.
   QSet<int> takenSetEntries = takenFrequencySetEntries(activePlans);
   for (const FrequencyPlanningData &fpdEntry : entries)
   {
-     QSet<int> frequencySetEntries = AudioVideoManagement::frequencySetDataIds(fpdEntry.properties());
+     QSet<int> frequencySetEntries = AudioVideoManagement::frequencySetDataIds(fpdEntry.properties);
      for(const int &setEntry : qAsConst(frequencySetEntries))
      {
        if(takenSetEntries.contains(setEntry))
        {
-         const CnrConfig   &cnrConfig = m_cnrHandler->config(fpdEntry.cnrConfigId());
-         return reply.setStr(tr_lts("dds", "FrequencyPlanning cannot be activated because CnrConfig \"%1\" uses an entry in the FrequencySet which is used by some other active FrequencyPlanning")).arg(cnrConfig.radioCircuit());
+         const CnrConfig   &cnrConfig = m_cnrHandler->config(fpdEntry.cnrConfigId);
+         return reply.setStr(tr_lts("dds", "FrequencyPlanning cannot be activated because CnrConfig \"%1\" uses an entry in the FrequencySet which is used by some other active FrequencyPlanning")).arg(cnrConfig.radioCircuit);
        }
      }
   }
@@ -614,14 +614,14 @@ std::vector<int> FrequencyPlanningHandler::takenGlobalCnrConfigs(const std::vect
   for (auto planId : plans)
   {
     const FrequencyPlanning   &plan = m_cache.value(planId);
-    Q_ASSERT(plan.id() == planId);
+    Q_ASSERT(plan.id == planId);
 
-    for (const FrequencyPlanningData &entry : plan.data())
+    for (const FrequencyPlanningData &entry : plan.data)
     {
-      const CnrConfig   &cnrConfig = m_cnrHandler->config(entry.cnrConfigId());
+      const CnrConfig   &cnrConfig = m_cnrHandler->config(entry.cnrConfigId);
       bool   isGlobal = !cnrConfig.exerciseId.is_set();
       if (isGlobal)
-        result.push_back(cnrConfig.id());
+        result.push_back(cnrConfig.id);
     }
   }
 
@@ -638,11 +638,11 @@ QSet<int> FrequencyPlanningHandler::takenFrequencySetEntries(const std::vector<i
   for (auto planId : plans)
   {
     const FrequencyPlanning   &plan = m_cache.value(planId);
-    Q_ASSERT(plan.id() == planId);
+    Q_ASSERT(plan.id == planId);
 
-    for (const FrequencyPlanningData &entry : plan.data())
+    for (const FrequencyPlanningData &entry : plan.data)
     {
-      result += AudioVideoManagement::frequencySetDataIds(entry.properties());
+      result += AudioVideoManagement::frequencySetDataIds(entry.properties);
     }
   }
 
@@ -651,7 +651,7 @@ QSet<int> FrequencyPlanningHandler::takenFrequencySetEntries(const std::vector<i
 
 bool FrequencyPlanningHandler::hasSameFrequencySet(const FrequencyPlanning &plan1, const FrequencyPlanning &plan2) const
 {
-  return plan1.frequencySetId() == plan2.frequencySetId();
+  return plan1.frequencySetId == plan2.frequencySetId;
 }
 
 bool FrequencyPlanningHandler::collectAndPublish(const Database::AvmFrequencyPlanning &planDb, bool isReload)
@@ -684,29 +684,29 @@ bool FrequencyPlanningHandler::collectAndPublish(const Database::AvmFrequencyPla
 
 void FrequencyPlanningHandler::addPlan(const FrequencyPlanning &plan)
 {
-  Q_ASSERT(plan.id() > 0);
-  Q_ASSERT(!m_cache.contains(plan.id()));
+  Q_ASSERT(plan.id > 0);
+  Q_ASSERT(!m_cache.contains(plan.id));
 
-  m_cache.insert(plan.id(), plan);
+  m_cache.insert(plan.id, plan);
 
   bool   status = m_dts->publish(plan);
   if (!status)
-    ERROR_LOG(m_logger) << QStringLiteral("Failed to publish 'FrequencyPlanning' data with id %1 (create)").arg(plan.id());
+    ERROR_LOG(m_logger) << QStringLiteral("Failed to publish 'FrequencyPlanning' data with id %1 (create)").arg(plan.id);
 
   emit planningChanged();
 }
 
 void FrequencyPlanningHandler::updatePlan(const FrequencyPlanning &plan)
 {
-  Q_ASSERT(plan.id() > 0);
-  auto   found = m_cache.find(plan.id());
+  Q_ASSERT(plan.id > 0);
+  auto   found = m_cache.find(plan.id);
   Q_ASSERT(found != m_cache.end());
 
   *found = plan;
 
   bool   status = m_dts->publish(plan);
   if (!status)
-    ERROR_LOG(m_logger) << QStringLiteral("Failed to publish 'FrequencyPlanning' data with id %1 (modify)").arg(plan.id());
+    ERROR_LOG(m_logger) << QStringLiteral("Failed to publish 'FrequencyPlanning' data with id %1 (modify)").arg(plan.id);
 
   emit planningChanged();
 }
@@ -762,22 +762,22 @@ void FrequencyPlanningHandler::onCnrConfigRemoved(int cnrConfigId)
   for (FrequencyPlanning &fp : m_cache)
   {
     ModifyFrequencyPlanningRequest req;
-    req.data() = fp.data();
-    auto found = std::find_if(req.data().begin(), req.data().end(), [cnrConfigId](const FrequencyPlanningData &data)
+    req.data = fp.data;
+    auto found = std::find_if(req.data.begin(), req.data.end(), [cnrConfigId](const FrequencyPlanningData &data)
     {
-      return data.cnrConfigId() == cnrConfigId;
+      return data.cnrConfigId == cnrConfigId;
     });
-    if (found == req.data().end())
+    if (found == req.data.end())
       continue;
 
     // In this Frequency Planning, the (removed) cnrConfig ID is present. Therefore, we need to delete it also:
-    req.data().erase(found);
+    req.data.erase(found);
 
-    req.date() = fp.date();
-    req.exerciseId() = fp.exerciseId.is_set() ? fp.exerciseId.get() : 0;
-    req.frequencySetId() = fp.frequencySetId();
-    req.id() = fp.id();
-    req.name() = fp.name();
+    req.date = fp.date;
+    req.exerciseId = fp.exerciseId.is_set() ? fp.exerciseId.get() : 0;
+    req.frequencySetId = fp.frequencySetId;
+    req.id = fp.id;
+    req.name = fp.name;
     handleModify(req);
   }
 }