vrfSimulationSettingsRecord.h

Go to the documentation of this file.

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



#pragma once

#include <vrfGuiCore/vrfGuiCore.h>
#include <vrvUtil/DtUnicode.h>

#include <boost/serialization/access.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/list.hpp>
#include <boost/serialization/map.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/string.hpp>

namespace makVrf
{
   class DT_DLL_VRFGUICORE DtVrfSimulationSettingsRecord
   {
   public:
      enum VrfSimulationSettingsOptions
      {
         DtAllowOrbatDeletionChoice             = 0x00000001,
         DtAggregateOnCreate             = 0x00000400,
         DtCheckForUnusedTriggersOnPlanSave = 0x00100000,
         DtSaveScenarioAsStartingSnapshot       = 0x00200000,
         DtEnablePeriodicCheckpointing       = 0x00400000,
         AutomaticallyStartMissingBackends = 0x00800000,
      };


      struct SimulationModelSetConfiguration
      {
         std::string title;
         std::vector<std::string> simulationModelSets;
         std::string additionalInformation;
         friend class boost::serialization::access;

         template<class Archive>
            void serialize(Archive & ar, const unsigned int version)
         {
            ar & BOOST_SERIALIZATION_NVP(title);
            ar & BOOST_SERIALIZATION_NVP(simulationModelSets);
            ar & BOOST_SERIALIZATION_NVP(additionalInformation);
         }
      };

   public:
      DtVrfSimulationSettingsRecord();
      DtVrfSimulationSettingsRecord(const DtVrfSimulationSettingsRecord& orig);

      virtual ~DtVrfSimulationSettingsRecord();

   public:

      virtual void setFlag(int flag, bool set);

      virtual void setCheckForUnusedTriggersOnPlanSave(bool);
      virtual bool checkForUnusedTriggersOnPlanSave() const;

      void setSaveScenarioAsStartingSnapshot(bool);
      bool saveScenarioAsStartingSnapshot() const;

      void setEnablePeriodicCheckpointing(bool);
      bool enablePeriodicCheckpointing() const;

      virtual void setAllowOrbatDeletionChoice(bool);
      virtual bool allowOrbatDeletionChoice() const;

      void setPeriodicCheckpointingFrequency(int);
      int periodicCheckpointingFrequency() const;

      void setPeriodicCheckpointingDirectory(const std::string&);
      const std::string& periodicCheckpointingDirectory() const;

      void setStartupTerrain(const std::string&);
      const std::string& startupTerrain() const;

      void setStartupScenario(const std::string&);
      const std::string& startupScenario() const;

      void setStartupSimulationModelSet(const std::string&);
      const std::string& startupSimulationModelSet() const;

      void setAggregateOnCreate(bool);
      bool aggregateOnCreate() const;

      void setDefaultScenarioFile(const std::string&);
      const std::string& defaultScenarioFile() const;

      void setSimulationObjectGroupTerrain(const std::string&);
      const std::string& simulationObjectGroupTerrain() const;

      void setDefaultEnvironmentCondition(const std::string&);
      const std::string& defaultEnvironmentCondition() const;

      void setDefaultSimulationModelSetFile(const std::string&);
      const std::string& defaultSimulationModelSetFile() const;

      virtual const std::vector<SimulationModelSetConfiguration>& simulationModelSetConfigurations() const;
      virtual void setSimulationModelSetConfigurations(const std::vector<SimulationModelSetConfiguration>&);

      virtual void setDefaultScenarioStartTime(time_t);
      virtual time_t defaultScenarioStartTime() const;

      virtual void setAutomaticallyStartMissingBackends(bool);
      virtual bool automaticallyStartMissingBackends() const;

   protected:
      friend class boost::serialization::access;

      template<class Archive>
         void serialize(Archive & ar, const unsigned int version)
      {
         ar & BOOST_SERIALIZATION_NVP(mySimulationOptions);
         ar & BOOST_SERIALIZATION_NVP(myDefaultScenarioFile);
         ar & BOOST_SERIALIZATION_NVP(myDefaultSimulationModelSetFile);
         ar & BOOST_SERIALIZATION_NVP(mySimulationModelSetConfigurations);
         ar & BOOST_SERIALIZATION_NVP(myDefaultScenarioStartTime);
         ar & BOOST_SERIALIZATION_NVP(mySimulationObjectGroupTerrain);
         ar & BOOST_SERIALIZATION_NVP(myStartupTerrain);
         ar & BOOST_SERIALIZATION_NVP(myStartupScenario);
         ar & BOOST_SERIALIZATION_NVP(myStartupSimulationModelSet);
         ar & BOOST_SERIALIZATION_NVP(myPeriodicCheckpointingTime);
         ar & BOOST_SERIALIZATION_NVP(myPeriodicCheckpointingDirectory);
         ar & BOOST_SERIALIZATION_NVP(myDefaultEnvironmentCondition);
      }

   protected:
      VrfSimulationSettingsOptions   mySimulationOptions;
      std::string myDefaultScenarioFile;
      std::string myDefaultSimulationModelSetFile;
      std::string mySimulationObjectGroupTerrain;
      std::vector<SimulationModelSetConfiguration> mySimulationModelSetConfigurations;
      time_t myDefaultScenarioStartTime;

      std::string myStartupTerrain;
      std::string myStartupScenario;
      std::string myStartupSimulationModelSet;

      int myPeriodicCheckpointingTime;
      std::string myPeriodicCheckpointingDirectory;
      std::string myDefaultEnvironmentCondition;
   };
}

BOOST_CLASS_VERSION(makVrf::DtVrfSimulationSettingsRecord,1)