valuecacheprivate.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_PRIVATE_H
#define SWIFT_MISC_VALUECACHE_PRIVATE_H
 
#include <QMap>
#include <QObject>
 
#include "misc/statusmessage.h"
#include "misc/variantmap.h"
 
namespace swift::misc
{
    class CIdentifier;
    class CValueCache;
    class CValueCachePacket;
 
    namespace private_ns
    {
 
        template <typename T>
        struct TClassOfPointerToMember
        {
            using type = QObject;
        };
        template <typename T, typename M>
        struct TClassOfPointerToMember<M T::*>
        {
            using type = T;
        };
 
        template <typename T, typename... Args>
        void reconstruct(T *object, Args &&...args)
        {
            object->~T();
            new (object) T(std::forward<Args>(args)...);
        }
 
        class SWIFT_MISC_EXPORT CValuePage : public QObject
        {
            Q_OBJECT
 
        public:
            static const QStringList &getLogCategories();
 
            static CValuePage &getPageFor(QObject *parent, CValueCache *cache);
 
            struct Element;
 
            using Validator = std::function<bool(const CVariant &, QString &)>;
 
            using NotifySlot = std::pair<std::function<void(QObject *)>, void (QObject::*)()>;
 
            Element &createElement(const QString &key, const QString &name, int metaType, const Validator &validator,
                                   const CVariant &defaultValue);
 
            void setNotifySlot(Element &element, const NotifySlot &slot);
 
            bool isInitialized(const Element &element) const;
 
            bool isValid(const Element &element, int typeId) const;
 
            const CVariant &getValue(const Element &element) const;
 
            CVariant getValueCopy(const Element &element) const;
 
            CStatusMessage setValue(Element &element, CVariant value, qint64 timestamp, bool save = false);
 
            const QString &getKey(const Element &element) const;
 
            qint64 getTimestamp(const Element &element) const;
 
            bool isSaved(const Element &element) const;
 
            bool isSaving(const Element &element) const;
 
            void setValuesFromCache(const swift::misc::CValueCachePacket &values, QObject *changedBy);
 
            void beginBatch();
 
            void abandonBatch();
 
            void endBatch();
 
        signals:
            void valuesWantToCache(const swift::misc::CValueCachePacket &values);
 
        private:
            using ElementPtr = QSharedPointer<Element>; // QMap doesn't support move-only types
 
            CValueCache *m_cache = nullptr;
            QMap<QString, ElementPtr> m_elements;
            int m_batchMode = 0;
            CVariantMap m_batchedValues;
 
            CValuePage(QObject *parent, CValueCache *cache);
            CStatusMessage validate(const Element &element, const CVariant &value,
                                    CStatusMessage::StatusSeverity invalidSeverity) const;
        };
 
    } // namespace private_ns
 
} // namespace swift::misc
 
#endif // SWIFT_MISC_VALUECACHE_PRIVATE_H