reflectedObjectLists.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2020 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/

#pragma once

#include "vrlinkNetworkInterface/vrlinkNetworkInterfaceDefines.h"
#include <vl/reflectedEmitterSystemList.h>
#include <vl/reflectedObjectList.h>
#include <vrfExtObjects/reflectedDynamicTerrainList.h>
#include <vl/reflectedActiveSonarList.h>
#include <vrfExtObjects/reflectedNavAidList.h>
#include <vl/reflectedPropulsionNoiseList.h>
#include <vl/reflectedIffList.h>
#include <vrfExtObjects/reflectedControlObjectList.h>
#include <vrfExtObjects/reflectedExtAggregateList.h>
#include <vrfExtObjects/reflectedExtEntityList.h>
#include <vl/reflectedDesignatorList.h>
#include <vl/reflectedPropulsionNoiseList.h>
#include <vl/reflectedRadioTransmitterList.h>
#include <vl/reflectedRadioReceiverList.h>
#include <vl/reflectedIffList.h>

#include <vl/reflectedLandSurfaceList.h>
#include <vl/reflectedSubsurfaceLayerList.h>
#include <vl/reflectedWaterSurfaceList.h>
#include <vl/reflectedTroposphereLayerList.h>
#include <vl/reflectedTimeAndDateList.h>
#include <vl/reflectedWindCorridorList.h>

#include <vl/reflectedAerodromeList.h>

class DtReflectedEmitterSystemList;
class DtReflectedDesignatorList;
class DtReflectedActiveSonarList;
class DtReflectedPropulsionNoiseList;
class DtReflectedIffList;
class DtReflectedRadioTransmitterList;
class DtReflectedNavAidList;
class DtReflectedDynamicTerrainList;
class DtReflectedRadioReceiverList;
class DtExerciseConn;

#if DtHLA
namespace makVrfVrlinkExtToolkit
{
   class DtReflectedExtendedAttributesObjectList;
}
#endif

namespace makVrf
{
   struct DiscoveryCondition
   {
      DiscoveryCondition() : fcn(nullptr), userData(nullptr) {};
      void clear() { fcn = nullptr; userData = nullptr; };
      DtDiscoveryCondition fcn;
      void* userData;
   };

   template <typename T_ReflectedList>
   struct DtReflectedListInformation
   {
      T_ReflectedList* operator ->() { return reflectedList; };
      const T_ReflectedList* operator ->() const { return reflectedList; };
      T_ReflectedList* reflectedList = nullptr;
      bool createdLocally = false;
      DiscoveryCondition existingDiscoveryCondition;

      class ReflectedObjectList : T_ReflectedList
      {
      public:
         ReflectedObjectList(DtExerciseConn* exConn) : T_ReflectedList(exConn) {};

         DtDiscoveryCondition discoveryCondition() const { return T_ReflectedList::myDiscoveryCondition; };
         void* discoveryConditionData() const { return T_ReflectedList::myDiscoveryConditionParameter; };
      };

      void backup()
      {
         if (reflectedList)
         {
            existingDiscoveryCondition.fcn = ((ReflectedObjectList*)reflectedList)->discoveryCondition();
            existingDiscoveryCondition.userData = ((ReflectedObjectList*)reflectedList)->discoveryConditionData();
         }
      }

      DtReflectedListInformation& operator=(const DtReflectedListInformation& rhs)
      {
         reflectedList = rhs.reflectedList;
         createdLocally = false;

         return *this;
      }

      void create(DtExerciseConn* conn)
      {
         reflectedList = new T_ReflectedList(conn);
         createdLocally = true;
      }

      bool operator==(const DtReflectedListInformation& rhs) const
      {
         return ((rhs.createdLocally == createdLocally) &&
                 (rhs.reflectedList == reflectedList));
      }

      bool operator!=(const DtReflectedListInformation& rhs) const
      {
         return !(*this == rhs);
      }

      void cleanup()
      {
         if (createdLocally)
         {
            delete reflectedList;
            reflectedList = nullptr;
            createdLocally = false;
         }
         else if (reflectedList)
         {
            reflectedList->setDiscoveryCondition(existingDiscoveryCondition.fcn, existingDiscoveryCondition.userData);
            existingDiscoveryCondition.clear();
         }
      }

#if DtDIS
      void setTimeoutInterval(int timeout)
      {
         if (reflectedList)
         {
            reflectedList->setTimeoutInterval(timeout);
         }
      }

