remoteEnvironmentManager.h

Go to the documentation of this file.

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

#pragma once

#include "vrlinkNetworkInterface/vrlinkNetworkInterfaceDefines.h"
#include "vrlinkNetworkInterface/reflectedObjectLists.h"
#include "vrlinkNetworkInterface/remoteObjectManager.h"
#include <boost/function.hpp>
#include <boost/signals2.hpp>

class DtReflectedTimeAndDate;

namespace makVrf
{
   class DtRemoteObjectManager;
   class DtStateData;

   class DT_DLL_vrlinkNetworkInterface DtRemoteEnvironmentManager : public DtRemoteObjectManager
   {
   public:
      typedef std::function<bool(const InterfacesByReflectedObjectMap&)> HasTypeFunc;

      DtRemoteEnvironmentManager(DtVrlinkNetworkInterface*);

      virtual ~DtRemoteEnvironmentManager();

      virtual void setReflectedLists(const DtReflectedObjectLists& lists);
      virtual void cleanup();
      virtual void advanceFrame(DtVrfCallbackQueue* queue) override;
      virtual void init(DtStateDataManager* sdm, DtExerciseConn* connection, const DtReflectedObjectLists& reflectedLists) override;

   protected:
      virtual void stateDataToBeRemoved(const DtStateData*);
      boost::signals2::scoped_connection myStateDataRemovalConnection;

   protected:
      virtual void createReflectedLandSurfaceList(DtExerciseConn* exConn);
      virtual void createReflectedSubsurfaceLayerList(DtExerciseConn* exConn);
      virtual void createReflectedWaterSurfaceList(DtExerciseConn* exConn);
      virtual void createReflectedTroposphereLayerList(DtExerciseConn* exConn);
      virtual void createReflectedTimeAndDateList(DtExerciseConn* exConn);
      virtual void createReflectedWindCorridorList(DtExerciseConn* exConn);

   public:
      static void TimeAndDateAdditionCallback(DtReflectedTimeAndDate*, void*);
      virtual void processTimeAndDateAddition(DtReflectedTimeAndDate*);

      static void TimeAndDateRemovalCallback(DtReflectedTimeAndDate*, void*);
      virtual void processTimeAndDateRemoval(DtReflectedTimeAndDate*);

      static void WindCorridorAdditionCallback(DtReflectedWindCorridor*, void*);
      virtual void processWindCorridorAddition(DtReflectedWindCorridor*);

      static void WindCorridorRemovalCallback(DtReflectedWindCorridor*, void*);
      virtual void processWindCorridorRemoval(DtReflectedWindCorridor*);

      template<typename T, typename U>
      static void environmentConditionAddedCallback(T* object, void* usr);

      template<typename T, typename U>
      static void environmentConditionRemovedCallback(T* object, void* usr);
      
   protected:
      template<typename T, typename U>
      bool initializeRemoteEnvironmentCondition(DtStateData* sd, T* entity);
      
      virtual bool initializeRemoteWindCorridor(DtStateData* sd, DtReflectedWindCorridor*);

      template<typename T, typename U>
      void processEnvironmentConditionAdded(T* object);
      template <typename T>
      static bool hasTypeInMap(const DtRemoteObjectManager::InterfacesByReflectedObjectMap& map);

      template<typename T>
      static DtBoolean reflectedEnvironmentConditionDiscoveryCriteriaCallback(DtReflectedObject* object, void* userData);

      virtual DtBoolean processReflectedMetocRootDiscoveryCriteria(DtReflectedObject*);
      virtual DtBoolean processReflectedEnvironmentConditionDiscoveryCriteria(DtReflectedObject*);

      virtual void processEnvironmentConditionRemoved(DtReflectedObject* object, HasTypeFunc func);

      static DtEntityType geoLocationTypeToEntityIdentifier(DtGeoLocationTypeEnum32 type);
      virtual DtUUID uuidFor(DtStateRepository* sr, bool& hasVrfUUID) const;

   protected:
      virtual bool setupEntityIdentifierForMetocObject(DtStateData*, DtEntityIdentifier);

      struct WaitingForDiscoveryInterface
      {
         virtual void process(DtStateData*) = 0;
      };

      struct WaitingForDateTimeDiscovery : public WaitingForDiscoveryInterface
      {
         WaitingForDateTimeDiscovery(DtRemoteEnvironmentManager* mgr, DtReflectedTimeAndDate* object) : myRemoteObjectManager(mgr), myReflectedObject(object) {};

         virtual void process(DtStateData* stateData) override
         {
            myRemoteObjectManager->processTimeAndDateAddition(myReflectedObject);
         }

         DtRemoteEnvironmentManager* myRemoteObjectManager;
         DtReflectedTimeAndDate* myReflectedObject;
      };

      template <typename T, typename U>
      struct WaitingForDiscoveryStruct : public WaitingForDiscoveryInterface
      {
         WaitingForDiscoveryStruct(DtRemoteEnvironmentManager* mgr, T* object) : myRemoteObjectManager(mgr), myReflectedObject(object) {};

         virtual void process(DtStateData* stateData) override
         {
            myRemoteObjectManager->initializeRemoteEnvironmentCondition<T, U>(stateData, myReflectedObject);
         }

         DtRemoteEnvironmentManager* myRemoteObjectManager;
         T* myReflectedObject;
      };

      typedef std::map<DtReflectedObject*, std::shared_ptr<WaitingForDiscoveryInterface> > ObjectWaitingForDiscoveryMap;
      typedef std::map<DtUUID, ObjectWaitingForDiscoveryMap> WaitingForRemoteDiscovery;
      WaitingForRemoteDiscovery myWaitingForRemoteDiscovery;

      DtReflectedTimeAndDate* myReflectedTimeAndDate = nullptr;
      DtStateData* myGlobalEnvironment = nullptr;
      RemoteInterfacesMapById myRemoteInterfacesSetById;
   };
}