valuecache.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_VALUECACHE_H
#define SWIFT_MISC_VALUECACHE_H
 
#include <cstddef>
#include <memory>
#include <stdexcept>
#include <tuple>
#include <utility>
 
#include <QChar>
#include <QDBusArgument>
#include <QDateTime>
#include <QFile>
#include <QJsonObject>
#include <QMap>
#include <QMetaType>
#include <QMutex>
#include <QObject>
#include <QSet>
#include <QSharedPointer>
#include <QString>
#include <QStringList>
#include <QThread>
#include <QVariant>
#include <QtGlobal>
 
#include "misc/dictionary.h"
#include "misc/identifier.h"
#include "misc/metaclass.h"
#include "misc/mixin/mixincompare.h"
#include "misc/mixin/mixindatastream.h"
#include "misc/mixin/mixindbus.h"
#include "misc/mixin/mixinmetatype.h"
#include "misc/propertyindexref.h"
#include "misc/range.h"
#include "misc/slot.h"
#include "misc/statusmessagelist.h"
#include "misc/swiftmiscexport.h"
#include "misc/valuecacheprivate.h"
#include "misc/variantmap.h"
 
namespace swift::misc
{
    class CLogCategoryList;

    SWIFT_MISC_EXPORT void setMockCacheRootDirectory(const QString &path);

    class SWIFT_MISC_EXPORT CValueCachePacket :
        public CDictionary<QString, std::pair<CVariant, qint64>, QMap>,
        public mixin::MetaType<CValueCachePacket>,
        public mixin::DBusByMetaClass<CValueCachePacket>,
        public mixin::DataStreamByMetaClass<CValueCachePacket>,
        public mixin::EqualsByMetaClass<CValueCachePacket>
    {
    public:
        SWIFT_MISC_DECLARE_USING_MIXIN_DBUS(CValueCachePacket)
        SWIFT_MISC_DECLARE_USING_MIXIN_DATASTREAM(CValueCachePacket)
 
        
        using base_type = CDictionary;

        CValueCachePacket(bool saved = false, bool valuesChanged = true)
            : m_saved(saved), m_valuesChanged(valuesChanged)
        {}

        CValueCachePacket(const CVariantMap &values, qint64 timestamp, bool saved = false, bool valuesChanged = true);

        bool valuesChanged() const { return m_valuesChanged; }

        bool isSaved() const { return m_saved; }
        void setSaved(bool saved = true) { m_saved = saved; }

        void insert(const QString &key, const CVariant &value, qint64 timestamp);

        void insert(const CVariantMap &values, qint64 timestamp);

        void insert(const CValueCachePacket &other) { CDictionary::insert(other); }

        CVariantMap toVariantMap() const;

        QMap<QString, qint64> toTimestampMap() const;

        QString toTimestampMapString(const QStringList &keys) const;

        void setTimestamps(const QMap<QString, qint64> &);

        CValueCachePacket takeByKey(const QString &key);

        static void registerMetadata();

        struct const_iterator : public CDictionary::const_iterator
        {
            using value_type = CVariant;
            using pointer = const value_type *;
            using reference = const value_type &;
            const_iterator(CDictionary::const_iterator base) : CDictionary::const_iterator(base) {}
            reference value() const { return CDictionary::const_iterator::value().first; }
            reference operator*() const { return value(); }
            pointer operator->() const { return &value(); }
            qint64 timestamp() const { return CDictionary::const_iterator::value().second; }
        };

        const_iterator cbegin() const { return CDictionary::cbegin(); }
        const_iterator cend() const { return CDictionary::cend(); }
        const_iterator begin() const { return CDictionary::cbegin(); }
        const_iterator end() const { return CDictionary::cend(); }
 
    private:
        bool m_saved = false;
        bool m_valuesChanged = true;
 
        SWIFT_METACLASS(
            CValueCachePacket,
            SWIFT_METAMEMBER(saved),
            SWIFT_METAMEMBER(valuesChanged));
    };

    class SWIFT_MISC_EXPORT CValueCache : public QObject
    {
        Q_OBJECT
 
    public:
        class BatchGuard;

        static const QStringList &getLogCategories();

        explicit CValueCache(int fileSplitDepth, QObject *parent = nullptr);

        swift::misc::CVariantMap getAllValues(const QString &keyPrefix = {}) const;

        swift::misc::CVariantMap getAllValues(const QStringList &keys) const;

        swift::misc::CValueCachePacket getAllValuesWithTimestamps(const QString &keyPrefix = {}) const;

        QStringList getAllUnsavedKeys(const QString &keyPrefix = {}) const;

