Initial commit

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_global.h

@@ -0,0 +1,24 @@
+// $Revision$
+// $Date$
+// $Id$
+
+#pragma once
+
+#include <DamageStatusEnum32.h>
+#include <EntityTypeStruct.h>
+#include <QtCore/QMetaType>
+#include <QtCore/QHash>
+
+Q_DECLARE_METATYPE(rpr2::DamageStatusEnum32::ET)
+
+
+namespace rpr2
+{
+inline uint qHash(const rpr2::EntityTypeStruct &ets)
+{
+  // da es genau 64 belegte Bits sind, geht es so am einfachsten
+  const quint64 *val = reinterpret_cast<const quint64 *>(&ets);
+  return ::qHash(*val);
+}
+}
+

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_ia_actionrequest.cpp

@@ -0,0 +1,32 @@
+/**
+  * Handle WeaponFire Events
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#include "rpr_ia_actionrequest.h"
+
+// rpr2 data types
+#include <EventIdentifierStruct.h>
+#include <EntityTypeStruct.h>
+
+
+/*
+ * ObserverActionRequestCBNotifier
+ */
+ObserverActionRequestCBNotifier::ObserverActionRequestCBNotifier()
+  : rpr2::IObserverActionRequestIntClassCB()
+  , m_logger(HighLevelArchitecture::getLogger("Callbacks.Interaction.ActionRequest"))
+{}
+
+void ObserverActionRequestCBNotifier::newActionRequestIntInstance(const rpr2::IObserverActionRequestIntInstance &interaction)
+{
+  emit newActionRequest(interaction);
+}
+
+void ObserverActionRequestCBNotifier::deleteInterface()
+{
+  DEBUG_LOG(m_logger) << "Delete Interface";
+  //rpr2::IObserverActionRequestIntClassCB::deleteInterface();
+}

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_ia_actionrequest.h

@@ -0,0 +1,39 @@
+/**
+  * Handle EventReport Events
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#pragma once
+
+#include "rpr_global.h"
+
+#include <IObserverActionRequestIntClassCB.h>
+#include <IObserverActionRequestIntInstance.h>
+
+#include <QObject>
+
+#include <Common/logger.h>
+
+/**
+  * The notifier for new action requests
+  */
+class ObserverActionRequestCBNotifier : public QObject, public rpr2::IObserverActionRequestIntClassCB
+{
+  Q_OBJECT
+
+public:
+  ObserverActionRequestCBNotifier();
+
+  void newActionRequestIntInstance(const rpr2::IObserverActionRequestIntInstance &interaction) override;
+  void deleteInterface() override;
+
+protected:
+  NGL::INGLLogger &m_logger;
+
+signals:
+  // Action requests only come in, when ICE wants to reset/resurrect our players. This is not implemented.
+  void newActionRequest(const rpr2::IObserverActionRequestIntInstance &interaction);
+};
+

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_ia_data.cpp

@@ -0,0 +1,32 @@
+/**
+  * Handle WeaponFire Events
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#include "rpr_ia_data.h"
+
+// rpr2 data types
+#include <EventIdentifierStruct.h>
+#include <EntityTypeStruct.h>
+
+
+/*
+ * ObserverDataCBNotifier
+ */
+ObserverDataCBNotifier::ObserverDataCBNotifier()
+  : rpr2::IObserverDataIntClassCB()
+  , m_logger(HighLevelArchitecture::getLogger("Callbacks.Interaction.Data"))
+{}
+
+void ObserverDataCBNotifier::newDataIntInstance(const rpr2::IObserverDataIntInstance &interaction)
+{
+  emit newData(interaction);
+}
+
+void ObserverDataCBNotifier::deleteInterface()
+{
+  DEBUG_LOG(m_logger) << "Delete Interface";
+  //rpr2::IObserverDataIntClassCB::deleteInterface();
+}

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_ia_data.h

@@ -0,0 +1,39 @@
+/**
+  * Handle Data Events
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#pragma once
+
+#include "rpr_global.h"
+
+#include <IObserverDataIntClassCB.h>
+#include <IObserverDataIntInstance.h>
+
+#include <QObject>
+
+#include <Common/logger.h>
+
+/**
+  * The notifier for new action requests
+  */
+class ObserverDataCBNotifier : public QObject, public rpr2::IObserverDataIntClassCB
+{
+  Q_OBJECT
+
+public:
+  ObserverDataCBNotifier();
+
+  void newDataIntInstance(const rpr2::IObserverDataIntInstance &interaction) override;
+  void deleteInterface() override;
+
+protected:
+  NGL::INGLLogger &m_logger;
+
+signals:
+  // This is only emitted, when ICE sends data to us. This is not the case ever.
+  void newData(const rpr2::IObserverDataIntInstance &interaction);
+};
+

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_ia_engagementreply.cpp

@@ -0,0 +1,33 @@
+/**
+  * Handle WeaponFire Events
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#include "rpr_ia_engagementreply.h"
+
+// rpr2 data types
+#include <EventIdentifierStruct.h>
+#include <EntityTypeStruct.h>
+#include <WorldLocationStruct.h>
+
+
+/*
+ * ObserverWeaponFireCBNotifier
+ */
+ObserverEngagementReplyCBNotifier::ObserverEngagementReplyCBNotifier()
+  : rpr2::IObserverEngagementReplyIntClassCB()
+  , m_logger(HighLevelArchitecture::getLogger("Callbacks.Interaction.EngagementReply"))
+{}
+
+void ObserverEngagementReplyCBNotifier::newEngagementReplyIntInstance(const rpr2::IObserverEngagementReplyIntInstance &interaction)
+{
+  emit newEngagementReply(interaction);
+}
+
+void ObserverEngagementReplyCBNotifier::deleteInterface()
+{
+  DEBUG_LOG(m_logger) << "Delete Interface";
+  //rpr2::IObserverEngagementReplyIntClassCB::deleteInterface();
+}

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_ia_engagementreply.h

@@ -0,0 +1,38 @@
+/**
+  * Handle WeaponFire Events
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#pragma once
+
+#include "rpr_global.h"
+
+#include <IObserverEngagementReplyIntClassCB.h>
+#include <IObserverEngagementReplyIntInstance.h>
+
+#include <QObject>
+
+#include <Common/logger.h>
+
+/**
+  * The notifier for new action requests
+  */
+class ObserverEngagementReplyCBNotifier : public QObject, public rpr2::IObserverEngagementReplyIntClassCB
+{
+  Q_OBJECT
+
+public:
+  ObserverEngagementReplyCBNotifier();
+
+  void newEngagementReplyIntInstance(const rpr2::IObserverEngagementReplyIntInstance &interaction) override;
+  void deleteInterface() override;
+
+protected:
+  NGL::INGLLogger &m_logger;
+
+signals:
+  void newEngagementReply(const rpr2::IObserverEngagementReplyIntInstance &interaction);
+};
+

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_ia_eventreport.cpp

@@ -0,0 +1,32 @@
+/**
+  * Handle WeaponFire Events
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#include "rpr_ia_eventreport.h"
+
+// rpr2 data types
+#include <EventIdentifierStruct.h>
+#include <EntityTypeStruct.h>
+
+
+/*
+ * ObserverWeaponFireCBNotifier
+ */
+ObserverEventReportCBNotifier::ObserverEventReportCBNotifier()
+  : rpr2::IObserverEventReportIntClassCB()
+  , m_logger(HighLevelArchitecture::getLogger("Callbacks.Interaction.EventReport"))
+{}
+
+void ObserverEventReportCBNotifier::newEventReportIntInstance(const rpr2::IObserverEventReportIntInstance &interaction)
+{
+  emit newEventReport(interaction);
+}
+
+void ObserverEventReportCBNotifier::deleteInterface()
+{
+  DEBUG_LOG(m_logger) << "Delete Interface";
+  //rpr2::IObserverEventReportIntClassCB::deleteInterface();
+}

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_ia_eventreport.h

