vrfSimBackendManager.h

Go to the documentation of this file.

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



#pragma once

#include <vrfGuiCore/vrfGuiCore.h>
#include <vrfGuiCore/vrfBackendState.h>
#include <vrfGuiCore/queuedManager.h>
#include <vrvUtil/DtSignalConnectionManager.h>

#include <vrvCore/DtSimData.h>
#include <vrvCore/DtDe.h>
#include <vrfutil/sessionStatus.h>

#include <boost/function.hpp>
#include <boost/signal.hpp>

class DtBackend;
class DtRwNLengthStringVector;
class DtSimulationAddress;
class DtSimMessage;
class DtIfLoadComplete;
class DtIfSaveComplete;

namespace makVrv
{
   class DtBaseSimulation;
}

const int DtSessionChangedTerrain   = 0x00000001;
const int DtSessionChangedScenario  = 0x00000002;
const int DtSessionChangedNumberBEs = 0x00000004;
const int DtSessionScenarioJustLoaded = 0x00000008;
const int DtSessionChangedSimulationModelSets = 0x00000010;
const int DtSessionScenarioJustClosed = 0x00000020;
const int DtSessionScenarioClosing = 0x00000040;
const int DtSessionScenarioLoading = 0x00000080;
const int DtSessionScenarioErrorLoading = 0x00000100;
const int DtSessionScenarioImporting = 0x00000200;
const int DtSessionScenarioJustImported = 0x00000400;
const int DtSessionScenarioSaveSimulationObjectGroup = 0x00000800;
const int DtSessionScenarioJustSavedSimulationObjectGroup = 0x00001000;
const int DtSessionChangedScenarioFilename  = 0x00002000;
const int DtSessionScenarioJustRolledBack = 0x00004000;
const int DtSessionScenarioRollingBack = 0x00008000;
const int DtSessionSimulationStateChanged = 0x00010000;
const int DtSessionChangedSimTerrain = 0x00020000;
const int DtSessionScenarioReinitializing = 0x00040000;
const int DtSessionScenarioJustReinitialized = 0x00080000;

namespace makVrf
{
   class DtVrfBackEndState;
   class DtLocalWeatherManager;

   class DT_DLL_VRFGUICORE DtVrfSimBackendManager : public DtQueuedManager
   {
   public:
      typedef std::map<std::string, DtVrfBackendState*> DtVrfSimBackendStates;

   public:
      DtVrfSimBackendManager(makVrv::DtDe&);
      virtual ~DtVrfSimBackendManager();

      static DtVrfSimBackendManager& instance(makVrv::DtDe& de);

   public:
      virtual bool backEndsPresent() const;

      virtual bool anyBackendsLoading() const;

      virtual bool anyBackendsCreatingSimulationObjectGroup() const;

      virtual bool anyBackendsClosing() const;

      virtual bool allBackendsClosingOrClosed() const;

      virtual bool anyBackendsLoaded() const;

      virtual bool allBackendsLoaded() const;

      virtual bool backendLoaded(const DtSimulationAddress&) const;

      virtual bool backendSaving(const DtSimulationAddress&) const;

      virtual bool anyBackendsPlaying() const;

      virtual bool anyBackendsInControlState(int state) const;

      virtual bool hasDynamicTerrainServer() const;

      virtual bool allBackendsCanSimulate() const;

      virtual bool anyBackendCanSimulate() const;

      virtual bool backendCanSimulate(const DtSimulationAddress&) const;

      virtual void duplicateBackendDiscovered(const DtSimulationAddress&);

      virtual double timeMultiplier() const;


      virtual void removeAllBackends();
      virtual void addBackend(const DtBackend*);
      virtual void backendRemoved(const DtSimulationAddress&);
      virtual void backendUpdated(const DtSimulationAddress&, const DtBackend*);

      virtual DtVrfBackendState* stateFor(const DtSimulationAddress&) const;

      virtual const DtSimulationAddress& selectedBackend() const
      {
         return mySelectedBackend;
      }

      void setSelectedBackend(const DtSimulationAddress&);

      virtual void simulationAddresses(std::set<std::string>&);

      virtual int numberOfBackends() const;

      virtual void clearSelectedBackend();

      virtual DtVrfBackendState* firstTimeBackend() const;

      virtual double simTime() const;

      virtual double runDurationTime() const;

      virtual int scenarioRunId() const;

      virtual double timeOfDay() const;

      virtual double simStartSimTime() const;

      const DtVrfSimBackendStates& backendStates() const
      {
         return myBackendStates;
      }

      const DtVrfSimBackendStates& allBackendStates() const
      {
         return myAllBackendStates;
      }

      virtual std::map<short, int> currentObjectCounts() const;

      virtual const std::map<short, int>& currentObjectCount(const DtSimulationAddress&) const;

   public:
      virtual void signalWhenAllBackendsClosed();

      virtual void signalIfAllBackendsClosed();
      boost::signal<void ()> signal_allBackendsClosed;

      virtual void signalWhenAllBackendsLoaded();

      virtual void clearNotificationWhenBackendsLoaded();

      virtual void signalIfAllBackendsLoaded();
      boost::signal<void ()> signal_allBackendsLoaded;

