SignalDataTransition.h

Go to the documentation of this file.

#pragma once
 
#include "QGCSignalTransition.h"
#include "QGCState.h"
 
#include <QtStateMachine/QStateMachine>
#include <functional>
 
template<typename... Args>
class SignalDataTransition : public QGCSignalTransition
{
public:
    SignalDataTransition(const SignalDataTransition&) = delete;
    SignalDataTransition& operator=(const SignalDataTransition&) = delete;
 
    using Guard = std::function<bool(Args...)>;
    using Action = std::function<void(Args...)>;
 
    template<typename Sender, typename Func>
    SignalDataTransition(const Sender* sender, Func signalFn, QAbstractState* target,
                         Guard guard = nullptr, Action action = nullptr)
        : QGCSignalTransition(sender, signalFn)
        , _guard(std::move(guard))
        , _action(std::move(action))
    {
        setTargetState(target);
    }
 
    std::tuple<Args...> signalArgs() const { return _lastArgs; }
 
protected:
    bool eventTest(QEvent* event) override
    {
        if (!QGCSignalTransition::eventTest(event)) {
            return false;
        }
 
        // Extract signal arguments from SignalEvent
        auto* signalEvent = static_cast<QStateMachine::SignalEvent*>(event);
        const QList<QVariant>& arguments = signalEvent->arguments();
 
        // Convert QVariant list to tuple
        _lastArgs = extractArgs(arguments, std::index_sequence_for<Args...>{});
 
        if (_guard) {
            bool allowed = std::apply(_guard, _lastArgs);
            if (!allowed) {
                qCDebug(QGCStateMachineLog) << "SignalDataTransition blocked by guard";
                return false;
            }
        }
 
        return true;
    }
 
    void onTransition(QEvent* event) override
    {
        Q_UNUSED(event);
 
        if (_action) {
            std::apply(_action, _lastArgs);
        }
    }
 
private:
    template<std::size_t... Is>
    std::tuple<Args...> extractArgs(const QList<QVariant>& arguments, std::index_sequence<Is...>)
    {
        return std::make_tuple(
            (Is < static_cast<std::size_t>(arguments.size())
                ? arguments[Is].value<std::tuple_element_t<Is, std::tuple<Args...>>>()
                : std::tuple_element_t<Is, std::tuple<Args...>>{})...
        );
    }
 
    Guard _guard;
    Action _action;
    mutable std::tuple<Args...> _lastArgs;
};
 
template<typename... Args, typename Sender, typename Func>
SignalDataTransition<Args...>* makeSignalDataTransition(
    const Sender* sender, Func signalFn, QAbstractState* target,
    typename SignalDataTransition<Args...>::Guard guard = nullptr,
    typename SignalDataTransition<Args...>::Action action = nullptr)
{
    return new SignalDataTransition<Args...>(sender, signalFn, target, std::move(guard), std::move(action));
}