@@ -0,0 +1,38 @@
+/**
+  * Handle EventReport Events
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#pragma once
+
+#include "rpr_global.h"
+
+#include <IObserverEventReportIntClassCB.h>
+#include <IObserverEventReportIntInstance.h>
+
+#include <QObject>
+
+#include <Common/logger.h>
+
+/**
+  * The notifier for new action requests
+  */
+class ObserverEventReportCBNotifier : public QObject, public rpr2::IObserverEventReportIntClassCB
+{
+  Q_OBJECT
+
+public:
+  ObserverEventReportCBNotifier();
+
+  void newEventReportIntInstance(const rpr2::IObserverEventReportIntInstance &interaction) override;
+  void deleteInterface() override;
+
+protected:
+  NGL::INGLLogger &m_logger;
+
+signals:
+  void newEventReport(const rpr2::IObserverEventReportIntInstance &interaction);
+};
+

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_ia_munitiondetonation.cpp

@@ -0,0 +1,27 @@
+/**
+  * Handle MunitionDetonation Events
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#include "rpr_ia_munitiondetonation.h"
+
+/*
+ * ObserverMunitionDetonationCBNotifier
+ */
+ObserverMunitionDetonationCBNotifier::ObserverMunitionDetonationCBNotifier()
+  : rpr2::IObserverMunitionDetonationIntClassCB()
+  , m_logger(HighLevelArchitecture::getLogger("Callbacks.Interaction.MunitionDetonation"))
+{}
+
+void ObserverMunitionDetonationCBNotifier::newMunitionDetonationIntInstance(const rpr2::IObserverMunitionDetonationIntInstance &interaction)
+{
+  emit newMunitionDetonation(interaction);
+}
+
+void ObserverMunitionDetonationCBNotifier::deleteInterface()
+{
+  DEBUG_LOG(m_logger) << "Delete Interface";
+  //rpr2::IObserverMunitionDetonationCBNotifier::deleteInterface();
+}

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_ia_munitiondetonation.h

@@ -0,0 +1,37 @@
+/**
+  * Handle MunitionDetonation Events
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#pragma once
+
+#include "rpr_global.h"
+
+#include <IObserverMunitionDetonationIntClassCB.h>
+#include <IObserverMunitionDetonationIntInstance.h>
+
+#include <QtCore/QObject>
+#include <Common/logger.h>
+
+/**
+  * The notifier for new munition detonation requests
+  */
+class ObserverMunitionDetonationCBNotifier : public QObject, public rpr2::IObserverMunitionDetonationIntClassCB
+{
+  Q_OBJECT
+
+public:
+  ObserverMunitionDetonationCBNotifier();
+
+  void newMunitionDetonationIntInstance(const rpr2::IObserverMunitionDetonationIntInstance &interaction) override;
+  void deleteInterface() override;
+
+protected:
+  NGL::INGLLogger &m_logger;
+
+signals:
+  void newMunitionDetonation(const rpr2::IObserverMunitionDetonationIntInstance &interaction);
+};
+

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_ia_weaponfire.cpp

@@ -0,0 +1,33 @@
+/**
+  * Handle WeaponFire Events
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#include "rpr_ia_weaponfire.h"
+
+// rpr2 data types
+#include <EventIdentifierStruct.h>
+#include <EntityTypeStruct.h>
+#include <WorldLocationStruct.h>
+
+
+/*
+ * ObserverWeaponFireCBNotifier
+ */
+ObserverWeaponFireCBNotifier::ObserverWeaponFireCBNotifier()
+  : rpr2::IObserverWeaponFireIntClassCB()
+  , m_logger(HighLevelArchitecture::getLogger("Callbacks.Interaction.WeaponFire"))
+{}
+
+void ObserverWeaponFireCBNotifier::newWeaponFireIntInstance(const rpr2::IObserverWeaponFireIntInstance &interaction)
+{
+  emit newWeaponFire(interaction);
+}
+
+void ObserverWeaponFireCBNotifier::deleteInterface()
+{
+  DEBUG_LOG(m_logger) << "Delete Interface";
+  //rpr2::IObserverMunitionDetonationIntClassCB::deleteInterface();
+}

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_ia_weaponfire.h

@@ -0,0 +1,38 @@
+/**
+  * Handle WeaponFire Events
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#pragma once
+
+#include "rpr_global.h"
+
+#include <IObserverWeaponFireIntClassCB.h>
+#include <IObserverWeaponFireIntInstance.h>
+
+#include <QObject>
+
+#include <Common/logger.h>
+
+/**
+  * The notifier for new action requests
+  */
+class ObserverWeaponFireCBNotifier : public QObject, public rpr2::IObserverWeaponFireIntClassCB
+{
+  Q_OBJECT
+
+public:
+  ObserverWeaponFireCBNotifier();
+
+  void newWeaponFireIntInstance(const rpr2::IObserverWeaponFireIntInstance &interaction) override;
+  void deleteInterface() override;
+
+protected:
+  NGL::INGLLogger &m_logger;
+
+signals:
+  void newWeaponFire(const rpr2::IObserverWeaponFireIntInstance &interaction);
+};
+

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_observer_aircraft_object_cb.h