      virtual void signalWhenAllBackendsSaved();

      virtual void clearNotificationWhenBackendsSaved();

      virtual void signalIfAllBackendsSaved(bool checkpointSave);
      boost::signal<void (bool)> signal_allBackendsSaved;

      std::string sessionScenario() const
      {
         return mySessionStatus.scenarioName().c_str();
      }

      virtual void setSessionScenario(const std::string&);

      std::string sessionScenarioFilename() const
      {
         return mySessionStatus.scenarioFilename().c_str();
      }

      virtual void setSessionScenarioFilename(const std::string&);

      std::string sessionGuiTerrain() const
      {
         return mySessionStatus.guiTerrainName().c_str();
      }

      virtual void setSessionGuiTerrain(const std::string&);

      std::string sessionSimTerrain() const
      {
         return mySessionStatus.terrainName().c_str();
      }

      virtual void setSessionSimTerrain(const std::string&);

      const std::vector<DtFilename>& simulationModelSets() const
      {
         return mySessionStatus.simulationModelSets();
      }

      virtual void setSimulationModelSets(const DtRwNLengthStringVector&);

      virtual void sessionStatusChanged(const DtSessionStatus& status);

      virtual time_t dateAndTimeOfDay() const;
      virtual void setDateAndTimeOfDay(time_t);
      virtual void resetDateAndTimeOfDay();

      virtual const std::map<std::string, bool> backendsLoading() const
      {
         return myLoadingMap;
      }

      virtual const std::map<std::string, bool> backendsClosing() const
      {
         return myClosingMap;
      }

   public:
      boost::signal<void (const DtVrfBackendState&)> signal_frameRatesUpdated;
      boost::signal<void (const DtVrfBackendState&)> signal_backendDiscovered;
      boost::signal<void (const DtVrfBackendState&)> signal_nonSimulationBackendDiscovered;
      boost::signal<void (const DtVrfBackendState&)> signal_backendRemoved;
      boost::signal<void (const DtVrfBackendState&)> signal_nonSimulationBackenRemoved;
      boost::signal<void (const DtVrfBackendState&, int)> signal_backendUpdated;
      boost::signal<void (int)> signal_sessionUpdated;
      boost::signal<void (const DtVrfBackendState&)> signal_duplicateSimulationAddress;
      boost::signal<void (const DtSimulationAddress& old, const DtSimulationAddress& newaddr)> signal_selectedBackendChanged;
      boost::signal<void ()> signal_allBackendsAboutToBeRemoved;

   protected:
      virtual DtLocalWeatherManager& localWeatherManager() const;

      virtual void tick();

      virtual double simTimeFromBackend() const;

      virtual void updateDateAndTimeOfDay();
      virtual void slot_dateAndTimeOfDayChanged(int year, int month, int day, int hours, int mins, int secs);

      virtual void slot_frameRatesUpdated(const DtVrfBackendState&);
      virtual void simulationBackendRemoved(DtVrfBackendState*);
      virtual void simulationBackendDiscovered(DtVrfBackendState*);
      virtual void simulationBackendUpdated(DtSimulationAddress, int);
      virtual void duplicateSimulationBackendDiscovered(DtSimulationAddress);
      virtual void processSessionStatusChange(DtSessionStatus);

      virtual void processLoadCompleteCallback(DtSimMessage*);
      virtual void processSaveCompleteCallback(DtSimMessage*);

      virtual void backendSaved(const std::string&, bool checkpointSave);

      virtual void setBackendSaving(const DtSimulationAddress&, bool b);

      virtual void updateSessionInformation(int sessionFlags = 0);

      virtual void clear();

   protected:
      makVrv::DtBaseSimulation*   mySimulation;
      DtVrfSimBackendStates      myBackendStates;
      DtVrfSimBackendStates      myAllBackendStates;
      DtSimulationAddress        mySelectedBackend;
      bool                       mySignalWhenAllBackendsClosed;
      bool                       mySignalWhenAllBackendsLoaded;
      bool                       mySignalWhenAllBackendsSaved;
      std::map<std::string, char> myBackendsWaitingForSave;
      std::map<std::string, bool> myAlreadyDuplicateWarned;
      std::map<std::string, bool> myNeedToLoad;
      std::set<std::string>      myNeedToSave;

      DtSessionStatus             mySessionStatus;
      std::map<std::string, bool> myJustLoadedMap;
      std::map<std::string, bool> myLoadingMap;
      std::map<std::string, bool> myReinitializingMap;
      std::map<std::string, bool> myClosingMap;
      std::map<std::string, bool> myJustClosedMap;
      std::map<std::string, bool> myJustRolledBackMap;
      std::map<std::string, bool> myRollingBackMap;
      std::map<std::string, bool> myImportingMap;
      std::map<std::string, bool> myCreatingSimulationObjectGroupMap;
      std::set<std::string> myBackendWasClosing;

      double mySimTime;
      double myLastSimTime;
      double myDateAndTimeOfDay;
      makVrv::DtSignalConnectionManager myConnectionManager;
      bool myCloseProcessStarted;
      bool myInSaveCallback;

      mutable DtLocalWeatherManager* myLocalWeatherManager;
   };
}