backend.h

Go to the documentation of this file.

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


#pragma once

#include "vrfutil/vrfutilDefines.h"
#include "vrfutil/rwKeyValueList.h"

#include "makSettingsManager/settingsManager.h"

#include <vl/hostStructs.h>
#include <vlutil/vlUtil.h>
#include <vlutil/vlInetAddr.h>

class DtSimTimeReport;

#define DtKindFromKey(key) ((key & 0XFF00) >> 8)
#define DtDomainFromKey(key) (key & 0x00FF)
#define DtKeyFromKindDomain(kind, domain) ((kind << 8) | (0x00FF & domain))

enum DtSimulationStatus
{
   DtSimulationStatusUnknown = 0,
   DtSimulationStatusNotLoaded = 1,
   DtSimulationStatusNotReady,
   DtSimulationStatusReady,
   DtSimulationStatusPlaying,
   DtSimulationStatusPaused,
   DtSimulationStatusLoading,
   DtSimulationStatusLoaded,
   DtSimulationStatusClosing,
   DtSimulationStatusClosed,
   DtSimulationStatusSaving,
   DtSimulationStatusSaved,
   DtSimulationStatusRollingBackScenario,
   DtSimulationStatusRolledBackScenario,
   DtSimulationStatusImportingScenario,
   DtSimulationStatusImportedScenario
};

class DT_DLL_vrfutil DtBackend
{
public:
   struct SectionTime
   {
      DtFloat64 frameRateMean;
      DtFloat64 frameRateMedian;
      DtFloat64 frameRateStandardDeviation;
      DtFloat64 minFrameRate;
      DtFloat64 maxFrameRate;
   };

   typedef std::map<int, SectionTime> SectionTimes;

public:
   enum Status
   {
      Unknown = 0,
      NotLoaded = 1,             
      NotReady,                  
      Loaded,                    
      Ready,                     
      Playing,                   
      Paused,                    
      Loading,                   
      Closing,                   
      Saving,                    
      RollingBackScenario,       
      ImportingScenario          
   };

public:
   typedef std::map<short, int> ObjectCounts;

   DtBackend(const DtSimulationAddress& addr, const DtInetAddr& ipAddr, int port, 
      int state, bool isLoaded, DtTime exerciseStartTime,
      DtTime simTime, double timeMultiplier, const DtClock* clock);
   DtBackend(const DtSimulationAddress& addr);
   DtBackend();
   DtBackend(const DtBackend&);

   virtual ~DtBackend();

   DtBackend& operator=(const DtBackend&);

   virtual const DtSimulationAddress& address() const;

   virtual void printStatus();

   virtual Status status() const;

   virtual bool isInSimulatableState() const;

   virtual bool isSimulatableStatus(DtBackend::Status) const;

   virtual bool isInTransitionStatus() const;

   virtual bool isTransitionStatus(DtBackend::Status) const;

   virtual DtInetAddr inetAddress() const;
   virtual void setInetAddress(DtInetAddr address);

   virtual unsigned int port() const;
   virtual void setPort(unsigned int port);

   virtual int controlState() const;
   virtual void setControlState(int controlState);

   virtual void setScenarioRunId(int);
   virtual int scenarioRunId() const;

   virtual DtU32 scenarioCapabilities() const;
   virtual void setScenarioCapabilities(const DtU32&);

   virtual void setAppIdRangeMax(int);
   virtual int appIdRangeMax() const;

   virtual bool isLoaded() const;
   virtual bool isLoadedAndCanSimulate() const;
   virtual void setIsLoaded(bool b);

   virtual bool canSimulate() const;
   virtual void setCanSimulate(bool);

   virtual bool loadingScenario() const;
   virtual void setLoadingScenario(bool);

   virtual bool savingScenario() const;
   virtual void setSavingScenario(bool);

   virtual bool importingScenario() const;
   virtual void setImportingScenario(bool);

   virtual bool reinitializingScenario() const;
   virtual void setReinitializingScenario(bool);

   virtual bool hostingDynamicTerrainServer() const;
   virtual void setHostingDynamicTerrainServer(bool);

   virtual bool creatingSimulationObjectGroup() const;
   virtual void setCreatingSimulationObjectGroup(bool);

   virtual bool closingScenario() const;
   virtual void setClosingScenario(bool);

   virtual bool rollingBackScenario() const;
   virtual void setRollingBackScenario(bool);

   virtual bool loadedNewScenario() const;
   virtual void setLoadedNewScenario(bool);

   virtual const DtTime& lastResponseTime() const;
   virtual void setLastResponseTime(const DtTime& time);

   virtual void setGuiRuntimeLoadBalancingScheme(const DtString& scheme, const DtString& userData);
   virtual void getGuiRuntimeLoadBalancingScheme(DtString& scheme, DtString& userData) const;

   virtual void setSimRemoteAttachmentBalancingScheme(const DtString& scheme, const DtString& userData);
   virtual void getSimRemoteAttachmentBalancingScheme(DtString& scheme, DtString& userData) const;

   virtual int numSections() const;
   
   virtual int section(int) const;

   const DtBackend::SectionTimes& sectionTimes() const
   {
      return mySectionTimes;
   }

   void setSectionTimes(const DtBackend::SectionTimes& s)
   {
      mySectionTimes = s;
   }

