variables: switch from std::any to QVariant

src/libinputactions/Value.cpp

@@ -89,7 +89,7 @@ Value<T> Value<T>::variable(QString name)
             return variable->operations()->toString();
         }
 
-        if (variable->type() != typeid(T)) {
+        if (variable->type().id() != qMetaTypeId<T>()) {
             qCWarning(INPUTACTIONS).noquote()
                 << QString("Failed to get value: variable %1 is of type %2, expected %3").arg(name, variable->type().name(), typeid(T).name());
             return {};
@@ -136,11 +136,11 @@ bool Value<T>::expensive() const
 }
 
 template<typename T>
-Value<T>::operator Value<std::any>() const
+Value<T>::operator Value<QVariant>() const
 {
-    return Value<std::any>::function([valueProvider = *this] -> std::any {
+    return Value<QVariant>::function([valueProvider = *this] -> QVariant {
         if (const auto value = valueProvider.get()) {
-            return value.value();
+            return QVariant::fromValue(value.value());
         }
         return {};
     });
@@ -152,7 +152,7 @@ template class Value<Qt::KeyboardModifiers>;
 template class Value<InputDeviceTypes>;
 template class Value<qreal>;
 template class Value<QPointF>;
-template class Value<std::any>;
 template class Value<QString>;
+template class Value<QVariant>;
 
 }

src/libinputactions/Value.h

@@ -19,7 +19,6 @@
 #pragma once
 
 #include <QString>
-#include <any>
 #include <functional>
 #include <variant>
 
@@ -60,7 +59,7 @@ class Value
      */
     bool expensive() const;
 
-    operator Value<std::any>() const;
+    operator Value<QVariant>() const;
 
 private:
     std::variant<std::optional<T>, std::function<std::optional<T>()>> m_value;

src/libinputactions/conditions/VariableCondition.cpp

@@ -27,15 +27,15 @@ Q_LOGGING_CATEGORY(INPUTACTIONS_CONDITION_VARIABLE, "inputactions.condition.vari
 namespace InputActions
 {
 
-VariableCondition::VariableCondition(const QString &variableName, const std::vector<Value<std::any>> &values, ComparisonOperator comparisonOperator)
+VariableCondition::VariableCondition(const QString &variableName, const std::vector<Value<QVariant>> &values, ComparisonOperator comparisonOperator)
     : m_variableName(variableName)
     , m_values(values)
     , m_comparisonOperator(comparisonOperator)
 {
 }
 
-VariableCondition::VariableCondition(const QString &variableName, const Value<std::any> &value, ComparisonOperator comparisonOperator)
-    : VariableCondition(variableName, std::vector<Value<std::any>>{value}, comparisonOperator)
+VariableCondition::VariableCondition(const QString &variableName, const Value<QVariant> &value, ComparisonOperator comparisonOperator)
+    : VariableCondition(variableName, std::vector<Value<QVariant>>{value}, comparisonOperator)
 {
 }
 
@@ -46,7 +46,7 @@ bool VariableCondition::doEvaluate(const ConditionEvaluationArguments &arguments
         throw std::runtime_error(std::format("Variable {} does not exist.", m_variableName.toStdString()));
     }
 
-    std::vector<std::any> values;
+    std::vector<QVariant> values;
     for (const auto &valueProvider : m_values) {
         if (const auto value = valueProvider.get()) {
             values.push_back(value.value());

src/libinputactions/conditions/VariableCondition.h

@@ -20,7 +20,6 @@
 
 #include "Condition.h"
 #include <QString>
-#include <any>
 #include <libinputactions/Value.h>
 
 namespace InputActions
@@ -31,19 +30,19 @@ enum class ComparisonOperator;
 class VariableCondition : public Condition
 {
 public:
-    VariableCondition(const QString &variableName, const std::vector<Value<std::any>> &values, ComparisonOperator comparisonOperator);
-    VariableCondition(const QString &variableName, const Value<std::any> &value, ComparisonOperator comparisonOperator);
+    VariableCondition(const QString &variableName, const std::vector<Value<QVariant>> &values, ComparisonOperator comparisonOperator);
+    VariableCondition(const QString &variableName, const Value<QVariant> &value, ComparisonOperator comparisonOperator);
 
     const QString &variableName() const { return m_variableName; }
-    const std::vector<Value<std::any>> &values() const { return m_values; }
+    const std::vector<Value<QVariant>> &values() const { return m_values; }
     ComparisonOperator comparisonOperator() const { return m_comparisonOperator; }
 
 protected:
     bool doEvaluate(const ConditionEvaluationArguments &arguments) override;
 
 private:
     QString m_variableName;
-    std::vector<Value<std::any>> m_values;
+    std::vector<Value<QVariant>> m_values;
     ComparisonOperator m_comparisonOperator;
 };
 

src/libinputactions/config/parsers/core.cpp

@@ -63,21 +63,21 @@
 namespace InputActions
 {
 
-static Value<std::any> parseAny(const Node *node, const std::type_index &type)
+static Value<QVariant> parseVariant(const Node *node, const QMetaType &type)
 {
-    if (type == typeid(bool)) {
+    if (type.id() == qMetaTypeId<bool>()) {
         return node->as<Value<bool>>();
-    } else if (type == typeid(CursorShape)) {
+    } else if (type.id() == qMetaTypeId<CursorShape>()) {
         return node->as<Value<CursorShape>>();
-    } else if (type == typeid(Qt::KeyboardModifiers)) {
+    } else if (type.id() == qMetaTypeId<Qt::KeyboardModifiers>()) {
         return Value<Qt::KeyboardModifiers>(node->as<Qt::KeyboardModifiers>(true));
-    } else if (type == typeid(InputDeviceTypes)) {
+    } else if (type.id() == qMetaTypeId<InputDeviceTypes>()) {
         return Value<InputDeviceTypes>(node->as<InputDeviceTypes>(true));
-    } else if (type == typeid(qreal)) {
+    } else if (type.id() == qMetaTypeId<qreal>()) {
         return node->as<Value<qreal>>();
-    } else if (type == typeid(QPointF)) {
+    } else if (type.id() == qMetaTypeId<QPointF>()) {
         return node->as<Value<QPointF>>();
-    } else if (type == typeid(QString)) {
+    } else if (type.id() == qMetaTypeId<QString>()) {
         return node->as<Value<QString>>();
     }
     throw InvalidValueConfigException(node, "Unexpected type.");
@@ -104,8 +104,8 @@ static std::shared_ptr<Condition> parseVariableCondition(const Node *node, const
     }
 
     ComparisonOperator comparisonOperator;
-    std::vector<Value<std::any>> right;
-    if (firstSpace == -1 && variable->type() == typeid(bool)) { // bool variable condition without operator
+    std::vector<Value<QVariant>> right;
+    if (firstSpace == -1 && variable->type().id() == qMetaTypeId<bool>()) { // bool variable condition without operator
         comparisonOperator = ComparisonOperator::EqualTo;
         right.push_back(Value<bool>(true));
     } else {
@@ -126,14 +126,14 @@ static std::shared_ptr<Condition> parseVariableCondition(const Node *node, const
 
         if (!isTypeFlags(variable->type()) && rightNode->isSequence()) {
             for (const auto *item : rightNode->sequenceItems()) {
-                right.push_back(parseAny(item, variable->type()));
+                right.push_back(parseVariant(item, variable->type()));
             }
         } else if (comparisonOperator == ComparisonOperator::Between) {
             const auto values = parseSeparatedString2<std::shared_ptr<Node>>(rightNode.get(), ';');
-            right.push_back(parseAny(values.first.get(), variable->type()));
-            right.push_back(parseAny(values.second.get(), variable->type()));
+            right.push_back(parseVariant(values.first.get(), variable->type()));
+            right.push_back(parseVariant(values.second.get(), variable->type()));
         } else {
-            right.push_back(parseAny(rightNode.get(), variable->type()));
+            right.push_back(parseVariant(rightNode.get(), variable->type()));
         }
     }
 

src/libinputactions/config/parsers/flags.cpp

@@ -22,13 +22,13 @@
 namespace InputActions
 {
 
-bool isTypeFlags(const std::type_index &type)
+bool isTypeFlags(const QMetaType &type)
 {
-    static const std::set<std::type_index> flags{
-        typeid(InputDeviceTypes),
-        typeid(Qt::KeyboardModifiers),
+    static const std::set<int> flags{
+        qMetaTypeId<InputDeviceTypes>(),
+        qMetaTypeId<Qt::KeyboardModifiers>(),
     };
-    return flags.contains(type);
+    return flags.contains(type.id());
 }
 
 }

src/libinputactions/config/parsers/flags.h

@@ -37,6 +37,6 @@ struct NodeParser<QFlags<T>>
     }
 };
 
-bool isTypeFlags(const std::type_index &type);
+bool isTypeFlags(const QMetaType &type);
 
 }

src/libinputactions/config/parsers/triggers.cpp

@@ -128,7 +128,7 @@ void finalizeTrigger(const Node *node, Trigger *trigger)
                                                                        ComparisonOperator::EqualTo));
         } else {
             conditionGroup->append(std::make_shared<VariableCondition>(BuiltinVariables::Fingers,
-                                                                       std::vector<Value<std::any>>{
+                                                                       std::vector<Value<QVariant>>{
                                                                            Value<qreal>(range.min().value()), Value<qreal>(range.max().value())},
                                                                        ComparisonOperator::Between));
         }

src/libinputactions/variables/LocalVariable.cpp

@@ -21,17 +21,17 @@
 namespace InputActions
 {
 
-LocalVariable::LocalVariable(std::type_index type)
+LocalVariable::LocalVariable(QMetaType type)
     : Variable(std::move(type))
 {
 }
 
-std::any LocalVariable::get() const
+QVariant LocalVariable::get() const
 {
     return m_value;
 }
 
-void LocalVariable::set(std::any value)
+void LocalVariable::set(QVariant value)
 {
     m_value = std::move(value);
 }

src/libinputactions/variables/LocalVariable.h

@@ -29,13 +29,13 @@ namespace InputActions
 class LocalVariable : public Variable
 {
 public:
-    LocalVariable(std::type_index type);
+    LocalVariable(QMetaType type);
 
-    std::any get() const override;
-    void set(std::any value) override;
+    QVariant get() const override;
+    void set(QVariant value) override;
 
 private:
-    std::any m_value;
+    QVariant m_value;
 };
 
 }

src/libinputactions/variables/RemoteVariable.cpp

@@ -21,15 +21,15 @@
 namespace InputActions
 {
 
-RemoteVariable::RemoteVariable(std::type_index type, std::function<void(std::any &value)> getter)
+RemoteVariable::RemoteVariable(QMetaType type, std::function<void(QVariant &value)> getter)
     : Variable(std::move(type))
     , m_getter(std::move(getter))
 {
 }
 
-std::any RemoteVariable::get() const
+QVariant RemoteVariable::get() const
 {
-    std::any value;
+    QVariant value;
     m_getter(value);
     return value;
 }

src/libinputactions/variables/RemoteVariable.h

@@ -32,12 +32,12 @@ class RemoteVariable : public Variable
     /**
      * @param getter Must always return the same type as the variable or empty.
      */
-    RemoteVariable(std::type_index type, std::function<void(std::any &value)> getter);
+    RemoteVariable(QMetaType type, std::function<void(QVariant &value)> getter);
 
-    std::any get() const override;
+    QVariant get() const override;
 
 private:
-    std::function<void(std::any &value)> m_getter;
+    std::function<void(QVariant &value)> m_getter;
 };
 
 }

src/libinputactions/variables/Variable.cpp

@@ -21,20 +21,20 @@
 namespace InputActions
 {
 
-Variable::Variable(std::type_index type)
+Variable::Variable(QMetaType type)
     : m_type(std::move(type))
     , m_operations(VariableOperationsBase::create(this))
 {
 }
 
-const std::type_index &Variable::type() const
+const VariableOperationsBase *Variable::operations() const
 {
-    return m_type;
+    return m_operations.get();
 }
 
-const VariableOperationsBase *Variable::operations() const
+const QMetaType &Variable::type() const
 {
-    return m_operations.get();
+    return m_type;
 }
 
 }

src/libinputactions/variables/Variable.h

@@ -20,7 +20,6 @@
 
 #include "VariableOperations.h"
 #include <QString>
-#include <any>
 #include <typeindex>
 
 namespace InputActions
@@ -29,24 +28,24 @@ namespace InputActions
 class Variable
 {
 public:
-    Variable(std::type_index type);
+    Variable(QMetaType type);
     virtual ~Variable() = default;
 
     /**
      * @return May be empty.
      */
-    virtual std::any get() const { return {}; }
+    virtual QVariant get() const { return {}; }
     /**
      * @param value Must be the same as the variable's type or empty.
      */
-    virtual void set(std::any value) {}
+    virtual void set(QVariant value) {}
 
     /**
      * @return Operations for this variable's type.
      */
     const VariableOperationsBase *operations() const;
 
-    const std::type_index &type() const;
+    const QMetaType &type() const;
 
     /**
      * Whether the value should not be shown in the DBus interface.
@@ -55,7 +54,7 @@ class Variable
     void setHidden(bool value) { m_hidden = value; }
 
 private:
-    std::type_index m_type;
+    QMetaType m_type;
     std::variant<bool, QString> m_value;
     std::unique_ptr<VariableOperationsBase> m_operations;
     bool m_hidden{};

src/libinputactions/variables/VariableManager.cpp

@@ -54,7 +54,7 @@ Variable *VariableManager::registerVariable(const QString &name, std::unique_ptr
     variable->setHidden(hidden);
     m_variables[name] = std::move(variable);
 
-    if (m_variables[name]->type() == typeid(QPointF)) {
+    if (m_variables[name]->type().id() == qMetaTypeId<QPointF>()) {
         registerRemoteVariable<qreal>(
             name + "_x",
             [this, name](auto &value) {
@@ -93,12 +93,12 @@ std::map<QString, QString> VariableManager::extraProcessEnvironment(const QStrin
 
         if (const auto *variable = getVariable(variableName)) {
             const auto value = variable->get();
-            if (!value.has_value()) {
+            if (value.isNull()) {
                 continue;
             }
 
-            if (variable->type() == typeid(bool)) {
-                if (std::any_cast<bool>(value)) {
+            if (variable->type().id() == qMetaTypeId<bool>()) {
+                if (value.toBool()) {
                     result[variableName] = "1";
                 }
                 continue;