vrfCheckpointManager.h

Go to the documentation of this file.

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

#pragma once

#if !defined(Q_MOC_RUN)
#include <vrfGuiCommonQt/vrfGuiCommonQt.h>

#include <vrvUtil/DtVirtualBaseClass.h>

#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrfmsgs/ifSnapshotsResponse.h>
#endif

#include <QtWidgets/QWidget>
#include <QtCore/QObject>

class QLabel;
class DtSimMessage;

namespace makVrv
{
   class DtDe;
}

namespace makVrf
{
   class DtVrfBackendState;
   class DtScenarioSnapshotsWidget;
   class DtDeleteCheckpointsDialog;

   class DT_DLL_VRFGUICOMMONQT DtVrfCheckpointManager : public QObject, public makVrv::DtVirtualBaseClass
   {
      Q_OBJECT

   public:

      struct AvailableSnapshot
      {
         AvailableSnapshot() : saved(false), periodic(false), askedIfSaved(false) {};
         AvailableSnapshot(const AvailableSnapshot& orig) :
            available(orig.available), unavailable(orig.unavailable), saved(orig.saved),
            periodic(orig.periodic), askedIfSaved(orig.askedIfSaved) {};
         AvailableSnapshot& operator=(const AvailableSnapshot& rhs)
         {
            available = rhs.available;
            unavailable = rhs.unavailable;
            periodic = rhs.periodic;
            saved = rhs.saved;
            askedIfSaved = rhs.askedIfSaved;

            return *this;
         }

         std::set<std::string> available;
         std::set<std::string> unavailable;
         bool saved;
         bool periodic;
         bool askedIfSaved;
      };

      typedef std::map<double, AvailableSnapshot> AvailableSnapshots;

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

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

      static void init(makVrv::DtDe&);

      virtual void requestSnapshots(const DtSimulationAddress& addr = DtSimSendToAll);

      virtual void schedulePeriodicSnapshoting(bool enabled, double simTime, int numberOfSnapshotsToKeep);

      virtual void processSnapshotsResponse(DtSimMessage*);

      virtual bool rollbackTo(double simTime = -1);

      virtual bool haveSnapshotsThatCanBeRolledBack() const;

      virtual void clearSnapshots();

      virtual bool saveCheckpoints(const std::set<double>&);
      virtual bool saveCheckpoint(double);

      virtual bool saveCheckpoints();

      virtual bool takeSnapshot(bool force = false);

      virtual bool takeBaseSnapshot();

      virtual bool snapshotFor(double simTime, AvailableSnapshot&) const;

      virtual bool hasBaseSnapshot(double simTime = -1) const;

      virtual bool hasSnapshot(double simTime) const;

      virtual bool hasFixedSnapshot(double simTime) const;

      virtual bool hasPeriodicSnapshot(double simTime) const;

      virtual bool hasSavedScenarioForSnapshot(double simTime) const;

      virtual bool hasUnaskedUnsavedSavedScenarioForSnapshot(double simTime) const;

      virtual bool isSavingCheckpoints() const;

      virtual void setAskedToSaveAtThisSimTime(double simTime, bool);

      const std::set<double>& periodicSnapshots() const { return myPeriodicSnapshots; }
      const std::set<double>& scheduledToSave() const { return myScheduledToSave; }

      const AvailableSnapshots& availableSnapshots() const { return myAvailableSnapshots; };

      virtual DtFilename scenarioNameForCheckpoint(double) const;

      virtual double round(double simTime) const;

      virtual void setScenarioAsSaved(const DtFilename&);

      virtual void clearAllSnapshots();


      virtual double firstLoadableSimTime() const;

      virtual double baseSnapshotTime() const { return myBaseSnapshotTime; };

      virtual void updateCheckpointsSavedStatus();

      DtScenarioSnapshotsWidget* scenarioSnapshotsWidget() { return myScenarioSnapshotsWidget; };

      virtual void scenarioSnapshots();

      virtual void deleteCheckpoints();

   protected slots:
      virtual void scenarioSnapshotsWidgetDestroyed();

   public:
      boost::signals2::signal<void(const AvailableSnapshots&, const AvailableSnapshots&)> signal_snapshotsChanged;
      boost::signals2::signal<void()> signal_snapshotsCleared;
      boost::signals2::signal<void (double)> signal_savedScenarioCheckpoint;
      boost::signals2::signal<void (const std::set<double>&, const std::set<double>&)> signal_saveStateChanged;

      boost::signals2::signal<void (const std::set<double>&)> signal_savedCheckpointsCleared;

      boost::signals2::signal<void (const std::set<double>&)> signal_savingCheckpoints;
      boost::signals2::signal<void (double, double)> signal_baseScenarioSnapshotTimeChanged;

   protected:
      virtual DtDeleteCheckpointsDialog* createDeleteCheckpointsDialog(QWidget* p, const Qt::WindowFlags& f);

      virtual bool scenarioExists(double simTime, DtFilename* foundFile = 0) const;

      virtual void slot_backendRemoved(const DtVrfBackendState&);

      virtual void removeBackend(const std::string& addr, bool sendMessage);

      virtual void mergeBackendSnapshots(const std::string& addr, const DtIfSnapshotsResponse::SnapshotStatus&);

      virtual double removeSnapshot(const std::string& addr, double snapshotTime);
      virtual double addSnapshot(const std::string& addr,
         const DtIfSnapshotsResponse::Snapshot&, const std::set<std::string>& otherBes,
         std::set<std::string>& stillUnavailable);

      virtual void processScenarioSnapshotSaved(DtSimMessage*);

      virtual void checkNeedsPeriodicSave(const std::set<double>&);

      virtual void updatePeriodicCheckpointFrequency(int periodicCheckpointFrequency);
      virtual void simulationSettingsChanged();

      virtual DtScenarioSnapshotsWidget* createScenarioSnapshotsWidget(QWidget* p, const Qt::WindowFlags& f);

   protected:
      makVrv::DtDe&     myDe;

      AvailableSnapshots myAvailableSnapshots;

      makVrv::DtSignalConnectionManager myConnections;
      typedef std::map<double, int> BackendSnapshot;

      typedef std::map<std::string, BackendSnapshot> SnapshotIdsByBackend;
      SnapshotIdsByBackend mySnapshotIdsByBackend;

      std::set<double> myPeriodicSnapshots;
      std::set<double> myScheduledToSave;
      std::set<double> mySnapshotsThatCanBeRolledBackTo;

      double myBaseSnapshotTime;
      std::map<std::string, bool> myHasBaseSnapshot;
      int myPeriodicCheckpointFrequency;

      DtScenarioSnapshotsWidget* myScenarioSnapshotsWidget;
   };
}