@@ -0,0 +1,19 @@
+/**
+  * class to handle signals for ObserverAircrafts functions
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#pragma once
+
+#include "rpr_observer_platform_object_cb.h"
+
+class ObserverAircraftObjectCB : public ObserverPlatformObjectCB
+{
+  Q_OBJECT
+public:
+  ObserverAircraftObjectCB(const char *loggerName = "Callbacks.Object.Aircraft")
+    : ObserverPlatformObjectCB(loggerName)
+  {}
+};

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_observer_aircraft_object_instance_cb.h

@@ -0,0 +1,47 @@
+/**
+  * template class to handle IObserverAircraftObjInstanceCB functions
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#pragma once
+
+#include <IObserverAircraftObjClassCB.h>
+#include <IObserverAircraftObjInstance.h>
+#include <IObserverAircraftObjInstanceCB.h>
+
+#include "rpr_observer_platform_object_instance_cb.h"
+
+class ObserverAircraftObjectCB;
+
+template<typename IOBJ_CB, typename OBJ, typename OBJ_CB>
+class ObserverAircraftObjInstanceCB : public ObserverPlatformObjInstanceCB<IOBJ_CB, OBJ, OBJ_CB>
+{
+public:
+  explicit ObserverAircraftObjInstanceCB(OBJ_CB &hoicb, const char *loggerName = "Callbacks.Object.Aircraft")
+    : ObserverPlatformObjInstanceCB<IOBJ_CB, OBJ, OBJ_CB>(hoicb, loggerName)
+  {}
+
+  void changedAfterburnerOn(bool) override {}
+  void changedAntiCollisionLightsOn(bool) override {}
+  void changedBlackOutBrakeLightsOn(bool) override {}
+  void changedBlackOutLightsOn(bool) override {}
+  void changedBrakeLightsOn(bool) override {}
+  void changedFormationLightsOn(bool) override {}
+  void changedHatchState(rpr2::HatchStateEnum32::ET) override {}
+  void changedHeadLightsOn(bool) override {}
+  void changedInteriorLightsOn(bool) override {}
+  void changedLandingLightsOn(bool) override {}
+  void changedLauncherRaised(bool) override {}
+  void changedNavigationLightsOn(bool) override {}
+  void changedRampDeployed(bool) override {}
+  void changedRunningLightsOn(bool) override {}
+  void changedSpotLightsOn(bool) override {}
+  void changedTailLightsOn(bool) override {}
+
+};
+
+using ObserverAircraftObjInstanceCBType = ObserverAircraftObjInstanceCB<rpr2::IObserverAircraftObjInstanceCB,
+      rpr2::IObserverAircraftObjInstance,
+      ObserverAircraftObjectCB>;

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_observer_baseentity_object_cb.h

@@ -0,0 +1,56 @@
+/**
+  * class to handle signals for ObserverBaseEntities functions
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#pragma once
+
+#include "rpr_observer_object_cb.h"
+
+#include <EntityIdentifierStruct.h>
+
+namespace rpr2
+{
+class WorldLocationStruct;
+}
+
+class ObserverBaseEntityObjectCB : public ObserverObjectCB
+{
+  Q_OBJECT
+public:
+  ObserverBaseEntityObjectCB(const char *loggerName = "Callbacks.Object.BaseEntity")
+    : ObserverObjectCB(loggerName)
+  {}
+
+  void onEntityIdentifierChanged(const rpr2::EntityIdentifierStruct &eis, rpr2::IObserverBaseEntityObjInstance &object, const ngs::SimTime &simTime)
+  {
+    INFO_LOG(m_logger) << "EntityIdentifier changed for Base Entity Object. New EntityIdentifier: "
+                       << eis.FederateIdentifier.SiteID << "/"
+                       << eis.FederateIdentifier.ApplicationID << "/"
+                       << eis.EntityNumber;
+    emit entityIdentifierChanged(eis, &object, simTime.getSeconds() * 1000ULL + simTime.getMicroSeconds() / 1000ULL);
+  }
+
+  void onSpatialChanged(const rpr2::EntityIdentifierStruct &eis, const rpr2::WorldLocationStruct &wl, const ngs::SimTime &simTime)
+  {
+    emit spatialChanged(eis, wl, simTime.getSeconds() * 1000ULL + simTime.getMicroSeconds() / 1000ULL);
+  }
+
+  void onEntityTypeChanged(const rpr2::EntityIdentifierStruct &eis, const rpr2::EntityTypeStruct &ets, const ngs::SimTime &simTime)
+  {
+    emit entityTypeChanged(eis, ets, simTime.getSeconds() * 1000ULL + simTime.getMicroSeconds() / 1000ULL);
+  }
+
+  void onIsPartOfChanged(const rpr2::EntityIdentifierStruct &eis, const rpr2::IsPartOfStruct &ipos, const ngs::SimTime &simTime)
+  {
+    emit isPartOfChanged(eis, ipos, simTime.getSeconds() * 1000ULL + simTime.getMicroSeconds() / 1000ULL);
+  }
+
+Q_SIGNALS:
+  void entityIdentifierChanged(const rpr2::EntityIdentifierStruct &eis, rpr2::IObserverBaseEntityObjInstance *object, qint64 simTimeMSecs);
+  void spatialChanged(const rpr2::EntityIdentifierStruct &eis, const rpr2::WorldLocationStruct &wl, qint64 simTimeMSecs);
+  void entityTypeChanged(const rpr2::EntityIdentifierStruct &eis, const rpr2::EntityTypeStruct &ets, qint64 simTimeMSecs);
+  void isPartOfChanged(const rpr2::EntityIdentifierStruct &eis, const rpr2::IsPartOfStruct &ipos, qint64 simTimeMSecs);
+};

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_observer_baseentity_object_instance_cb.h

@@ -0,0 +1,133 @@
+/**
+  * template class to handle IObserverBaseEntityObjInstanceCB functions
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#pragma once
+
+#include <IObserverBaseEntityObjInstanceCB.h>
+#include <EntityIdentifierStruct.h>
+#include <SpatialStruct.h>
+#include <WorldLocationStruct.h>
+
+#include <NGSUtils/SimTime.h>
+
+#include "rpr_observer_object_instance_cb.h"
+
+template<typename IOBJ_CB, typename OBJ, typename OBJ_CB>
+class ObserverBaseEntityObjInstanceCB : public ObserverObjectInstanceCB<IOBJ_CB, OBJ, OBJ_CB>
+{
+public:
+  explicit ObserverBaseEntityObjInstanceCB(OBJ_CB &hoicb, const char *loggerName = "Callbacks.Object.BaseEntity")
+    : ObserverObjectInstanceCB<IOBJ_CB, OBJ, OBJ_CB>(hoicb, loggerName)
+  {}
+
+  //
+  // IObserverObjectInstanceCallback
+  //
+  void changedSpatial(const rpr2::SpatialStruct &data) override
+  {
+    if (!this->m_pIObject->isValidEntityType())
+      return;
+
+    rpr2::DeadReckoningAlgorithmEnum8::ET d = data.DeadReckoningAlgorithm__A__Alternatives.discriminant();
+    switch (d)
+    {
+    case  rpr2::DeadReckoningAlgorithmEnum8::Other:
+      // nothing
+      break;
+    case rpr2::DeadReckoningAlgorithmEnum8::Static:
+    {
+      rpr2::WorldLocationStruct wl = data.DeadReckoningAlgorithm__A__Alternatives.SpatialStatic().WorldLocation;
+      try
+      {
+        //Bei anderen Projekten muss ein Mapping stattfinden. Dies wird jetzt im NGSInterface erledigt.
+        //m_pCB->onSpatialChanged(m_pIObject->getEntityIdentifier().EntityNumber, wl, simTimeMSecs);
+        this->m_pCB->onSpatialChanged(this->m_pIObject->getEntityIdentifier(), wl, this->m_pIObject->getLatestTimeStamp());
+      }
+      catch (...)
+      {
+        ERROR_LOG(this->m_logger) << "Human-Callback threw Exception in 'newTlnPos()";
+      }
+      break;
+    }
+    case rpr2::DeadReckoningAlgorithmEnum8::DRM_FPW:
+    {
+      rpr2::WorldLocationStruct wl = data.DeadReckoningAlgorithm__A__Alternatives.SpatialFPW().WorldLocation;
+      try
+      {
+        this->m_pCB->onSpatialChanged(this->m_pIObject->getEntityIdentifier(), wl, this->m_pIObject->getLatestTimeStamp());
+      }
+      catch (...)
+      {
+        ERROR_LOG(this->m_logger) << "Human-Callback threw Exception in 'newTlnPos()";
+      }
+      break;
+    }
+    case rpr2::DeadReckoningAlgorithmEnum8::DRM_RPW:
+      DEBUG_LOG(this->m_logger) << "ObserverHumanObjInstanceCB::changedSpatial, case rpr2::DeadReckoningAlgorithmEnum8::DRM_RPW";
+      break;
+    case rpr2::DeadReckoningAlgorithmEnum8::DRM_RVW:
+      DEBUG_LOG(this->m_logger) << "ObserverHumanObjInstanceCB::changedSpatial, case rpr2::DeadReckoningAlgorithmEnum8::DRM_RVW";
+      break;
+    case rpr2::DeadReckoningAlgorithmEnum8::DRM_FVW:
+      DEBUG_LOG(this->m_logger) << "ObserverHumanObjInstanceCB::changedSpatial, case rpr2::DeadReckoningAlgorithmEnum8::DRM_FVW";
+      break;
+    case rpr2::DeadReckoningAlgorithmEnum8::DRM_FPB:
+      DEBUG_LOG(this->m_logger) << "ObserverHumanObjInstanceCB::changedSpatial, case rpr2::DeadReckoningAlgorithmEnum8::DRM_FPB";
+      break;
+    case rpr2::DeadReckoningAlgorithmEnum8::DRM_RPB:
+      DEBUG_LOG(this->m_logger) << "ObserverHumanObjInstanceCB::changedSpatial, case rpr2::DeadReckoningAlgorithmEnum8::DRM_RPB";
+      break;
+    case rpr2::DeadReckoningAlgorithmEnum8::DRM_RVB:
+      DEBUG_LOG(this->m_logger) << "ObserverHumanObjInstanceCB::changedSpatial, case rpr2::DeadReckoningAlgorithmEnum8::DRM_RVB";
+      break;
+    case rpr2::DeadReckoningAlgorithmEnum8::DRM_FVB:
+      DEBUG_LOG(this->m_logger) << "ObserverHumanObjInstanceCB::changedSpatial, case rpr2::DeadReckoningAlgorithmEnum8::DRM_FVB";
+      break;
+    }
+  }
+
+  void receivedSpatial(const rpr2::SpatialStruct &, const ngs::SimTime &simTime) override
+  {
+    m_lastPositionTime = simTime;
+  }
+
+  void changedEntityIdentifier(const rpr2::EntityIdentifierStruct &data) override
+  {
+    if (!this->m_pIObject->isValidEntityType())
+    {
+      ERROR_LOG(this->m_logger) << "No valid Entity.";
+      return;
+    }
+    this->m_pCB->onEntityIdentifierChanged(data, *this->m_pIObject, this->m_pIObject->getLatestTimeStamp());
+  }
+
+  void changedEntityType(const rpr2::EntityTypeStruct &value) override
+  {
+    if (!this->m_pIObject->isValidEntityType())
+      return;
+
+    this->m_pCB->onEntityTypeChanged(this->m_pIObject->getEntityIdentifier(),
+                                     value,
+                                     this->m_pIObject->getLatestTimeStamp());
+
+  }
+
+  void changedIsPartOf(const rpr2::IsPartOfStruct &value) override
+  {
+    if (!this->m_pIObject->isValidEntityType())
+      return;
+
+    this->m_pCB->onIsPartOfChanged(this->m_pIObject->getEntityIdentifier(),
+                                   value,
+                                   this->m_pIObject->getLatestTimeStamp());
+  }
+
+  // Declarations for pure virtual functions
+  void changedRelativeSpatial(const rpr2::SpatialStruct &) override {}
+protected:
+  ngs::SimTime     m_lastPositionTime;
+};

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_observer_designator_cb_notifier.h

@@ -0,0 +1,33 @@
+/**
+  * A notifier to inform NGSConnector about changes in an Designator instance
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#pragma once
+
+#include "rpr_global.h"
+#include "rpr_observer_designator_object_cb.h"
+#include "rpr_observer_designator_object_instance_cb.h"
+
+/**
+  * The notifier for new Designator instances
+  */
+class ObserverDesignatorCBNotifier : public ObserverDesignatorObjectCB, public rpr2::IObserverDesignatorObjClassCB
+{
+  Q_OBJECT
+public:
+  ObserverDesignatorCBNotifier()
+    : ObserverDesignatorObjectCB("Callbacks.Object.Designator")
+    , rpr2::IObserverDesignatorObjClassCB()
+  {}
+
+  //Abstract functions realized from IObserverDesignatorObjClassCB
+  rpr2::IObserverDesignatorObjInstanceCB &newDesignatorObjInstance(rpr2::IObserverDesignatorObjInstance &object) override
+  {
+    return newObjectInstance<ObserverDesignatorObjInstanceCBType>(object);
+  }
+
+  void deleteInterface() override {}
+};

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_observer_designator_object_cb.h

