vrfBackendState.h

Go to the documentation of this file.

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



#pragma once

#include <vrfGuiCore/vrfGuiCore.h>

#include <vrvUtil/signalslib.h>

#include <vrvCore/DtSimStateObject.h>
#include <vrvCore/DtSimState.h>
#include <vrvCore/DtSimEntry.h>
#include <vrvCore/DtStateView.h>

#include <vlpi/simulationAddress.h>

#include <map>

#include <vrfutil/backend.h>

namespace makVrv
{
   class DtMessage;
}

class DtSimMessage;

namespace makVrf 
{
   enum DtBackendChangedStates
   {
      DtBackendLoadedState =     0x00000001,
      DtBackendSimTime =         0x00000002,
      DtBackendExerciseTime =    0x00000004,
      DtBackendCanSimulate =     0x00000008,
      DtBackendControlState =    0x00000010,
      DtBackendSaving =          0x00000020,
      DtBackendAdded =           0x00000040,
      DtBackendRemoved =         0x00000080,
      DtBackendLoadedNewScenario = 0x00000100,
      DtBackendTimeMultiplier = 0x00000200,
      DtBackendRunDurationTime = 0x00000400,
      DtBackendClosedState =     0x00000800,
      DtBackendLoadingScenario =     0x00001000,
      DtBackendClosingScenario =     0x00002000,
      DtBackendDoneLoadingScenario =     0x00004000,
      DtBackendImportingScenario =     0x00008000,
      DtBackendDoneImportingScenario =     0x00010000,
      DtBackendObjectCount =     0x00020000,
      DtBackendCreatingSimulationObjectGroup =     0x00040000,
      DtBackendDoneCreatingSimulationObjectGroup =     0x00080000,
      DtBackendRollingBackScenario =     0x00100000,
      DtBackendRolledBackState =     0x00200000,
      DtBackendScenarioCapabilities =     0x00400000,
      DtHostingDynamicTerrainServer = 0x00800000,
      DtBackendChangedScenarioFilename = 0x01000000,
      DtBackendReinitializingScenario = 0x02000000,
      DtBackendDoneReinitializingScenario = 0x04000000
   };

   class DT_DLL_VRFGUICORE DtVrfBackendState : public makVrv::DtSimState
   {
   public:
      DtVrfBackendState(makVrv::DtDe& de)
      : mySaving(false)
      , myDe(de)
      , myFrameRateReportPeriod(1)
      , mySampleSize(50)
      , myMonitoringReference(0)
      , myFrameRateMean(0)
      , myFrameRateMedian(0)
      , myFrameStandardDeviation(0)
      , myMinFrameRate(0)
      , myMaxFrameRate(0)
      , mySimTimeToRealTimeRatio(0)
      {
      }

      DtVrfBackendState(makVrv::DtDe& de, const DtBackend& b)
      : myBackend(b)
      , myDe(de)
      , mySaving(false)
      , myFrameRateReportPeriod(1)
      , mySampleSize(50)
      , myMonitoringReference(0)
      , myFrameRateMean(0)
      , myFrameRateMedian(0)
      , myFrameStandardDeviation(0)
      , myMinFrameRate(0)
      , myMaxFrameRate(0)
      , mySimTimeToRealTimeRatio(0)
      {
      }

      DtVrfBackendState(const DtVrfBackendState& o)
      : myBackend(o.myBackend)
      , mySaving(o.mySaving)
      , myDe(o.myDe)
      , myFrameRateMean(o.myFrameRateMean)
      , myFrameRateMedian(o.myFrameRateMedian)
      , myFrameStandardDeviation(o.myFrameStandardDeviation)
      , myMinFrameRate(o.myMinFrameRate)
      , myMaxFrameRate(o.myMaxFrameRate)
      , mySimTimeToRealTimeRatio(o.mySimTimeToRealTimeRatio)
      {
         if (o.myMonitoringReference)
         {
            myMonitoringReference = o.myMonitoringReference;
            (*myMonitoringReference)++;
         }
      }

      virtual ~DtVrfBackendState();

      DtVrfBackendState& operator=(const DtVrfBackendState& rhs);

      DtBackend::Status status() const
      {
         return myBackend.status();
      }

      std::string displayName() const
      {
         return myBackend.address().string();
      }

      const DtBackend& backend() const
      {
         return myBackend;
      }

      DtBackend& backend()
      {
         return myBackend;
      }

      void setBackend(const DtBackend& b)
      {
         myBackend = b;
      }

      void setSaving(bool b)
      {
         mySaving = b;
      }

      bool saving() const
      {
         return mySaving;
      }

      virtual void startFrameRateMonitor();
      virtual void stopFrameRateMonitor();

      boost::signals2::signal<void (const DtVrfBackendState&)> signal_frameRatesUpdated;

   public:
      double frameRateMean() const
      {
         return myFrameRateMean;
      }

      double frameRateMedian() const
      {
         return myFrameRateMedian;
      }

      double frameRateStandardDeviation() const
      {
         return myFrameStandardDeviation;
      }

      double frameRateMin() const
      {
         return myMinFrameRate;
      }

      double frameRateMax() const
      {
         return myMaxFrameRate;
      }
      
      double frameRateSimTimeToRealTimeRatio() const
      {
         return mySimTimeToRealTimeRatio;
      }

   protected:
      virtual void processFrameRateCallback(DtSimMessage * msg);

   protected:
      makVrv::DtDe&  myDe;
      DtBackend      myBackend;
      bool           mySaving;
      double         myFrameRateReportPeriod;
      int            mySampleSize;
      int*           myMonitoringReference;

      double myFrameRateMean;
      double myFrameRateMedian;
      double myFrameStandardDeviation;
      double myMinFrameRate;
      double myMaxFrameRate;
      double mySimTimeToRealTimeRatio;
   };

   DT_DLL_VRFGUICORE makVrv::DtMessage& operator<<( makVrv::DtMessage& msg,const DtVrfBackendState& state );

   DT_DLL_VRFGUICORE makVrv::DtMessage& operator>>( makVrv::DtMessage& msg, DtVrfBackendState& state );

   typedef makVrv::DtStateView<DtVrfBackendState> DtVrfBackendStateView;

   class DT_DLL_VRFGUICORE DtVrfBackendStateObject : public makVrv::DtSimStateObject
   {
   public:
      DtVrfBackendStateObject(makVrv::DtDe& de, makVrv::DtUniqueID); 
 
       void setState(DtVrfBackendState& state)
       {
          DtVrfBackendState* backendState = dynamic_cast<DtVrfBackendState*>(myState);
          if(backendState)
          {
             *backendState = state;

             if(mySimEntry)
             {
                mySimEntry->stateUpdated();
             }
          }
       }    

      void setBackend(const DtBackend& b)
      {
         ((DtVrfBackendState*)myState)->setBackend(b);
      }

      const DtVrfBackendState& backend() const
      {
         return *((DtVrfBackendState*)myState);
      }
   };
}