timeAndDateStateComponent.h

Go to the documentation of this file.

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

#pragma once

#include "vrfStateData/stateComponent.h"
#include "vrfStateData/doubleBufferedDataStorage.h"
#include <vlpi/netStructs.h>
#include <vlutil/vlString.h>
#include <vrfExtObjects/vrfCloudLayerStateEnums.h>
#include "legionDataStore/writeStateInstance.h"
#include "legionDataStore/readStateInstance.h"
#include "vrfOM/sets/writeSimulationDateTimeRepository.hpp"
#include "vrfOM/sets/readSimulationDateTimeRepository.hpp"
#include <vrfutil/rwUUID.h>

namespace makVrf
{
   static DtUUID DtGlobalWeatherObjectUUID("VRF_UUID:73666f77-63d6-e041-a002-f2690e990574");

   struct DT_DLL_vrfStateData DtTimeAndDateStateComponentData
   {
      DtTimeAndDateStateComponentData()
      {
         myScenarioStartTimeAtLocalOnFirstObjectCreationToTime = 36000;
         myUpdateWhenTimeChangedBy = 60.;
         myDateAndTimeOfDay = 43200.0;
         myNetworkDateAndTimeOfDay = 0.;
         myScenarioStartTimeIsLocal = true;
      }

      DtTimeAndDateStateComponentData(const DtTimeAndDateStateComponentData& orig)
      {
         myScenarioStartTimeAtLocalOnFirstObjectCreationToTime = orig.myScenarioStartTimeAtLocalOnFirstObjectCreationToTime;
         myUpdateWhenTimeChangedBy = orig.myUpdateWhenTimeChangedBy;
         myDateAndTimeOfDay = orig.myDateAndTimeOfDay;
         myNetworkDateAndTimeOfDay = orig.myNetworkDateAndTimeOfDay;
         myScenarioStartTimeIsLocal = orig.myScenarioStartTimeIsLocal;
      }

      DtTimeAndDateStateComponentData& operator=(const DtTimeAndDateStateComponentData& rhs)
      {
         myScenarioStartTimeAtLocalOnFirstObjectCreationToTime = rhs.myScenarioStartTimeAtLocalOnFirstObjectCreationToTime;
         myUpdateWhenTimeChangedBy = rhs.myUpdateWhenTimeChangedBy;
         myDateAndTimeOfDay = rhs.myDateAndTimeOfDay;
         myNetworkDateAndTimeOfDay = rhs.myNetworkDateAndTimeOfDay;
         myScenarioStartTimeIsLocal = rhs.myScenarioStartTimeIsLocal;
         return *this;
      }

      bool dateAndTimeOfDayHasBeenSet() const
      {
         return (myDateAndTimeOfDay != 43200.0);
      }

      DEFINE_ACCESSOR_MUTATOR(double, updateWhenTimeChangedBy, UpdateWhenTimeChangedBy)
      DEFINE_ACCESSOR_MUTATOR(double, dateAndTimeOfDay, DateAndTimeOfDay)
      DEFINE_ACCESSOR_MUTATOR(double, networkDateAndTimeOfDay, NetworkDateAndTimeOfDay)
      DEFINE_ACCESSOR_MUTATOR(int, scenarioStartTimeAtLocalOnFirstObjectCreationToTime, ScenarioStartTimeAtLocalOnFirstObjectCreationToTime)
      DEFINE_ACCESSOR_MUTATOR(bool, scenarioStartTimeIsLocal, ScenarioStartTimeIsLocal)

   protected:
      int myScenarioStartTimeAtLocalOnFirstObjectCreationToTime;
      double myUpdateWhenTimeChangedBy;
      double myDateAndTimeOfDay;
      double myNetworkDateAndTimeOfDay;

      bool myScenarioStartTimeIsLocal;
   };

   class DT_DLL_vrfStateData DtTimeAndDateStateComponent : public DtFrameStateInterface
   {
   public:
      DEFINE_STATE_COMPONENT_TYPE(DtStateComponent::TimeAndDateStateComponent)

