Initial upload of HyprArch releng configuration

airootfs/usr/include/libcalamares/modulesystem/Config.h

@@ -0,0 +1,147 @@
+/* === This file is part of Calamares - <https://calamares.io> ===
+ *
+ *   SPDX-FileCopyrightText: 2021 Adriaan de Groot <groot@kde.org>
+ *   SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ *   Calamares is Free Software: see the License-Identifier above.
+ *
+ */
+
+#ifndef CALAMARES_MODULESYSTEM_CONFIG_H
+#define CALAMARES_MODULESYSTEM_CONFIG_H
+
+#include "DllMacro.h"
+
+#include <QObject>
+#include <QStringList>
+#include <QVariantMap>
+
+#include <memory>
+
+namespace Calamares
+{
+namespace ModuleSystem
+{
+/** @brief Base class for Config-objects
+ *
+ * This centralizes the things every Config-object should
+ * do and provides one source of preset-data. A Config-object
+ * for a module can **optionally** inherit from this class
+ * to get presets-support.
+ *
+ * TODO:3.3 This is not optional
+ * TODO:3.3 Put consistent i18n for Configurations in here too
+ */
+class DLLEXPORT Config : public QObject
+{
+    Q_OBJECT
+public:
+    Config( QObject* parent = nullptr );
+    ~Config() override;
+
+    /** @brief Set the configuration from the config file
+     *
+     * Subclasses must implement this to load configuration data;
+     * that subclass **should** also call loadPresets() with the
+     * same map, to pick up the "presets" key consistently.
+     */
+    virtual void setConfigurationMap( const QVariantMap& ) = 0;
+
+public Q_SLOTS:
+    /** @brief Checks if a @p fieldName is editable according to presets
+     *
+     * If the field is named as a preset, **and** the field is set
+     * to not-editable, returns @c false. Otherwise, return @c true.
+     * Calling this with an unknown field (one for which no presets
+     * are accepted) will print a warning and return @c true.
+     *
+     * @see CONFIG_PREVENT_EDITING
+     *
+     * Most setters will call isEditable() to check if the field should
+     * be editable. Do not count on the setter not being called: the
+     * UI might not have set the field to fixed / constant / not-editable
+     * and then you can have the setter called by changes in the UI.
+     *
+     * To prevent the UI from changing **and** to make sure that the UI
+     * reflects the unchanged value (rather than the changed value it
+     * sent to the Config object), use CONFIG_PREVENT_EDITING, like so:
+     *
+     *  CONFIG_PREVENT_EDITING( type, "propertyName" );
+     *
+     * The ; is necessary. <type> is the type of the property; for instance
+     * QString. The name of the property is a (constant) string. The
+     * macro will return (out of the setter it is used in) if the field
+     * is not editable, and will send a notification event with the old
+     * value as soon as the event loop resumes.
+     */
+    bool isEditable( const QString& fieldName ) const;
+
+protected:
+    friend class ApplyPresets;
+    /** @brief "Builder" class for presets
+     *
+     * Derived classes should instantiate this (with themselves,
+     * and the whole configuration map that is passed to
+     * setConfigurationMap()) and then call .apply() to apply
+     * the presets specified in the configuration to the **named**
+     * QObject properties.
+     */
+    class ApplyPresets
+    {
+    public:
+        /** @brief Create a preset-applier for this config
+         *
+         * The @p configurationMap should be the one passed in to
+         * setConfigurationMap() . Presets are extracted from the
+         * standard key *presets* and can be applied to the configuration
+         * with apply() or operator<<.
+         */
+        ApplyPresets( Config& c, const QVariantMap& configurationMap );
+        ~ApplyPresets();
+
+        /** @brief Add a preset for the given @p fieldName
+         *
+         * This checks for preset-entries in the configuration map that was
+         * passed in to the constructor.
+         */
+        ApplyPresets& apply( const char* fieldName );
+        /** @brief Alternate way of writing apply()
+         */
+        ApplyPresets& operator<<( const char* fieldName ) { return apply( fieldName ); }
+
+    private:
+        Config& m_c;
+        bool m_bogus = true;
+        const QVariantMap m_map;
+    };
+
+private:
+    class Private;
+    std::unique_ptr< Private > d;
+    bool m_unlocked = false;
+};
+}  // namespace ModuleSystem
+}  // namespace Calamares
+
+/// @see Config::isEditable()
+//
+// This needs to be a macro, because Q_ARG() is a macro that stringifies
+// the type name.
+#define CONFIG_PREVENT_EDITING( type, fieldName ) \
+    do \
+    { \
+        if ( !isEditable( QStringLiteral( fieldName ) ) ) \
+        { \
+            auto prop = property( fieldName ); \
+            const auto& metaobject = metaObject(); \
+            auto metaprop = metaobject->property( metaobject->indexOfProperty( fieldName ) ); \
+            if ( metaprop.hasNotifySignal() ) \
+            { \
+                metaprop.notifySignal().invoke( this, Qt::QueuedConnection, Q_ARG( type, prop.value< type >() ) ); \
+            } \
+            return; \
+        } \
+    } while ( 0 )
+
+
+#endif