        void insertValues(const swift::misc::CValueCachePacket &values);

        QJsonObject saveToJson(const QString &keyPrefix = {}) const;

        void loadFromJson(const QJsonObject &json);

        CStatusMessageList loadFromJsonNoThrow(const QJsonObject &json, const CLogCategoryList &categories,
                                               const QString &prefix);

        CStatusMessage saveToFiles(const QString &directory, const QString &keyPrefix = {});

        CStatusMessage saveToFiles(const QString &directory, const QStringList &keys);

        CStatusMessage loadFromFiles(const QString &directory);

        QString filenameForKey(const QString &key) const;

        QStringList enumerateFiles(const QString &directory) const;

        void clearAllValues(const QString &keyPrefix = {});

        QString getHumanReadableName(const QString &key) const;

        QString getHumanReadableWithKey(const QString &key) const;

        void setHumanReadableName(const QString &key, const QString &name);

        BatchGuard batchChanges(QObject *owner);
 
    public slots:
        void changeValuesFromRemote(const swift::misc::CValueCachePacket &values,
                                    const swift::misc::CIdentifier &originator);
 
    signals:
        void valuesChangedByLocal(const swift::misc::CValueCachePacket &values);

        void valuesSaveRequested(const swift::misc::CValueCachePacket &values);
 
    protected:
        auto elementsStartingWith(const QString &keyPrefix)
        {
            return makeRange(m_elements.lowerBound(keyPrefix),
                             m_elements.lowerBound(keyPrefix + QChar(QChar::LastValidCodePoint)));
        }
        auto elementsStartingWith(const QString &keyPrefix) const
        {
            return makeRange(m_elements.lowerBound(keyPrefix),
                             m_elements.lowerBound(keyPrefix + QChar(QChar::LastValidCodePoint)));
        }


        CStatusMessage saveToFiles(const QString &directory, const CVariantMap &values,
                                   const QString &keysMessage = {}) const;

        CStatusMessage loadFromFiles(const QString &directory, const QSet<QString> &keys, const CVariantMap &current,
                                     CValueCachePacket &o_values, const QString &keysMessage = {},
                                     bool keysOnly = false) const;

        void markAllAsSaved(const QString &keyPrefix);

        void markAllAsSaved(const QStringList &keys);

        mutable QRecursiveMutex m_mutex;

        CVariant getValueSync(const QString &key) { return std::get<0>(getValue(key)); }

        qint64 getTimestampSync(const QString &key) { return std::get<1>(getValue(key)); }

        static const QString &getCacheRootDirectory();
 
    private:
        friend class private_ns::CValuePage;
        struct Element;
 
        using ElementPtr = QSharedPointer<Element>; // QMap doesn't support move-only types
 
        QMap<QString, ElementPtr> m_elements;
        QMap<QString, QString> m_humanReadable;
        const int m_fileSplitDepth = 1; 
 
        Element &getElement(const QString &key);
        Element &getElement(const QString &key, QMap<QString, ElementPtr>::const_iterator pos);
        std::tuple<CVariant, qint64, bool> getValue(const QString &key);
        void backupFile(QFile &file) const;
 
        virtual void connectPage(private_ns::CValuePage *page);
 
        // only used by CValuePage::createElement
        QSet<QString> m_warnedKeys;
        QMutex m_warnedKeysMutex;
 
    signals:
        void valuesChanged(const swift::misc::CValueCachePacket &values, QObject *changedBy);
 
    protected slots:
        void changeValues(const swift::misc::CValueCachePacket &values);
    };

    template <typename T>
    class CCached
    {
    public:
        template <typename U>
        CCached(CValueCache *cache, const QString &key, const QString &name, U *owner)
            : CCached(cache, key, name, nullptr, T {}, owner)
        {}

        template <typename U, typename F>
        CCached(CValueCache *cache, const QString &key, const QString &name, F validator, const T &defaultValue,
                U *owner)
            : m_page(&private_ns::CValuePage::getPageFor(owner, cache)),
              m_element(&m_page->createElement(key, name, qMetaTypeId<T>(), wrap(validator),
                                               CVariant::fromValue(defaultValue)))
        {
            if (isInitialized())
            {
                cache->setHumanReadableName(getKey(), name);
            }
        }

