DtRecordSettingsBackup.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/DtDe.h>
#include <vrvCore/DtDeSettingsManager.h>
#include <vrvCore/DtSettingsBackupManager.h>
#include <vrvCore/DtWriteSettingsLock.h>

namespace makVrv 
{
   class DtElementDefinitionManager;

   class DT_DLL_VRVCORE DtRecordSettingsBackupInterface : public DtSettingsBackup
   {
   public:
      DtRecordSettingsBackupInterface(DtDe& de, const std::string& classType, const std::string& descriptiveName)
         : myDe(de)
         , myClassType(classType)
         , myDescriptiveName(descriptiveName)
         , myCanBackup(true)
      {
         DtDeSettings* settings = DtDeSettingsManager::instance(myDe).findSettings(classType);
         if (settings)
         {
            setFactoryFile(settings->factoryFilePath());
         }
         DtSettingsBackupManager::instance(myDe).registerSettingsBackup(this);
      }

      DtRecordSettingsBackupInterface(const DtRecordSettingsBackupInterface& orig)
         : myDe(orig.myDe)
         , myClassType(orig.myClassType)
         , myCanBackup(orig.myCanBackup)
         , myDescriptiveName(orig.myDescriptiveName)
      {
      }

      virtual ~DtRecordSettingsBackupInterface()
      {
      }

      std::string backupClassType() const
      {
         return myClassType;
      }

      std::string backupName() const
      {
         return myDescriptiveName;
      }

      virtual void backup()
      {
         if (canBackup())
         {
            DtSettingsBackup::backup();
         }
      }

      virtual void backupByDir()
      {
         if (canBackup())
         {
            DtSettingsBackup::backupByDir();
         }
      }

      void setCanBackup(bool b)
      {
         myCanBackup = b;
      }

      bool canBackup() const
      {
         return myCanBackup;
      }

   protected:
      DtDe&          myDe;
      std::string    myClassType;
      std::string    myDescriptiveName;
      bool           myCanBackup;
   };



   template <typename SettingsClass, typename ArchiveClass>
   class DtRecordSettingsBackup : public DtRecordSettingsBackupInterface
   { 
   public:
      DtRecordSettingsBackup(DtDe& de, SettingsClass* parent, const std::string& classType, const std::string& descriptiveName)
         : DtRecordSettingsBackupInterface(de, classType, descriptiveName)
         , myParent(parent)
      {
      }

      DtRecordSettingsBackup(const DtRecordSettingsBackup& orig)
         : DtRecordSettingsBackupInterface(orig)
         , myParent(orig.myParent)
      {
      }

      virtual ~DtRecordSettingsBackup()
      {
      }

      void restore(const DtSettingsBackup* from)
      {
         bool can = canBackup();

         setCanBackup(false);

         myParent->setFromRecord(
             ((DtRecordSettingsBackup<SettingsClass, ArchiveClass>*)from)->restoredRecord());

         setCanBackup(can);
      }

      DtSettingsBackup* create() const
      {
         return new DtRecordSettingsBackup<SettingsClass, ArchiveClass>(*this);
      }

      void write(boost::archive::xml_oarchive& ar)
      {
         ArchiveClass rec;

         myParent->getRecord(rec);

         ar << boost::serialization::make_nvp(myClassType.c_str(), rec);
      }

      template<class Q = SettingsClass>
      typename std::enable_if<!std::is_same<Q, DtElementDefinitionManager>::value, void>::type writeDirSpecialised( std::vector<std::ostringstream*>& outStreamVec, std::vector<std::string>& fileNames )
      {
         // intentional no-op, only implemented for DtElementDefinitionManager
      }

      template<class Q = SettingsClass>
      typename std::enable_if<std::is_same<Q, DtElementDefinitionManager>::value, void>::type writeDirSpecialised( std::vector<std::ostringstream*>& outStreamVec, std::vector<std::string>& fileNames )
      {
         std::vector<ArchiveClass> rec;

         myParent->getSplitRecord( rec, fileNames );

         assert( rec.size() == fileNames.size() );

         unsigned int recSize = rec.size();
         outStreamVec.resize( recSize );

         for( unsigned int i = 0; i < recSize; ++i )
         {
            outStreamVec[i] = new std::ostringstream();
            boost::archive::xml_oarchive oa( *(outStreamVec[i]) );

            oa << boost::serialization::make_nvp( myClassType.c_str(), rec[i] );
         }
      }

