CAutoPersistenceComp.h

Go to the documentation of this file.

/********************************************************************************
**  This file is part of the ICF Framework. Copyright (C) Witold Gantzke & Kirill Lepskiy
**  ICF Framework may be used under the terms of the LGPL License v. 2.1 by the Free Software Foundation.
********************************************************************************/
 
#pragma once
 
 
// Qt includes
#include <QtCore/QObject>
#include <QtCore/QTimer>
#include <QtCore/QFileSystemWatcher>
#include <QtCore/QLockFile>
#include <QtCore/QReadWriteLock>
#include <QtCore/QFuture>
 
// ICF 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>
 
 
namespace ifile
{
 
 
class CAutoPersistenceCompBase: public ilog::CLoggerComponentBase
{
public:
    typedef ilog::CLoggerComponentBase BaseClass;
 
    I_BEGIN_BASE_COMPONENT(CAutoPersistenceCompBase);
    I_ASSIGN(m_objectCompPtr, "Object", "Object will be restored and stored", true, "Object");
    I_ASSIGN_TO(m_objectModelCompPtr, 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_prototypeFilePathAttrPtr, "PrototypeFilePath", "File path of prototype file, will be used for load if the file pointed at normal file path does not exist", false, "");
    I_END_COMPONENT;
 
protected:
    I_REF(istd::IChangeable, m_objectCompPtr);
    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(QString, m_prototypeFilePathAttrPtr);
};
 
 
class CAutoPersistenceComp:
    public QObject,
    public CAutoPersistenceCompBase,
    protected imod::CMultiModelDispatcherBase
{
    Q_OBJECT
 
public:
    typedef CAutoPersistenceCompBase BaseClass;
    typedef imod::CMultiModelDispatcherBase BaseClass2;
 
    enum ModelIds
    {
        MI_OBJECT,
 
        MI_FILEPATH,
 
        MI_RUNTIME_STATUS
    };
 
    I_BEGIN_COMPONENT(CAutoPersistenceComp);
        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:
    bool SaveObjectSnapshot();
 
    virtual bool LoadObject(const QString& filePath, bool allowPrototypeFile);
    virtual bool StoreObject(const istd::IChangeable& object);
 
    // reimplemented (icomp::CComponentBase)
    void OnComponentCreated() override;
    void OnComponentDestroyed() override;
 
    // reimplemented (imod::CMultiModelDispatcherBase)
    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_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;
 
    bool m_isObjectChanged;
 
    bool m_isLoadedFromFile;
 
    QTimer m_storingTimer;
 
    QFuture<bool> m_storingFuture;
 
    mutable std::unique_ptr<istd::IChangeable> m_objectShadowPtr;
 
    QFileSystemWatcher m_fileWatcher;
 
    QReadWriteLock m_loadSaveMutex;
 
    mutable bool m_blockLoadingOnFileChanges;
 
    mutable std::unique_ptr<QLockFile> m_lockFilePtr;
    mutable QReadWriteLock m_fileLockMutex;
};
 
 
} // namespace ifile