CAutoPersistenceComp.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-2.1-or-later OR GPL-2.0-or-later OR GPL-3.0-or-later OR LicenseRef-ACF-Commercial
#pragma once
 
 
// Qt includes
#include <QtCore/QObject>
#include <QtCore/QTimer>
#include <QtCore/QFuture>
#include <QtCore/QFileSystemWatcher>
 
// ACF includes
#include <istd/IChangeable.h>
#include <imod/IModel.h>
#include <imod/CMultiModelDispatcherBase.h>
#include <ilog/TLoggerCompWrap.h>
#include <iser/CMemoryWriteArchive.h>
#include <ifile/IFilePersistence.h>
#include <ifile/IFileNameParam.h>
#include <ibase/IRuntimeStatusProvider.h>
 
#if QT_VERSION >= 0x050000
#include <QtCore/QLockFile>
#endif
 
namespace ifile
{
 
 
class CAutoPersistenceComp:
                     public QObject,
                     public ilog::CLoggerComponentBase,
                     protected imod::CMultiModelDispatcherBase
{
       Q_OBJECT
 
public:
       typedef ilog::CLoggerComponentBase BaseClass;
       typedef imod::CMultiModelDispatcherBase BaseClass2;
 
       enum ModelIds
       {
              MI_OBJECT,
 
              MI_FILEPATH,
 
              MI_RUNTIME_STATUS
       };
 
       I_BEGIN_COMPONENT(CAutoPersistenceComp);
              I_ASSIGN(m_objectCompPtr, "Object", "Object will be restored and stored", true, "Object");
              I_ASSIGN_TO(m_objectModelCompPtr, m_objectCompPtr, false);
              I_ASSIGN_TO(m_serializeableObjectCompPtr, m_objectCompPtr, false);
              I_ASSIGN(m_fileLoaderCompPtr, "FileLoader", "File loader used to store and restore object", true, "FileLoader");
              I_ASSIGN(m_filePathCompPtr, "FilePath", "File path where object data will be stored if non anonymous loader is used", false, "FilePath");
              I_ASSIGN_TO(m_filePathModelCompPtr, m_filePathCompPtr, false);
              I_ASSIGN(m_restoreOnBeginAttrPtr, "RestoreOnBegin", "Flag indicating that object should be restored on begin", true, true);
              I_ASSIGN(m_storeOnBeginAttrPtr, "StoreOnBegin", "Flag indicating that object should be stored on begin if the storage file doesn't exist", true, false);
              I_ASSIGN(m_storeOnEndAttrPtr, "StoreOnEnd", "Flag indicating that object should be stored on end", true, true);
              I_ASSIGN(m_storeOnChangeAttrPtr, "StoreOnChange", "Flag indicating that object should be stored on each data change", true, false);
              I_ASSIGN(m_storeIntervalAttrPtr, "StoreInterval", "Time interval in seconds for automatic object storing", false, 10);
              I_ASSIGN(m_reloadOnFileChangeAttrPtr, "AutoReload", "Update data model if the file was changed", true, false);
              I_ASSIGN(m_runtimeStatusCompPtr, "RuntimeStatus", "Application's runtime status", false, "RuntimeStatus");
              I_ASSIGN_TO(m_runtimeStatusModelCompPtr, m_runtimeStatusCompPtr, false);
              I_ASSIGN(m_staleLockTimeAttrPtr, "StaleLockTime", "Time in seconds after which a lock file is considered stale.", true, 30.0);
              I_ASSIGN(m_tryLockTimeoutAttrPtr, "TryLockTimeout", "Lock function will wait for at most TryLockTimeout seconds for the lock file to become available."
                                   "\nNOTE: Lock will wait forever until the lock file can be locked when set to negative", true, 0.0);
              I_ASSIGN(m_enableLockForLoadAttrPtr, "EnableLockForRead", "When enabled lock is also set when reading from file."
                                   "\nNOTE: On NTFS file systems, ownership and permissions checking is disabled (in QT) by default for performance reasons."
                                   "\nEnable this flag when you are known what you are doing.", true, false);
       I_END_COMPONENT;
 
       CAutoPersistenceComp();
 
protected:
       void SaveObjectSnapshot();
 
       virtual bool LoadObject(const QString& filePath);
       virtual bool StoreObject(const istd::IChangeable& object);
 
       // reimplemented (icomp::CComponentBase)
       virtual void OnComponentCreated() override;
       virtual void OnComponentDestroyed() override;
 
       // reimplemented (imod::CMultiModelDispatcherBase)
       virtual void OnModelChanged(int modelId, const istd::IChangeable::ChangeSet& changeSet) override;
 
private Q_SLOTS:
       void OnTimeout();
 
       void OnFileContentsChanged(const QString& path);
 
private:
       bool TryStartIntervalStore();
 
       bool LockFile(const QString& filePath, bool store) const;
       void UnlockFile() const;
 
private:
       I_REF(ibase::IRuntimeStatusProvider, m_runtimeStatusCompPtr);
       I_REF(imod::IModel, m_runtimeStatusModelCompPtr);
 
       I_REF(istd::IChangeable, m_objectCompPtr);
       I_REF(iser::ISerializable, m_serializeableObjectCompPtr);
       I_REF(imod::IModel, m_objectModelCompPtr);
 
       I_REF(ifile::IFilePersistence, m_fileLoaderCompPtr);
 
       I_REF(ifile::IFileNameParam, m_filePathCompPtr);
       I_REF(imod::IModel, m_filePathModelCompPtr);
 
       I_ATTR(bool, m_restoreOnBeginAttrPtr);
 
       I_ATTR(bool, m_storeOnBeginAttrPtr);
 
       I_ATTR(bool, m_storeOnEndAttrPtr);
 
       I_ATTR(bool, m_storeOnChangeAttrPtr);
 
       I_ATTR(double, m_storeIntervalAttrPtr);
 
       I_ATTR(bool, m_reloadOnFileChangeAttrPtr);
 
       I_ATTR(double, m_staleLockTimeAttrPtr);
 
       I_ATTR(double, m_tryLockTimeoutAttrPtr);
 
       I_ATTR(bool, m_enableLockForLoadAttrPtr);
 
       iser::CMemoryWriteArchive m_lastStoredObjectState;
 
       std::atomic<bool> m_isObjectChanged;
 
       bool m_isLoadedFromFile;
 
       QTimer m_storingTimer;
 
       QFuture<void> m_storingFuture;
 
       mutable istd::IChangeableUniquePtr m_objectShadowPtr;
 
       QFileSystemWatcher m_fileWatcher;
 
       QMutex m_loadSaveMutex;
       
       mutable bool m_blockLoadingOnFileChanges;
 
#if QT_VERSION >= 0x050000
       mutable istd::TDelPtr<QLockFile> m_lockFilePtr;
#endif
       mutable QMutex m_fileLockMutex;
};
 
 
} // namespace ifile