      void setTimeoutProcessing(bool b)
      {
         if (reflectedList)
         {
            reflectedList->setTimeoutProcessing(b);
         }
      }
#endif
   };

   struct DT_DLL_vrlinkNetworkInterface DtReflectedObjectLists
   {
      DtReflectedListInformation<DtReflectedExtEntityList> reflectedEntitiesList;
      DtReflectedListInformation<DtReflectedAggregateList> reflectedAggregatesList;
      DtReflectedListInformation<DtReflectedEnvironmentProcessList> reflectedEnvironmentalsList;
      DtReflectedListInformation<DtReflectedAerodromeList> reflectedAerodromesList;
      DtReflectedListInformation<DtReflectedEmitterSystemList> reflectedEmitterSystemList;
      DtReflectedListInformation<DtReflectedDesignatorList> reflectedDesignatorsList;
      DtReflectedListInformation<DtReflectedActiveSonarList> reflectedActiveSonarList;
      DtReflectedListInformation<DtReflectedPropulsionNoiseList> reflectedPropulsionNoiseList;
      DtReflectedListInformation<DtReflectedRadioTransmitterList> reflectedRadioTransmitterList;
      DtReflectedListInformation<DtReflectedNavAidList> reflectedNavAidTransmitterList;
      DtReflectedListInformation<DtReflectedRadioReceiverList> reflectedRadioReceiverList;
      DtReflectedListInformation<DtReflectedDynamicTerrainList> reflectedDynamicTerrainList;
      DtReflectedListInformation<DtReflectedIffList> reflectedIffList;
      DtReflectedListInformation<DtReflectedLandSurfaceList> reflectedLandSurfaceList;
      DtReflectedListInformation<DtReflectedSubsurfaceLayerList> reflectedSubsurfaceLayerList;
      DtReflectedListInformation<DtReflectedWaterSurfaceList> reflectedWaterSurfaceList;
      DtReflectedListInformation<DtReflectedTroposphereLayerList> reflectedTroposphereLayerList;
      DtReflectedListInformation<DtReflectedTimeAndDateList> reflectedTimeAndDateList;
      DtReflectedListInformation<DtReflectedWindCorridorList> reflectedWindCorridorList;
   #if DtHLA
      DtReflectedListInformation<makVrfVrlinkExtToolkit::DtReflectedExtendedAttributesObjectList> reflectedExtendedAttributesObjectList;
   #endif

#if DtDIS
      void setTimeoutInterval(int timeout)
      {
         reflectedEntitiesList.setTimeoutInterval(timeout);
         reflectedAerodromesList.setTimeoutInterval(timeout);
         reflectedAggregatesList.setTimeoutInterval(timeout);
         reflectedEnvironmentalsList.setTimeoutInterval(timeout);
         reflectedDesignatorsList.setTimeoutInterval(timeout);
         reflectedActiveSonarList.setTimeoutInterval(timeout);
         reflectedPropulsionNoiseList.setTimeoutInterval(timeout);
         reflectedRadioTransmitterList.setTimeoutInterval(timeout);
         reflectedNavAidTransmitterList.setTimeoutInterval(timeout);
         reflectedRadioReceiverList.setTimeoutInterval(timeout);
         reflectedRadioReceiverList.setTimeoutInterval(timeout);
         reflectedDynamicTerrainList.setTimeoutInterval(timeout);
         reflectedIffList.setTimeoutInterval(timeout);
         reflectedEmitterSystemList.setTimeoutInterval(timeout);
      }

      void setDisableTimeoutProcessing(bool b)
      {
         reflectedEntitiesList.setTimeoutProcessing(!b);
         reflectedAerodromesList.setTimeoutProcessing(!b);
         reflectedAggregatesList.setTimeoutProcessing(!b);
         reflectedEnvironmentalsList.setTimeoutProcessing(!b);
         reflectedDesignatorsList.setTimeoutProcessing(!b);
         reflectedActiveSonarList.setTimeoutProcessing(!b);
         reflectedPropulsionNoiseList.setTimeoutProcessing(!b);
         reflectedRadioTransmitterList.setTimeoutProcessing(!b);
         reflectedNavAidTransmitterList.setTimeoutProcessing(!b);
         reflectedRadioReceiverList.setTimeoutProcessing(!b);
         reflectedRadioReceiverList.setTimeoutProcessing(!b);
         reflectedDynamicTerrainList.setTimeoutProcessing(!b);
         reflectedIffList.setTimeoutProcessing(!b);
         reflectedEmitterSystemList.setTimeoutProcessing(!b);
      }
#endif
   };
}