      // Allocates the outStreamVec, delete after use - use vec<ptr> for Linux build
      void writeDir(std::vector<std::ostringstream*>& outStreamVec, std::vector<std::string>& fileNames)
      {
         writeDirSpecialised( outStreamVec, fileNames );
      }

      void readRecords(boost::archive::xml_iarchive& ar, ArchiveClass& recordsResult)
      {
         ar >> boost::serialization::make_nvp(myClassType.c_str(), recordsResult);
      }

      template<class Q = SettingsClass>
      typename std::enable_if<!std::is_same<Q, DtElementDefinitionManager>::value, void>::type readIncrementalSpecialised( boost::archive::xml_iarchive& ar )
      {
         // intentional no-op, only implemented for DtElementDefinitionManager
      }

      template<class Q = SettingsClass>
      typename std::enable_if<std::is_same<Q, DtElementDefinitionManager>::value, void>::type readIncrementalSpecialised( boost::archive::xml_iarchive& ar )
      {
         ArchiveClass rec;
         myParent->enableFilePathReadWriteOnRecord( rec );
         ar >> boost::serialization::make_nvp( myClassType.c_str(), rec );
         myParent->addRecords( rec, myRestoredRecord );
      }

      virtual void readIncremental( boost::archive::xml_iarchive& ar )
      {
         readIncrementalSpecialised( ar );
      }

      void read(boost::archive::xml_iarchive& ar)
      {
         ar >> boost::serialization::make_nvp(myClassType.c_str(), myRestoredRecord);
      }

      const ArchiveClass& restoredRecord() const
      {
         return myRestoredRecord;
      }

   protected:
      ArchiveClass   myRestoredRecord;
      SettingsClass* myParent;
   };

   template <typename SettingsClass, typename ArchiveClass>
   class DtSharedRecordSettingsBackup : public DtSettingsBackup
   { 
   public:

      DtSharedRecordSettingsBackup(DtSharedSettingsManager& manager, const std::string& classType, const std::string& descriptiveName)
         : myManager(manager)
         , myClassType(classType)
         , myCanBackup(true)
         , myDescriptiveName(descriptiveName)
      {
      }

      virtual ~DtSharedRecordSettingsBackup()
      {
      }

      void restore(const DtSettingsBackup* from)
      {
         bool can = canBackup();

         myCanBackup = false;

         DtWriteSettingsLock<SettingsClass> settings(myManager);

         settings->setFromRecord(((DtSharedRecordSettingsBackup<SettingsClass, ArchiveClass>*)from)->restoredRecord());

         myCanBackup = can;
      }

      std::string backupClassType() const
      {
         return myClassType;
      }

      std::string backupName() const
      {
         return myDescriptiveName;
      }

      DtSettingsBackup* create() const
      {
         return new DtSharedRecordSettingsBackup<SettingsClass, ArchiveClass>(myManager, myClassType, myDescriptiveName);
      }

      void write(boost::archive::xml_oarchive& ar)
      {
         ar << boost::serialization::make_nvp(backupClassType().c_str(), myRestoredRecord);
      }

      void read(std::vector<boost::archive::xml_iarchive>& ar)
      {
         if (!ar.empty())
         {
            ar[0] >> boost::serialization::make_nvp(backupClassType().c_str(), myRestoredRecord);
         }
      }

      void read(boost::archive::xml_iarchive& ar)
      {
         ar >> boost::serialization::make_nvp(backupClassType().c_str(), myRestoredRecord);
      }

      const ArchiveClass& restoredRecord() const
      {
         return myRestoredRecord;
      }

      void backup(const ArchiveClass& rec)
      {
         if (myCanBackup)
         {
            myRestoredRecord = rec;
            DtSettingsBackup::backup();
         }
      }

      void setCanBackup(bool b)
      {
         myCanBackup = b;
      }

      bool canBackup() const
      {
         return myCanBackup;
      }

   protected:
      DtSharedSettingsManager&   myManager;
      ArchiveClass               myRestoredRecord;
      bool                       myCanBackup;
      std::string                myClassType;
      std::string                myDescriptiveName;
   };
}