      DtTimeAndDateStateComponent(DtStateData* storage)
      : DtFrameStateInterface(storage)
      {
      }

      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, updateWhenTimeChangedBy, UpdateWhenTimeChangedBy)
      UNDEFINED_RETURNVALUE_ACCESSOR(double, dateAndTimeOfDay)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, networkDateAndTimeOfDay, NetworkDateAndTimeOfDay)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, timeOfDayAdvancementSpeed, TimeOfDayAdvancementSpeed)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(bool, useDayNightIlluminationModel, UseDayNightIlluminationModel)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(int, scenarioStartTimeAtLocalOnFirstObjectCreationToTime, ScenarioStartTimeAtLocalOnFirstObjectCreationToTime)
      virtual void setDateAndTimeOfDay(const double&, bool markModified = false) { throw DtUnimplementedMethod("void setDateAndTimeOfDay(double, bool markModified = false) is not implemented for this class."); };

      UNDEFINED_RETURNVALUE_ACCESSOR(DtString, timeOfDayString)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(bool, userModifiedTime, UserModifiedTime)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(bool, timeToLocalOnFirstPlacement, TimeToLocalOnFirstPlacement)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(bool, alreadySetTimePlacement, AlreadySetTimePlacement)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(bool, canSetScenarioPreStartTime, CanSetScenarioPreStartTime)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(bool, scenarioStartTimeIsLocal, ScenarioStartTimeIsLocal)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, timeOfDay, TimeOfDay)
   };

   class DT_DLL_vrfStateData DtTimeAndDateStateComponentNextFrame : public DtTimeAndDateStateComponent
   {
   public:
      DtTimeAndDateStateComponentNextFrame(DtStateData*);

      const DtTimeAndDateStateComponentData& frameState() const { return myData; };
      DtTimeAndDateStateComponentData& frameState() { return myData; };

      virtual const double dateAndTimeOfDay() const override;
      virtual void setDateAndTimeOfDay(const double&, bool markModified = false) override;

      virtual const double networkDateAndTimeOfDay() const override;
      virtual void setNetworkDateAndTimeOfDay(const double&) override;

      virtual const double updateWhenTimeChangedBy() const override;
      virtual void setUpdateWhenTimeChangedBy(const double&) override;

      virtual const double timeOfDayAdvancementSpeed() const override;
      virtual void setTimeOfDayAdvancementSpeed(const double&) override;

      virtual const bool useDayNightIlluminationModel() const override;
      virtual void setUseDayNightIlluminationModel(const bool&) override;

      virtual const int scenarioStartTimeAtLocalOnFirstObjectCreationToTime() const override;
      virtual void setScenarioStartTimeAtLocalOnFirstObjectCreationToTime(const int&) override;

      virtual void setTimeToLocalOnFirstPlacement(const bool&) override;
      virtual const bool timeToLocalOnFirstPlacement() const override;

      virtual void setUserModifiedTime(const bool&) override;
      virtual const bool userModifiedTime() const override;

      virtual void setAlreadySetTimePlacement(const bool&) override;
      virtual const bool alreadySetTimePlacement() const override;

      virtual void setCanSetScenarioPreStartTime(const bool&) override;
      virtual const bool canSetScenarioPreStartTime() const override;

      virtual void setScenarioStartTimeIsLocal(const bool&) override;
      virtual const bool scenarioStartTimeIsLocal() const override;

      virtual const DtString timeOfDayString() const override;
      virtual void setTimeOfDay(const double& value) override;

      virtual const double timeOfDay() const override;

      virtual void makeWritable() override;

      virtual void makeReadOnly() override;

   protected:
      VRF::WriteSimulationDateTimeRepository myWriteSimulationDateTimeRepository;
      DtTimeAndDateStateComponentData myData;
   };

   class DT_DLL_vrfStateData DtTimeAndDateStateComponentCurrentFrame : public DtTimeAndDateStateComponent
   {
   public:
      DtTimeAndDateStateComponentCurrentFrame(DtStateData*);
      virtual ~DtTimeAndDateStateComponentCurrentFrame() override;

      const DtTimeAndDateStateComponentData& frameState() const { return myData; };

      bool readComponentValid() const;
      bool findReadComponent();

      virtual const double updateWhenTimeChangedBy() const override;
      virtual const double dateAndTimeOfDay() const override;
      virtual const double networkDateAndTimeOfDay() const override;
      virtual const double timeOfDayAdvancementSpeed() const override;
      virtual const bool useDayNightIlluminationModel() const override;
      virtual const int scenarioStartTimeAtLocalOnFirstObjectCreationToTime() const override;
      virtual const DtString timeOfDayString() const override;
      virtual const bool timeToLocalOnFirstPlacement() const override;
      virtual const bool userModifiedTime() const override;
      virtual const bool scenarioStartTimeIsLocal() const override;

      virtual const bool alreadySetTimePlacement() const override;

      virtual const bool canSetScenarioPreStartTime() const override;
      virtual const double timeOfDay() const override;

   protected:
      void dateAndTimeOfDayChanged();

      friend class DtTimeAndDateStateComponentImplementation;
      void advanceFrame(const DtTimeAndDateStateComponentData& data)
      {
         myData = data;
      }

   protected:
      VRF::ReadSimulationDateTimeRepository myReadSimulationDateTimeRepository;
      unsigned int myCallbackHandle;
      DtTimeAndDateStateComponentData myData;
   };

   class DT_DLL_vrfStateData DtTimeAndDateStateComponentImplementation : public DtDoubleBufferedStateComponent<DtTimeAndDateStateComponent>
   {
   public:
      DtTimeAndDateStateComponentImplementation(DtStateData*);

      bool isDoubleBuffered() { return true; };
      virtual const DtFrameStateInterface* currentFrameState() const override { return &myCurrentFrameState; }
      virtual DtFrameStateInterface* nextFrameState() override { return &myNextFrameState; };
      virtual const DtFrameStateInterface* nextFrameState() const override { return &myNextFrameState; };

      virtual void updateDataStorage() override;

      virtual void updateStateData(DtStateData* sd) override
      {
         myCurrentFrameState.updateStateData(sd);
         myNextFrameState.updateStateData(sd);
      }

      virtual bool forceAdvance() override;

      virtual void firstFrameAdvance() override;

      virtual void initializeFromParameters(const DtVrfObjectParameters*) override;

      virtual void aboutToBeDeleted() override
      {
         DtDoubleBufferedStateComponent<DtTimeAndDateStateComponent>::aboutToBeDeleted();
         myCurrentFrameState.aboutToBeDeleted();
         myNextFrameState.aboutToBeDeleted();
      }

   protected:
      DtTimeAndDateStateComponentCurrentFrame myCurrentFrameState;
      DtTimeAndDateStateComponentNextFrame myNextFrameState;
      bool myFoundComponent;
   };

   typedef DtStateComponentCreator<DtTimeAndDateStateComponentImplementation> DtTimeAndDateStateComponentCreator;
}