@@ -0,0 +1,44 @@
+/**
+  * class to handle signals for ObserverDesignators functions
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#pragma once
+
+#include "rpr_observer_embeddedsystem_object_cb.h"
+#include <DesignatorCodeEnum16.h>
+
+class ObserverDesignatorObjectCB : public ObserverEmbeddedSystemObjectCB
+{
+  Q_OBJECT
+public:
+  ObserverDesignatorObjectCB(const char *loggerName = "Callbacks.Object.Designator")
+    : ObserverEmbeddedSystemObjectCB(loggerName)
+  {}
+
+
+  void onDesignatorCodeChanged(const rpr2::EntityIdentifierStruct &eis, rpr2::DesignatorCodeEnum16::ET value, const ngs::SimTime &simTime)
+  {
+    DEBUG_LOG(m_logger) << "Code changed: " << value;
+    emit designatorCodeChanged(eis, value, simTime.getSeconds() * 1000ULL + simTime.getMicroSeconds() / 1000ULL);
+  }
+
+  void onDesignatorOutputPowerChanged(const rpr2::EntityIdentifierStruct &eis, ngs::FLOAT32 value, const ngs::SimTime &simTime)
+  {
+    DEBUG_LOG(m_logger) << "Output Power changed: " << value;
+    emit designatorOutputPowerChanged(eis, value, simTime.getSeconds() * 1000ULL + simTime.getMicroSeconds() / 1000ULL);
+  }
+
+  void onDesignatorSpotLocationChanged(const rpr2::EntityIdentifierStruct &eis, const rpr2::WorldLocationStruct &value, const ngs::SimTime &simTime)
+  {
+    DEBUG_LOG(m_logger) << "Spot Location changed (not printed)";
+    emit designatorSpotLocationChanged(eis, value, simTime.getSeconds() * 1000ULL + simTime.getMicroSeconds() / 1000ULL);
+  }
+
+Q_SIGNALS:
+  void designatorCodeChanged(const rpr2::EntityIdentifierStruct &eis, rpr2::DesignatorCodeEnum16::ET value, qint64 simTimeMSecs);
+  void designatorOutputPowerChanged(const rpr2::EntityIdentifierStruct &eis, ngs::FLOAT32 value, qint64 simTimeMSecs);
+  void designatorSpotLocationChanged(const rpr2::EntityIdentifierStruct &eis, const rpr2::WorldLocationStruct &value, qint64 simTimeMSecs);
+};

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_observer_designator_object_instance_cb.h

@@ -0,0 +1,77 @@
+/**
+  * template class to handle IObserverDesignatorObjInstanceCB functions
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#pragma once
+
+#include <IObserverDesignatorObjClassCB.h>
+#include <IObserverDesignatorObjInstance.h>
+#include <IObserverDesignatorObjInstanceCB.h>
+
+#include <DesignatorCodeNameEnum16.h>
+
+#include "rpr_observer_embeddedsystem_object_instance_cb.h"
+
+class ObserverDesignatorObjectCB;
+
+template<typename IOBJ_CB, typename OBJ, typename OBJ_CB>
+class ObserverDesignatorObjInstanceCB : public ObserverEmbeddedSystemObjInstanceCB<IOBJ_CB, OBJ, OBJ_CB>
+{
+public:
+  explicit ObserverDesignatorObjInstanceCB(OBJ_CB &hoicb, const char *loggerName = "Callbacks.Object.Designator")
+    : ObserverEmbeddedSystemObjInstanceCB<IOBJ_CB, OBJ, OBJ_CB>(hoicb, loggerName)
+  {}
+
+  void changedDesignatorCode(rpr2::DesignatorCodeEnum16::ET value) override
+  {
+    if (!this->m_pIObject->isValidEntityIdentifier())
+    {
+      ERROR_LOG(this->m_logger) << "No valid Entity.";
+      return;
+    }
+    this->m_pCB->onDesignatorCodeChanged(this->m_pIObject->getEntityIdentifier(),
+                                         value,
+                                         this->m_pIObject->getLatestTimeStamp());
+  }
+
+  void changedDesignatorOutputPower(ngs::FLOAT32 value) override
+  {
+    if (!this->m_pIObject->isValidEntityIdentifier())
+    {
+      ERROR_LOG(this->m_logger) << "No valid Entity.";
+      return;
+    }
+    this->m_pCB->onDesignatorOutputPowerChanged(this->m_pIObject->getEntityIdentifier(),
+                                                value,
+                                                this->m_pIObject->getLatestTimeStamp());
+  }
+
+  void changedDesignatorSpotLocation(const rpr2::WorldLocationStruct &value) override
+  {
+    if (!this->m_pIObject->isValidEntityIdentifier())
+    {
+      ERROR_LOG(this->m_logger) << "No valid Entity.";
+      return;
+    }
+    this->m_pCB->onDesignatorSpotLocationChanged(this->m_pIObject->getEntityIdentifier(),
+                                                 value,
+                                                 this->m_pIObject->getLatestTimeStamp());
+  }
+
+
+  // Declarations for pure virtual functions
+  void changedCodeName(rpr2::DesignatorCodeNameEnum16::ET) override {}
+  void changedDesignatedObjectIdentifier(const  rpr2::RTIObjectIdStruct&) override {}
+  void changedDesignatorEmissionWavelength(ngs::FLOAT32) override {}
+  void changedDeadReckoningAlgorithm(rpr2::DeadReckoningAlgorithmEnum8::ET) override {}
+  void changedRelativeSpotLocation(const  rpr2::RelativePositionStruct&) override {}
+  void changedSpotLinearAccelerationVector(const  rpr2::AccelerationVectorStruct&) override {}
+
+};
+
+using ObserverDesignatorObjInstanceCBType = ObserverDesignatorObjInstanceCB<rpr2::IObserverDesignatorObjInstanceCB,
+      rpr2::IObserverDesignatorObjInstance,
+      ObserverDesignatorObjectCB>;

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_observer_embeddedsystem_object_cb.h

@@ -0,0 +1,45 @@
+/**
+  * class to handle signals for ObserverBaseEntities functions
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#pragma once
+
+#include "rpr_observer_object_cb.h"
+
+#include <EntityIdentifierStruct.h>
+#include <RTIObjectIdStruct.h>
+
+namespace rpr2
+{
+class WorldLocationStruct;
+}
+
+class ObserverEmbeddedSystemObjectCB : public ObserverObjectCB
+{
+  Q_OBJECT
+public:
+  ObserverEmbeddedSystemObjectCB(const char *loggerName = "Callbacks.Object.EmbeddedSystem")
+    : ObserverObjectCB(loggerName)
+  {}
+
+  void onEntityIdentifierChanged(const rpr2::EntityIdentifierStruct &eis, rpr2::IObserverEmbeddedSystemObjInstance &object, const ngs::SimTime simTime)
+  {
+    INFO_LOG(m_logger) << "EntityIdentifier changed for Embedded System Object. New EntityIdentifier: "
+                       << eis.FederateIdentifier.SiteID << "/"
+                       << eis.FederateIdentifier.ApplicationID << "/"
+                       << eis.EntityNumber;
+    emit entityIdentifierChanged(eis, &object, simTime.getSeconds() * 1000ULL + simTime.getMicroSeconds() / 1000ULL);
+  }
+
+//  void onHostObjectIdentifierChanged(const rpr2::EntityIdentifierStruct &eis, const rpr2::RTIObjectIdStruct &host, const ngs::SimTime &simTime)
+//  {
+//    emit objectIdentifierChanged(eis, host, simTime.getSeconds() * 1000ULL + simTime.getMicroSeconds() / 1000ULL);
+//  }
+
+Q_SIGNALS:
+  void entityIdentifierChanged(const rpr2::EntityIdentifierStruct &eis, rpr2::IObserverEmbeddedSystemObjInstance *object, qint64 simTimeMSecs);
+//  void objectIdentifierChanged(const rpr2::EntityIdentifierStruct &eis, const rpr2::RTIObjectIdStruct &wl, qint64 simTimeMSecs);
+};

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_observer_embeddedsystem_object_instance_cb.h

@@ -0,0 +1,58 @@
+/**
+  * template class to handle IObserverEmbeddedSystemObjInstanceCB functions
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#pragma once
+
+#include <IObserverEmbeddedSystemObjInstanceCB.h>
+#include <EntityIdentifierStruct.h>
+#include <SpatialStruct.h>
+#include <WorldLocationStruct.h>
+
+#include <NGSUtils/SimTime.h>
+
+#include "rpr_observer_object_instance_cb.h"
+
+template<typename IOBJ_CB, typename OBJ, typename OBJ_CB>
+class ObserverEmbeddedSystemObjInstanceCB : public ObserverObjectInstanceCB<IOBJ_CB, OBJ, OBJ_CB>
+{
+public:
+  explicit ObserverEmbeddedSystemObjInstanceCB(OBJ_CB &hoicb, const char *loggerName = "Callbacks.Object.EmbeddedSystem")
+    : ObserverObjectInstanceCB<IOBJ_CB, OBJ, OBJ_CB>(hoicb, loggerName)
+  {}
+
+  //
+  // IObserverObjectInstanceCallback
+  //
+  void changedEntityIdentifier(const rpr2::EntityIdentifierStruct &data) override
+  {
+    if (!this->m_pIObject->isValidEntityIdentifier())
+    {
+      ERROR_LOG(this->m_logger) << "No valid Entity.";
+      return;
+    }
+    this->m_pCB->onEntityIdentifierChanged(data, *this->m_pIObject, this->m_pIObject->getLatestTimeStamp());
+  }
+
+  /* Unused yet. It is in EntityIdentifier. Not nice, but that's how ICE sends the data.
+  void changedHostObjectIdentifier(const rpr2::RTIObjectIdStruct &data) override
+  {
+    if (!this->m_pIObject->isValidEntityIdentifier())
+    {
+      ERROR_LOG(this->m_logger) << "No valid Entity.";
+      return;
+    }
+    this->m_pCB->onHostObjectIdentifierChanged(this->m_pIObject->getEntityIdentifier(),
+                                               data,
+                                               this->m_pIObject->getLatestTimeStamp());
+  }
+  */
+  // Declarations for pure virtual functions
+  void changedHostObjectIdentifier(const rpr2::RTIObjectIdStruct &) override {}
+  void changedRelativePosition(const rpr2::RelativePositionStruct &) override {}
+protected:
+  ngs::SimTime     m_lastPositionTime;
+};

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_observer_groundvehicle_cb_notifier.h

