DtRecordSettingsBackup.h

Go to the documentation of this file.

/****************************************************************************** 
** Copyright (c) 2010 MAK Technologies, Inc. 
** All rights reserved. 
******************************************************************************/ 
/****************************************************************************** 
** $RCSfile: DtRecordSettingsBackup.h,v $ $Revision: 1.16 $ $State: Exp $ 
******************************************************************************/ 
 
 
#pragma once

#ifndef DtRecordSettingsBackup_H
#define DtRecordSettingsBackup_H

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

namespace makVrv 
{
   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();
         }
      }

      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);
      }

      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(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;
   };
} 

#endif