        template <typename F>
        void setNotifySlot(F slot)
        {
            if (!isInitialized())
            {
                onOwnerNameChanged([this, slot] { setNotifySlot(slot); });
                return;
            }
            using U = typename private_ns::TClassOfPointerToMember<F>::type;
            Q_ASSERT_X(m_page->parent()->metaObject()->inherits(&U::staticMetaObject), Q_FUNC_INFO,
                       "Slot is member function of wrong class");
            m_page->setNotifySlot(
                *m_element,
                { [slot](QObject *obj) { private_ns::invokeSlot(slot, static_cast<U *>(obj)); }, makeId(slot) });
        }

        const T &getThreadLocal() const
        {
            static const T empty {};
            return *(isValid() ? static_cast<const T *>(getVariant().data()) : &empty);
        }

        T get() const { return isValid() ? getVariantCopy().template value<T>() : T {}; }

        CStatusMessage set(const T &value, qint64 timestamp = 0)
        {
            return m_page->setValue(*m_element, CVariant::fromValue(value), timestamp);
        }

        CStatusMessage setAndSave(const T &value, qint64 timestamp = 0)
        {
            return m_page->setValue(*m_element, CVariant::fromValue(value), timestamp, true);
        }

        CStatusMessage save() { return m_page->setValue(*m_element, {}, 0, true); }

        CStatusMessage setProperty(CPropertyIndexRef index, const CVariant &value, qint64 timestamp = 0)
        {
            auto v = get();
            v.setPropertyByIndex(index, value);
            return set(v, timestamp);
        }

        CStatusMessage setAndSaveProperty(CPropertyIndexRef index, const CVariant &value, qint64 timestamp = 0)
        {
            auto v = get();
            v.setPropertyByIndex(index, value);
            return setAndSave(v, timestamp);
        }

        bool isOwnerThread() const { return QThread::currentThread() == m_page->thread(); }

        const QString &getKey() const { return m_page->getKey(*m_element); }

        QDateTime getTimestamp() const { return QDateTime::fromMSecsSinceEpoch(m_page->getTimestamp(*m_element)); }

        qint64 getTimestampMsSinceEpoch() const { return this->getTimestamp().toMSecsSinceEpoch(); }

        qint64 lastUpdatedAge() const { return QDateTime::currentMSecsSinceEpoch() - this->getTimestampMsSinceEpoch(); }

        bool isSaved() const { return m_page->isSaved(*m_element); }

        bool isSaving() const { return m_page->isSaving(*m_element); }

        bool isInitialized() const { return m_page->isInitialized(*m_element); }

        CCached(const CCached &) = delete;

        CCached &operator=(const CCached &) = delete;
 
    private:
        template <typename F>
        static private_ns::CValuePage::Validator wrap(F func)
        {
            return [func](const CVariant &value, QString &reason) -> bool { return func(value.value<T>(), reason); };
        }
        static private_ns::CValuePage::Validator wrap(std::nullptr_t) { return {}; }
 
        template <typename F>
        static auto makeId(F &&)
        {
            return nullptr;
        }
        template <typename U, typename M>
        static auto makeId(M U::*slot)
        {
            return static_cast<std::tuple_element_t<1, private_ns::CValuePage::NotifySlot>>(slot);
        }
 
        const QVariant &getVariant() const { return m_page->getValue(*m_element).getQVariant(); }
        QVariant getVariantCopy() const { return m_page->getValueCopy(*m_element).getQVariant(); }
        bool isValid() const { return m_page->isValid(*m_element, qMetaTypeId<T>()); }
 
    protected:
        void onOwnerNameChanged(const std::function<void()> &function)
        {
            connectOnce(m_page->parent(), &QObject::objectNameChanged, [function](const QString &) { function(); });
        }
 
        private_ns::CValuePage *m_page = (throw std::logic_error("Uninitialized member"), nullptr); 
        private_ns::CValuePage::Element *m_element =
            (throw std::logic_error("Uninitialized member"), nullptr); 
    };

    class SWIFT_MISC_EXPORT CValueCache::BatchGuard
    {
    public:
        ~BatchGuard();

        BatchGuard(const BatchGuard &) = delete;

        BatchGuard &operator=(const BatchGuard &) = delete;

        BatchGuard(BatchGuard &&other) noexcept : m_page(other.m_page) { other.m_page = nullptr; }

        BatchGuard &operator=(BatchGuard &&other) noexcept
        {
            std::swap(m_page, other.m_page);
            return *this;
        }
 
    private:
        friend class CValueCache;
        BatchGuard(private_ns::CValuePage &page) : m_page(&page) {}
        private_ns::CValuePage *m_page;
    };
 
} // namespace swift::misc
 
Q_DECLARE_METATYPE(swift::misc::CValueCachePacket)
 
#endif // SWIFT_MISC_VALUECACHE_H