@@ -0,0 +1,34 @@
+/**
+  * A notifier to inform NGSConnector about changes in an GroundVehicle instance
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#pragma once
+
+#include "rpr_global.h"
+#include "rpr_observer_groundvehicle_object_cb.h"
+#include "rpr_observer_groundvehicle_object_instance_cb.h"
+
+/**
+  * The notifier for new ground vehicle instances
+  */
+class ObserverGroundVehicleCBNotifier : public ObserverGroundVehicleObjectCB, public rpr2::IObserverGroundVehicleObjClassCB
+{
+  Q_OBJECT
+
+public:
+  ObserverGroundVehicleCBNotifier()
+    : ObserverGroundVehicleObjectCB("Callbacks.Object.GroundVehicle")
+    , rpr2::IObserverGroundVehicleObjClassCB()
+  {}
+
+  //Abstract functions realized from IObserverGroundVehicleObjClassCB
+  rpr2::IObserverGroundVehicleObjInstanceCB &newGroundVehicleObjInstance(rpr2::IObserverGroundVehicleObjInstance &object) override
+  {
+    return newObjectInstance<ObserverGroundVehicleObjInstanceCBType>(object);
+  }
+
+  void deleteInterface() override {}
+};

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_observer_groundvehicle_object_cb.h

@@ -0,0 +1,19 @@
+/**
+  * class to handle signals for ObserverHumans functions
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#pragma once
+
+#include "rpr_observer_platform_object_cb.h"
+
+class ObserverGroundVehicleObjectCB : public ObserverPlatformObjectCB
+{
+  Q_OBJECT
+public:
+  ObserverGroundVehicleObjectCB(const char *loggerName = "Callbacks.Object.GroundVehicle")
+    : ObserverPlatformObjectCB(loggerName)
+  {}
+};

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_observer_groundvehicle_object_instance_cb.h

@@ -0,0 +1,31 @@
+/**
+  * template class to handle IObserverGroundVehicleObjInstanceCB functions
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#pragma once
+
+#include <IObserverGroundVehicleObjClassCB.h>
+#include <IObserverGroundVehicleObjInstance.h>
+#include <IObserverGroundVehicleObjInstanceCB.h>
+
+#include "rpr_observer_platform_object_instance_cb.h"
+
+class ObserverGroundVehicleObjectCB;
+
+template<typename IOBJ_CB, typename OBJ, typename OBJ_CB>
+class ObserverGroundVehicleObjInstanceCB : public ObserverPlatformObjInstanceCB<IOBJ_CB,
+  OBJ,
+  OBJ_CB>
+{
+public:
+  explicit ObserverGroundVehicleObjInstanceCB(OBJ_CB &hoicb, const char *loggerName = "Callbacks.Object.GroundVehicle")
+    : ObserverPlatformObjInstanceCB<IOBJ_CB, OBJ, OBJ_CB>(hoicb, loggerName)
+  {}
+};
+
+using ObserverGroundVehicleObjInstanceCBType = ObserverGroundVehicleObjInstanceCB<rpr2::IObserverGroundVehicleObjInstanceCB,
+      rpr2::IObserverGroundVehicleObjInstance,
+      ObserverGroundVehicleObjectCB>;

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_observer_human_cb_notifier.h

@@ -0,0 +1,33 @@
+/**
+  * A notifier to inform NGSConnector about changes in an Human instance
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#pragma once
+
+#include "rpr_global.h"
+#include "rpr_observer_human_object_cb.h"
+#include "rpr_observer_human_object_instance_cb.h"
+
+/**
+  * The notifier for new human instances
+  */
+class ObserverHumanCBNotifier : public ObserverHumanObjectCB, public rpr2::IObserverHumanObjClassCB
+{
+  Q_OBJECT
+public:
+  ObserverHumanCBNotifier()
+    : ObserverHumanObjectCB("Callbacks.Object.Human")
+    , rpr2::IObserverHumanObjClassCB()
+  {}
+
+  //Abstract functions realized from IObserverHumanObjClassCB
+  rpr2::IObserverHumanObjInstanceCB &newHumanObjInstance(rpr2::IObserverHumanObjInstance &object) override
+  {
+    return newObjectInstance<ObserverHumanObjInstanceCBType>(object);
+  }
+
+  void deleteInterface() override {}
+};

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_observer_human_object_cb.h