   virtual double frameRateMean(int section) const;
   virtual void setFrameRateMean(int section, double frameRateMean);

   virtual double frameRateMedian(int section) const;
   virtual void setFrameRateMedian(int section, double frameRateMedian);

   virtual double frameRateStandardDeviation(int section) const;
   virtual void setFrameRateStandardDeviation(int section, double 
      frameRateStandardDeviation);

   virtual double minFrameRate(int section) const;
   virtual void setMinFrameRate(int section, double minFrameRate);

   virtual double maxFrameRate(int section) const;
   virtual void setMaxFrameRate(int section, double maxFrameRate);
      
   virtual double simTimeToRealTimeRatio() const;
   virtual void setSimTimeToRealTimeRatio(double ratio);

   virtual void setExericseStartTime(DtTime time);
   virtual DtTime exerciseStartTime();
   
   virtual void setSimTime(DtTime time);
   virtual DtTime simTime();
   
   virtual void setRunDurationTime(DtTime);
   virtual DtTime runDurationTime() const;

   virtual void setSimStartSimTime(DtTime time);
   virtual DtTime simStartSimTime() const;

   virtual void setTimeMultiplier(double multiplier);
   virtual double timeMultiplier() const;

   //virtual void setIsOldParameterDb(bool flag);
   //virtual bool isOldParameterDb() const;

   virtual void setIsCurrentParameterDb(bool flag);
   virtual bool isCurrentParameterDb() const;

   virtual void setResourceMonitorEnabled(bool flag);
   virtual bool resourceMonitorEnabled() const;

   virtual void setIsTimeManaged(bool);
   virtual bool isTimeManaged() const;


   virtual void setScenarioName(const DtString& name);
   virtual const DtString& scenarioName() const;


   virtual void setScenarioFilename(const DtFilename& name);
   virtual const DtFilename& scenarioFilename() const;


   virtual void setSimulationModelSets(const std::vector<DtFilename>&);
   virtual const std::vector<DtFilename>& simulationModelSets() const;


   virtual void setTerrainName(const DtFilename& name);
   virtual const DtFilename& terrainName() const;
   

   virtual void setFrameRateMode(char mode);
   virtual char frameRateMode() const;

   virtual double dT() const;


   virtual void setGuiTerrainName(const DtFilename& name);
   virtual const DtFilename& guiTerrainName() const;

   virtual void setNumberOfTickThreads(short);
   virtual short numberOfTickThreads() const;

   virtual void setNumberOfCPUs(short);
   virtual short numberOfCPUs() const;

   virtual void setTickingPublishersDuringObjectTick(bool);
   virtual bool tickingPublishersDuringObjectTick() const;


   virtual void setSimEngineId(DtU32 id);
   virtual DtU32 simEngineId() const;

   virtual const DtSettingsObject* lookupSetting(std::string name) const;
   
   virtual void setSetting(const DtSettingsObject* object);
   
   virtual void copySettingsMap(const DtSettingsMap&);

   virtual void setObjectCounts(const std::map<DtU16, int>&);
   virtual void setObjectCounts(const ObjectCounts&);
   virtual int totalLocalObjects() const;
   const ObjectCounts& objectCounts() const
   {
      return myObjectCounts;
   }


   virtual DtRwKeyValueList& scenarioData();
   virtual const DtRwKeyValueList& scenarioData() const;

protected:
   
   DtSimulationAddress  myAddress;
   DtInetAddr           myInetAddr;
   DtU32                myPort;
   DtU16                myControlState;
   DtTime               myLastResponseTime;
   bool                 myIsLoaded;
   bool                 myCanSimulate;

   SectionTimes mySectionTimes;
   double mySimTimeToRealTimeRatio;

   DtTime myExerciseStartTime;
   DtTime mySimTime;
   DtTime mySimStartSimTime;
   double myTimeMultiplier;

   const DtClock* myClock;
   DtTime myLastSimTimeUpdated;

   DtTime myDt;

   //bool myIsOldParameterDb;
   bool myIsCurrentParameterDb;

   bool myResourceMonitorEnabled;

   bool myIsTimeManaged;

   DtString myScenarioName;
   DtFilename myScenarioFilename;

   DtFilename myTerrainName;
   DtFilename myGuiTerrainName;

   DtU32 mySimEngineId;

   DtSettingsMap mySettingsMap;  

   int myScenarioRunId;
   int myAppIdRangeMax;
   char myFrameRateMode;

   bool myLoadedNewScenario;
   bool myLoadingScenario;
   bool myImportingScenario;
   bool myReinitializingScenario;
   bool myClosingScenario;
   bool myHostingDynamicTerrainServer;
   bool myRollingBackScenario;
   bool myCreatingSimulationObjectGroup;
   bool mySavingScenario;

   ObjectCounts myObjectCounts;

   std::vector<DtFilename> mySimulationModelSets;

   DtTime myRunDurationTime;

   DtRwKeyValueList myScenarioData;

   DtU32 myScenarioCapabilities;

   short myNumberOfTickThreads;
   short myNumberOfCPUs;
   bool myTickingPublishersDuringObjectTick;
   DtString myGuiRuntimeLoadBalancingScheme;
   DtString myGuiRuntimeLoadBalancingSchemeData;
   DtString mySimRemoteAttachmentBalancingScheme;
   DtString mySimRemoteAttachmentBalancingSchemeData;
};