DtSettingsBackup.h

Go to the documentation of this file.

/****************************************************************************** 
** Copyright (c) 2020 MAK Technologies, Inc. 
** All rights reserved. 
******************************************************************************/ 
 
 
#pragma once
#include <vrvCore/DtBackupInterface.h>
#include <boost/archive/xml_iarchive.hpp>
#include <boost/archive/xml_oarchive.hpp>

namespace makVrv 
{

   class DT_DLL_VRVCORE DtSettingsBackup : public DtBackupInterface
   { 
   public:
      enum RestoreFlags
      {
         RestoreFromFactory = 0x00000001,
         RestoreFromLocal   = 0x00000002,
         KeepRestoreFromLocal = 0x80000000,
         RestoreAll         = RestoreFromFactory | RestoreFromLocal
      };

      typedef std::map<DtSettingsBackup*, int> RestoreWhenRestored;

   public:

      DtSettingsBackup();

      virtual ~DtSettingsBackup();

      virtual bool createAndWriteToBackupFile(const std::ostringstream& str, const std::string& path);
      
      virtual bool createAndWriteToBackupFiles(const std::vector<std::ostringstream*>& str, 
         const std::string& path, const std::vector<std::string>& fileNames);

      const std::string& backupFile() const;

      virtual bool backupFileExists() const;

      virtual bool backupDirExists() const;

      virtual bool factoryFileExists() const;

      virtual bool factoryDirExists() const;

      virtual void backup();

      virtual void backupByDir();

      virtual void deleteBackup();

      virtual void restore(bool fromFactory = false);

      virtual void getRestorableNames(NameList& names);

      virtual void restore(bool fromFactory, bool selectedOnly);

      virtual void restore(const DtSettingsBackup* from ) = 0;

      virtual void restoreSelected( const DtSettingsBackup* ) {}

      virtual std::string backupClassType() const = 0;

      virtual DtSettingsBackup* create() const = 0;

      virtual void write(boost::archive::xml_oarchive& ar) = 0;

      virtual void read(boost::archive::xml_iarchive& ar) = 0;

      virtual void writeDir(std::vector<std::ostringstream*>& outStreamVec, std::vector<std::string>& fileNames)
      {
         // should never be called
      };

      virtual void readIncremental(boost::archive::xml_iarchive& ar)
      {
         // should never be called
      };

      void setManagerDestroyed(bool b)
      {
         myManagerDestroyed = b;
      }

      virtual void addRestoreWhenRestored(DtSettingsBackup*, 
         const RestoreFlags& f = RestoreAll);

      const RestoreWhenRestored& restoreWhenRestored() const
      {
         return myRestoreWhenRestored;
      }

      virtual void cancelRestoreWhenRestored(DtSettingsBackup*, 
         const RestoreFlags& f = RestoreAll);

      virtual std::string backupName() const;

      void setBackupsPath(const std::string& s)
      {
         myBackupsPath = s;
      }

      const std::string& backupsPath() const
      {
         return myBackupsPath;
      }

      void setFactoryFile(const std::string& s)
      {
         myFactoryFile = s;
      }

      const std::string& factoryFile() const
      {
         return myFactoryFile;
      }

      void setFactoryDir(const std::string& dir)
      {
         myFactoryDir = dir;
      }

      const std::string& factoryDir() const
      {
         return myFactoryDir;
      }

      void setBackupDir(const std::string& dir)
      {
         myBackupDir = dir;
      }

      const std::string& backupDir() const
      {
         return myBackupDir;
      }

      boost::signalslib::signal<void (const DtSettingsBackup*)> signal_destructing;
      boost::signalslib::signal<void (const DtSettingsBackup*)> signal_backupCleared;
      boost::signalslib::signal<void (const DtSettingsBackup*)> signal_backedUp;
      boost::signalslib::signal<void (const DtSettingsBackup*)> signal_restored;

   protected:

      virtual bool restore(bool fromFactory, 
         std::vector<DtSettingsBackup*>& hasBeenRestored, bool selectedOnly);

   protected:

      bool                             myManagerDestroyed;
      RestoreWhenRestored              myRestoreWhenRestored;
      std::string                      myBackupFile;
      std::string                      myFactoryFile;
      std::string                      myBackupsPath;
      std::string                      myBackupDir;
      std::string                      myFactoryDir;

   };

}