@@ -0,0 +1,19 @@
+/**
+  * class to handle signals for ObserverHumans functions
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#pragma once
+
+#include "rpr_observer_lifeform_object_cb.h"
+
+class ObserverHumanObjectCB : public ObserverLifeformObjectCB
+{
+  Q_OBJECT
+public:
+  ObserverHumanObjectCB(const char *loggerName = "Callbacks.Object.Human")
+    : ObserverLifeformObjectCB(loggerName)
+  {}
+};

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_observer_human_object_instance_cb.h

@@ -0,0 +1,29 @@
+/**
+  * template class to handle IObserverHumanObjInstanceCB functions
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#pragma once
+
+#include <IObserverHumanObjClassCB.h>
+#include <IObserverHumanObjInstance.h>
+#include <IObserverHumanObjInstanceCB.h>
+
+#include "rpr_observer_lifeform_object_instance_cb.h"
+
+class ObserverHumanObjectCB;
+
+template<typename IOBJ_CB, typename OBJ, typename OBJ_CB>
+class ObserverHumanObjInstanceCB : public ObserverLifeformObjInstanceCB<IOBJ_CB, OBJ, OBJ_CB>
+{
+public:
+  explicit ObserverHumanObjInstanceCB(OBJ_CB &hoicb, const char *loggerName = "Callbacks.Object.Human")
+    : ObserverLifeformObjInstanceCB<IOBJ_CB, OBJ, OBJ_CB>(hoicb, loggerName)
+  {}
+};
+
+using ObserverHumanObjInstanceCBType = ObserverHumanObjInstanceCB<rpr2::IObserverHumanObjInstanceCB,
+      rpr2::IObserverHumanObjInstance,
+      ObserverHumanObjectCB>;

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_observer_lifeform_object_cb.h

@@ -0,0 +1,19 @@
+/**
+  * class to handle signals for ObserverLifeforms functions
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#pragma once
+
+#include "rpr_observer_physicalentity_object_cb.h"
+
+class ObserverLifeformObjectCB : public ObserverPhysicalEntityObjectCB
+{
+  Q_OBJECT
+public:
+  ObserverLifeformObjectCB(const char *loggerName = "Callbacks.Object.Lifeform")
+    : ObserverPhysicalEntityObjectCB(loggerName)
+  {}
+};

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_observer_lifeform_object_instance_cb.h

@@ -0,0 +1,40 @@
+/**
+  * template class to handle IObserverLifeformObjInstanceCB functions
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#pragma once
+
+#include <IObserverLifeformObjClassCB.h>
+#include <IObserverLifeformObjInstance.h>
+#include <IObserverLifeformObjInstanceCB.h>
+
+#include "rpr_observer_physicalentity_object_instance_cb.h"
+
+class ObserverLifeformObjectCB;
+
+template<typename IOBJ_CB, typename OBJ, typename OBJ_CB>
+class ObserverLifeformObjInstanceCB : public ObserverPhysicalEntityObjInstanceCB<IOBJ_CB, OBJ, OBJ_CB>
+{
+public:
+  explicit ObserverLifeformObjInstanceCB(OBJ_CB &hoicb, const char *loggerName = "Callbacks.Object.Lifeform")
+    : ObserverPhysicalEntityObjInstanceCB<IOBJ_CB, OBJ, OBJ_CB>(hoicb, loggerName)
+  {}
+
+  //
+  // IObserverLifeformObjInstanceCB
+  //
+  // Declarations for pure virtual functions
+  void changedFlashLightsOn(bool) override {}
+  void changedStanceCode(rpr2::StanceCodeEnum32::ET) override {}
+  void changedPrimaryWeaponState(rpr2::WeaponStateEnum32::ET) override {}
+  void changedSecondaryWeaponState(rpr2::WeaponStateEnum32::ET) override {}
+  void changedComplianceState(rpr2::ComplianceStateEnum32::ET) override {}
+};
+
+using ObserverLifeformObjInstanceCBType = ObserverLifeformObjInstanceCB<rpr2::IObserverLifeformObjInstanceCB,
+      rpr2::IObserverLifeformObjInstance,
+      ObserverLifeformObjectCB>;
+

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_observer_longbow_apache_cb_notifier.h

@@ -0,0 +1,33 @@
+/**
+  * A notifier to inform NGSConnector about changes in an GuezObserverController instance
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#pragma once
+
+#include "rpr_global.h"
+#include "rpr_observer_longbow_apache_object_cb.h"
+#include "rpr_observer_longbow_apache_object_instance_cb.h"
+
+/**
+  * The notifier for new longbow apache instances
+  */
+class ObserverLongBowApacheCBNotifier : public ObserverLongBowApacheObjectCB, public rpr2::IObserverLongBowApacheObjClassCB
+{
+  Q_OBJECT
+public:
+  ObserverLongBowApacheCBNotifier()
+    : ObserverLongBowApacheObjectCB("Callbacks.Object.LongBowApache")
+    , rpr2::IObserverLongBowApacheObjClassCB()
+  {}
+
+  //Abstract functions realized from IObserverGuezObserverControllerObjClassCB
+  rpr2::IObserverLongBowApacheObjInstanceCB &newLongBowApacheObjInstance(rpr2::IObserverLongBowApacheObjInstance &object) override
+  {
+    return newObjectInstance<ObserverLongBowApacheObjInstanceCBType>(object);
+  }
+
+  void deleteInterface() override {}
+};

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_observer_longbow_apache_object_cb.h

