settingscache.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2015 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
 
#ifndef SWIFT_MISC_SETTINGSCACHE_H
#define SWIFT_MISC_SETTINGSCACHE_H
 
#include <QObject>
#include <QString>
#include <QStringList>
 
#include "misc/statusmessage.h"
#include "misc/swiftmiscexport.h"
#include "misc/valuecache.h"
 
namespace swift::misc
{
    class SWIFT_MISC_EXPORT CSettingsCache : public swift::misc::CValueCache
    {
        Q_OBJECT
 
    public:
        static CSettingsCache *instance();
 
        static const QString &persistentStore();
 
        CStatusMessage saveToStore(const QString &keyPrefix = {});
 
        CStatusMessage saveToStore(const QStringList &keys);
 
        void enableLocalSave();
 
        CStatusMessage loadFromStore();
 
        static QString filenameForKey(const QString &key);
 
        static const QString &relativeFilePath();
 
        QStringList enumerateStore() const;
 
    private:
        CSettingsCache();
        void saveToStoreByPacket(const CValueCachePacket &values);
        static const QString &lockFileName();
        CStatusMessage lockFile(QLockFile &);
    };
 
    template <typename Trait>
    class CSetting : public swift::misc::CCached<typename Trait::type>
    {
    public:
        template <typename T>
        CSetting(T *owner)
            : CSetting::CCached(CSettingsCache::instance(), Trait::key(), Trait::humanReadable(), Trait::isValid,
                                Trait::defaultValue(), owner)
        {
            if (!this->isInitialized())
            {
                this->onOwnerNameChanged([this, owner] { private_ns::reconstruct(this, owner); });
            }
        }
 
        template <typename T, typename F>
        CSetting(T *owner, F slot) : CSetting(owner)
        {
            this->setNotifySlot(slot);
        }
 
        CStatusMessage setDefault() { return this->set(Trait::defaultValue()); }
 
        auto getDefault() const { return Trait::defaultValue(); }
 
        bool isDefault() const { return this->getDefault() == this->get(); }
 
        QString getFilename() const { return CSettingsCache::filenameForKey(this->getKey()); }
    };
 
    template <typename Trait>
    class CSettingReadOnly : public swift::misc::CSetting<Trait>
    {
    public:
        using CSetting<Trait>::CSetting;
 
        CStatusMessage set(const typename Trait::type &value, qint64 timestamp = 0) = delete;
        CStatusMessage setAndSave(const typename Trait::type &value, qint64 timestamp = 0) = delete;
        CStatusMessage save() = delete;
        CStatusMessage setProperty(CPropertyIndexRef index, const CVariant &value, qint64 timestamp = 0) = delete;
        CStatusMessage setAndSaveProperty(CPropertyIndexRef index, const CVariant &value,
                                          qint64 timestamp = 0) = delete;
        CStatusMessage setDefault() = delete;
    };
 
    template <typename T>
    struct TSettingTrait
    {
        using type = T;
 
        static const char *key()
        {
            qFatal("Not implemented");
            return "";
        }
 
        static const QString &humanReadable()
        {
            static const QString name;
            return name;
        }
 
        static bool isValid(const T &value, QString &reason)
        {
            Q_UNUSED(value);
            Q_UNUSED(reason);
            return true;
        }
 
        static const T &defaultValue()
        {
            static const T def {};
            return def;
        }
 
        TSettingTrait() = delete;
 
        TSettingTrait(const TSettingTrait &) = delete;
 
        TSettingTrait &operator=(const TSettingTrait &) = delete;
    };
} // namespace swift::misc
 
#endif // SWIFT_MISC_SETTINGSCACHE_H