@@ -0,0 +1,30 @@
+/**
+  * class to handle signals for ObserverGuezObserverControllers functions
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#pragma once
+
+#include "rpr_observer_aircraft_object_cb.h"
+
+#include <SensorFieldEnum32.h>
+
+class ObserverLongBowApacheObjectCB : public ObserverAircraftObjectCB
+{
+  Q_OBJECT
+public:
+  ObserverLongBowApacheObjectCB(const char *loggerName = "Callbacks.Object.LongBowApache")
+    : ObserverAircraftObjectCB(loggerName)
+  {}
+
+  void onSensorChanged(const rpr2::EntityIdentifierStruct &eis, rpr2::SensorFieldEnum32::ET value, const ngs::SimTime &simTime)
+  {
+    emit sensorChanged(eis, value, simTime.getSeconds() * 1000ULL + simTime.getMicroSeconds() / 1000ULL);
+  }
+
+Q_SIGNALS:
+  void sensorChanged(const rpr2::EntityIdentifierStruct &eis, rpr2::SensorFieldEnum32::ET value, qint64 simTimeMSecs);
+
+};

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_observer_longbow_apache_object_instance_cb.h

@@ -0,0 +1,45 @@
+/**
+  * template class to handle IObserverGuezObserverControllerObjInstanceCB functions
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#pragma once
+
+#include <IObserverLongBowApacheObjClassCB.h>
+#include <IObserverLongBowApacheObjInstance.h>
+#include <IObserverLongBowApacheObjInstanceCB.h>
+
+#include "rpr_observer_aircraft_object_instance_cb.h"
+
+class ObserverLongBowApacheObjectCB;
+
+template<typename IOBJ_CB, typename OBJ, typename OBJ_CB>
+class ObserverLongBowApacheObjInstanceCB : public ObserverAircraftObjInstanceCB<IOBJ_CB,
+  OBJ,
+  OBJ_CB>
+{
+public:
+  explicit ObserverLongBowApacheObjInstanceCB(OBJ_CB &hoicb, const char *loggerName = "Callbacks.Object.LongBowApache")
+    : ObserverAircraftObjInstanceCB<IOBJ_CB, OBJ, OBJ_CB>(hoicb, loggerName)
+  {}
+
+  void changedSensor(rpr2::SensorFieldEnum32::ET value) override
+  {
+    if (!this->m_pIObject->isValidEntityType())
+    {
+      ERROR_LOG(this->m_logger) << "No valid Entity.";
+      return;
+    }
+    this->m_pCB->onSensorChanged(this->m_pIObject->getEntityIdentifier(),
+                                 value,
+                                 this->m_pIObject->getLatestTimeStamp());
+
+  }
+
+};
+
+using ObserverLongBowApacheObjInstanceCBType = ObserverLongBowApacheObjInstanceCB<rpr2::IObserverLongBowApacheObjInstanceCB,
+      rpr2::IObserverLongBowApacheObjInstance,
+      ObserverLongBowApacheObjectCB>;

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_observer_object_cb.h

@@ -0,0 +1,48 @@
+/**
+  * class to handle signals for ObserverObjects functions
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#pragma once
+
+#include <QObject>
+#include <IObserverBaseEntityObjInstance.h>
+#include <IObserverEmbeddedSystemObjInstance.h>
+#include <IObserverEnvironmentObjectObjInstance.h>
+
+#include <Common/logger.h>
+
+class ObserverObjectCB : public QObject
+{
+  Q_OBJECT
+public:
+  ObserverObjectCB(const char *loggerName = "Callbacks.Object.Object")
+    : m_logger(HighLevelArchitecture::getLogger(loggerName))
+  {}
+
+  template<typename T>
+  typename T::IObjectCallback &newObjectInstance(typename T::Object &object)
+  {
+    typedef typename T::ObjectCallback OBJ_CB;
+
+    OBJ_CB *that = dynamic_cast<OBJ_CB *>(this);
+    T *cb = new T(*that);       //Neues Observer-Objekt erstellen
+    cb->setInterface(&object);            //Merken des Objekts, falls man die get-Funktionen nutzen möchte
+    emit newObjectInstance2(object);       //Bekannt machen, das ein neues Objekt gemeldet wurde
+    return *cb;   //Hier wird der Observer für dieses Objekt zurückgegeben.
+  }
+
+  void deleteObjectInstance(const ngs::IObserverObjectInstance &object)
+  {
+    emit objectInstanceDeleted(object);
+  }
+Q_SIGNALS:
+  void newObjectInstance(const ngs::IObserverObjectInstance &object);
+  void newObjectInstance2(const ngs::IObserverObjectInstance &object);
+  void objectInstanceDeleted(const ngs::IObserverObjectInstance &object);
+
+protected:
+  NGL::INGLLogger &m_logger;
+};

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_observer_object_instance_cb.h

@@ -0,0 +1,51 @@
+/**
+  * template class to handle IObserverBaseEntityObjInstanceCB functions
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#pragma once
+
+#include <IObserverObjectInstanceCallback.h>
+
+#include <Common/logger.h>
+
+template<typename IOBJ_CB, typename OBJ, typename OBJ_CB>
+class ObserverObjectInstanceCB : public IOBJ_CB
+{
+public:
+  explicit ObserverObjectInstanceCB(OBJ_CB &hoicb, const char *loggerName = "Callbacks.Object.Object")
+    : m_pIObject(nullptr)
+    , m_pCB(&hoicb)
+    , m_logger(HighLevelArchitecture::getLogger(loggerName))
+  {}
+
+  void setInterface(OBJ *_piobject) { m_pIObject = _piobject; }
+
+  //
+  // IObserverObjectInstanceCallback
+  //
+  // Declarations for pure virtual functions
+  void deleteObjectInstance() override
+  {
+    DEBUG_LOG(m_logger) << "deleteObjectInstance";
+    if (m_pCB && m_pIObject)
+      m_pCB->deleteObjectInstance(*m_pIObject);
+    delete this;
+  }
+
+  void anyAttributesChanged() override
+  {
+    //DEBUG_LOG(m_logger) << "anyAttributeChanged on EntityID:"<< m_pIObject->getEntityIdentifier().EntityNumber;
+  }
+
+  typedef OBJ Object;
+  typedef OBJ_CB ObjectCallback;
+  typedef IOBJ_CB IObjectCallback;
+
+protected:
+  OBJ             *m_pIObject;
+  OBJ_CB          *m_pCB;
+  NGL::INGLLogger &m_logger;
+};

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_observer_physicalentity_object_cb.h

@@ -0,0 +1,46 @@
+/**
+  * class to handle signals for ObserverPhysicalEntities functions
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#pragma once
+
+#include "rpr_observer_baseentity_object_cb.h"
+#include <MarkingStruct.h>
+#include <DamageStatusEnum32.h>
+
+class ObserverPhysicalEntityObjectCB : public ObserverBaseEntityObjectCB
+{
+  Q_OBJECT
+public:
+  ObserverPhysicalEntityObjectCB(const char *loggerName = "Callbacks.Object.PhysicalEntity")
+    : ObserverBaseEntityObjectCB(loggerName)
+  {}
+
+  void onForceIdentifierChanged(const rpr2::EntityIdentifierStruct &eis,
+                                rpr2::ForceIdentifierEnum8::ET identifier,
+                                const ngs::SimTime &simTime)
+  {
+    emit forceIdentifierChanged(eis, identifier, simTime.getSeconds() * 1000ULL + simTime.getMicroSeconds() / 1000ULL);
+  }
+  void onMarkingChanged(const rpr2::EntityIdentifierStruct &eis,
+                        const rpr2::MarkingStruct &marking,
+                        const ngs::SimTime &simTime)
+  {
+    emit markingChanged(eis, marking, simTime.getSeconds() * 1000ULL + simTime.getMicroSeconds() / 1000ULL);
+  }
+  void onDamageStateChanged(const rpr2::EntityIdentifierStruct &eis,
+                            rpr2::DamageStatusEnum32::ET status,
+                            const ngs::SimTime &simTime)
+  {
+    emit damageStateChanged(eis, status, simTime.getSeconds() * 1000ULL + simTime.getMicroSeconds() / 1000ULL);
+  }
+
+
+Q_SIGNALS:
+  void forceIdentifierChanged(const rpr2::EntityIdentifierStruct &eis, rpr2::ForceIdentifierEnum8::ET state, qint64 simTimeMSecs);
+  void markingChanged(const rpr2::EntityIdentifierStruct &eis, const rpr2::MarkingStruct &marking, qint64 simTimeMSecs);
+  void damageStateChanged(const rpr2::EntityIdentifierStruct &eis, rpr2::DamageStatusEnum32::ET status, qint64 simTimeMSecs);
+};

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_observer_physicalentity_object_instance_cb.h

@@ -0,0 +1,76 @@
+/**
+  * template class to handle IObserverPhysicalEntityObjInstanceCB functions
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#pragma once
+
+#include <IObserverPhysicalEntityObjInstanceCB.h>
+#include <MarkingStruct.h>
+
+#include "rpr_observer_baseentity_object_instance_cb.h"
+
+template<typename IOBJ_CB, typename OBJ, typename OBJ_CB>
+class ObserverPhysicalEntityObjInstanceCB : public ObserverBaseEntityObjInstanceCB<IOBJ_CB, OBJ, OBJ_CB>
+{
+public:
+  explicit ObserverPhysicalEntityObjInstanceCB(OBJ_CB &hoicb, const char *loggerName = "Callbacks.Object.PhysicalEntity")
+    : ObserverBaseEntityObjInstanceCB<IOBJ_CB, OBJ, OBJ_CB>(hoicb, loggerName)
+  {}
+
+  //
+  // IObserverPhysicalEntityObjInstanceCB
+  //
+  void changedForceIdentifier(rpr2::ForceIdentifierEnum8::ET data) override
+  {
+    if (!this->m_pIObject->isValidEntityType())
+      return;
+    this->m_pCB->onForceIdentifierChanged(this->m_pIObject->getEntityIdentifier(),
+                                          data,
+                                          this->m_pIObject->getLatestTimeStamp());
+  }
+
+  void changedMarking(const rpr2::MarkingStruct &data) override
+  {
+    if (!this->m_pIObject->isValidEntityType())
+      return;
+    this->m_pCB->onMarkingChanged(this->m_pIObject->getEntityIdentifier(),
+                                  data,
+                                  this->m_pIObject->getLatestTimeStamp());
+  }
+  void changedDamageState(rpr2::DamageStatusEnum32::ET data) override
+  {
+    if (!this->m_pIObject->isValidEntityType())
+      return;
+    this->m_pCB->onDamageStateChanged(this->m_pIObject->getEntityIdentifier(),
+                                      data,
+                                      this->m_pIObject->getLatestTimeStamp());
+  }
+  // Declarations for pure virtual functions
+  void changedFirePowerDisabled(bool) override {}
+  void changedImmobilized(bool) override {}
+  void changedAcousticSignatureIndex(short) override {}
+  void changedAlternateEntityType(const rpr2::EntityTypeStruct &) override {}
+  void changedArticulatedParametersArray(const rpr2::ArrayOfArticulatedParameterStructDynamicHLAunpaddedLengthlessVarArray &) override {}
+  void receivedArticulatedParametersArray(const rpr2::ArrayOfArticulatedParameterStructDynamicHLAunpaddedLengthlessVarArray &, const ngs::SimTime &) override {}
+  void changedCamouflageType(rpr2::CamouflageEnum32::ET) override {}
+  void changedEngineSmokeOn(bool) override {}
+  void changedFlamesPresent(bool) override {}
+  void changedHasAmmunitionSupplyCap(bool) override {}
+  void changedHasFuelSupplyCap(bool) override {}
+  void changedHasRecoveryCap(bool) override {}
+  void changedHasRepairCap(bool) override {}
+  void changedInfraredSignatureIndex(short) override {}
+  void changedIsConcealed(bool) override {}
+  void changedLiveEntityMeasuredSpeed(unsigned short) override {}
+  void changedPowerPlantOn(bool) override {}
+  void changedPropulsionSystemsData(const rpr2::ArrayOfPropulsionSystemDataStructDynamicHLAlengthlessVarArray &) override {}
+  void changedRadarCrossSectionSignatureIndex(short) override {}
+  void changedSmokePlumePresent(bool) override {}
+  void changedTentDeployed(bool) override {}
+  void changedTrailingEffectsCode(rpr2::TrailingEffectsCodeEnum32::ET) override {}
+  void changedVectoringNozzleSystemData(const  rpr2::ArrayOfVectoringNozzleSystemDataStructDynamicHLAlengthlessVarArray &) override {}
+
+};

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_observer_platform_object_cb.h

@@ -0,0 +1,19 @@
+/**
+  * class to handle signals for ObserverPlatforms functions
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#pragma once
+
+#include "rpr_observer_physicalentity_object_cb.h"
+
+class ObserverPlatformObjectCB : public ObserverPhysicalEntityObjectCB
+{
+  Q_OBJECT
+public:
+  ObserverPlatformObjectCB(const char *loggerName = "Callbacks.Object.Platform")
+    : ObserverPhysicalEntityObjectCB(loggerName)
+  {}
+};

Lts/Proxies/HighLevelArchitecture/Apache/rpr/rpr_observer_platform_object_instance_cb.h

@@ -0,0 +1,42 @@
+/**
+  * template class to handle IObserverPlatformObjInstanceCB functions
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#pragma once
+
+#include <IObserverPlatformObjInstanceCB.h>
+
+#include "rpr_observer_physicalentity_object_instance_cb.h"
+
+template<typename IOBJ_CB, typename OBJ, typename OBJ_CB>
+class ObserverPlatformObjInstanceCB : public ObserverPhysicalEntityObjInstanceCB<IOBJ_CB, OBJ, OBJ_CB>
+{
+public:
+  explicit ObserverPlatformObjInstanceCB(OBJ_CB &hoicb, const char *loggerName = "Callbacks.Object.Platform")
+    : ObserverPhysicalEntityObjInstanceCB<IOBJ_CB, OBJ, OBJ_CB>(hoicb, loggerName)
+  {}
+
+  //
+  // IObserverPlatformObjInstanceCB
+  //
+  // Declarations for pure virtual functions
+  void changedAfterburnerOn(bool) override {}
+  void changedAntiCollisionLightsOn(bool) override {}
+  void changedBlackOutBrakeLightsOn(bool) override {}
+  void changedBlackOutLightsOn(bool) override {}
+  void changedBrakeLightsOn(bool) override {}
+  void changedFormationLightsOn(bool) override {}
+  void changedHatchState(rpr2::HatchStateEnum32::ET) override {}
+  void changedHeadLightsOn(bool) override {}
+  void changedInteriorLightsOn(bool) override {}
+  void changedLandingLightsOn(bool) override {}
+  void changedLauncherRaised(bool) override {}
+  void changedNavigationLightsOn(bool) override {}
+  void changedRampDeployed(bool) override {}
+  void changedRunningLightsOn(bool) override {}
+  void changedSpotLightsOn(bool) override {}
+  void changedTailLightsOn(bool) override {}
+};