qscxmlstatemachine_p.h

qt/qtscxml/src/scxml/qscxmlstatemachine_p.h (file symbol)

Enable keyboard shortcuts

Revision control

Copy as Markdown

// Copyright (C) 2016 The Qt Company Ltd.

// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

// Qt-Security score:significant

#ifndef QSCXMLSTATEMACHINE_P_H

#define QSCXMLSTATEMACHINE_P_H

//

//  W A R N I N G

//  -------------

//

// This file is not part of the Qt API.  It exists purely as an

// implementation detail.  This header file may change from version to

// version without notice, or even be removed.

//

// We mean it.

//

#include <QtScxml/private/qscxmlexecutablecontent_p.h>

#include <QtScxml/qscxmlstatemachine.h>

#include <QtScxml/private/qscxmlstatemachineinfo_p.h>

#include <QtCore/private/qobject_p.h>

#include <QtCore/private/qmetaobject_p.h>

#include <QtCore/private/qproperty_p.h>

#include <QtCore/qhash.h>

#include <QtCore/qmap.h>

#include <QtCore/qvariant.h>

#include <QtCore/qmetaobject.h>

#include "qscxmlglobals_p.h"

QT_BEGIN_NAMESPACE

namespace QScxmlInternal {

class EventLoopHook: public QObject

    Q_OBJECT

    QScxmlStateMachinePrivate *smp;

public:

    EventLoopHook(QScxmlStateMachinePrivate *smp)

        : smp(smp)

{}

    void queueProcessEvents();

    Q_INVOKABLE void doProcessEvents();

protected:

    void timerEvent(QTimerEvent *timerEvent) override;

};

class ScxmlEventRouter : public QObject

    Q_OBJECT

public:

    ScxmlEventRouter(QObject *parent = nullptr) : QObject(parent) {}

    QMetaObject::Connection connectToEvent(const QStringList &segments, const QObject *receiver,

                                           const char *method, Qt::ConnectionType type);

    QMetaObject::Connection connectToEvent(const QStringList &segments, const QObject *receiver,

                                           void **slot, QtPrivate::QSlotObjectBase *method,

                                           Qt::ConnectionType type);

    void route(const QStringList &segments, QScxmlEvent *event);

signals:

    void eventOccurred(const QScxmlEvent &event);

private:

    QHash<QString, ScxmlEventRouter *> children;

    ScxmlEventRouter *child(const QString &segment);

    void disconnectNotify(const QMetaMethod &signal) override;

};

class StateMachineInfoProxy: public QObject

    Q_OBJECT

public:

    StateMachineInfoProxy(QObject *parent)

        : QObject(parent)

{}

Q_SIGNALS:

    void statesEntered(const QList<QScxmlStateMachineInfo::StateId> &states);

    void statesExited(const QList<QScxmlStateMachineInfo::StateId> &states);

    void transitionsTriggered(const QList<QScxmlStateMachineInfo::TransitionId> &transitions);

};

} // QScxmlInternal namespace

class QScxmlInvokableService;

class Q_SCXML_EXPORT QScxmlStateMachinePrivate: public QObjectPrivate

    Q_DECLARE_PUBLIC(QScxmlStateMachine)

    static QAtomicInt m_sessionIdCounter;

public: // types

    typedef QScxmlExecutableContent::StateTable StateTable;

    class HistoryContent

        QHash<int, int> storage;

    public:

        HistoryContent() { storage.reserve(4); }

        int &operator[](int idx) {

            QHash<int, int>::Iterator i = storage.find(idx);

            return (i == storage.end()) ? storage.insert(idx, StateTable::InvalidIndex).value() :

                                          i.value();

        int value(int idx) const {

            QHash<int, int>::ConstIterator i = storage.constFind(idx);

            return (i == storage.constEnd()) ? StateTable::InvalidIndex : i.value();

};

    class ParserData

    public:

        QScopedPointer<QScxmlDataModel> m_ownedDataModel;

        QList<QScxmlError> m_errors;

};

    // The OrderedSet is a set where it elements are in insertion order. See

    // http://www.w3.org/TR/scxml/#AlgorithmforSCXMLInterpretation under Algorithm, Datatypes. It

    // is used to keep lists of states and transitions in document order.

    class OrderedSet

        std::vector<int> storage;

    public:

        OrderedSet(){}

        OrderedSet(std::initializer_list<int> l): storage(l) {}

        std::vector<int> takeList() const

        { return std::move(storage); }

        const std::vector<int> &list() const

        { return storage; }

        bool contains(int i) const

            return std::find(storage.cbegin(), storage.cend(), i) != storage.cend();

        bool remove(int i)

            std::vector<int>::iterator it = std::find(storage.begin(), storage.end(), i);

            if (it == storage.end()) {

                return false;

            storage.erase(it);

            return true;

        void removeHead()

        { if (!isEmpty()) storage.erase(storage.begin()); }

        bool isEmpty() const

        { return storage.empty(); }

        void add(int i)

        { if (!contains(i)) storage.push_back(i); }

        bool intersectsWith(const OrderedSet &other) const

            for (auto i : storage) {

                if (other.contains(i)) {

                    return true;

            return false;

        void clear()

        { storage.clear(); }

        typedef std::vector<int>::const_iterator const_iterator;

        const_iterator begin() const { return storage.cbegin(); }

        const_iterator end() const { return storage.cend(); }

};

    class Queue

        QList<QScxmlEvent *> storage;

    public:

        Queue()

        { storage.reserve(4); }

        ~Queue()

        {  qDeleteAll(storage); }

        void enqueue(QScxmlEvent *e)

        { storage.append(e); }

        bool isEmpty() const

        { return storage.empty(); }

        QScxmlEvent *dequeue()

            Q_ASSERT(!isEmpty());

            QScxmlEvent *e = storage.first();

            storage.pop_front();

            int sz = storage.size();

            if (Q_UNLIKELY(sz > 4 && sz * 8 < storage.capacity())) {

                storage.squeeze();

            return e;

};

public:

    QScxmlStateMachinePrivate(const QMetaObject *qMetaObject);

    ~QScxmlStateMachinePrivate();

    static QScxmlStateMachinePrivate *get(QScxmlStateMachine *t)

    { return t->d_func(); }

    static QString generateSessionId(const QString &prefix);

    ParserData *parserData();

    void setIsInvoked(bool invoked)

    { m_isInvoked = invoked; }

    void addService(int invokingState);

    void removeService(int invokingState);

    QScxmlInvokableServiceFactory *serviceFactory(int id);

    bool executeInitialSetup();

    void routeEvent(QScxmlEvent *event);

    void postEvent(QScxmlEvent *event);

    void submitDelayedEvent(QScxmlEvent *event);

    void submitError(const QString &type, const QString &msg, const QString &sendid = QString());

    void start();

    void pause();

    void processEvents();

    void setEvent(QScxmlEvent *event);

    void resetEvent();

    void emitStateActive(int stateIndex, bool active);

    void emitInvokedServicesChanged();

    void attach(QScxmlStateMachineInfo *info);

    const OrderedSet &configuration() const { return m_configuration; }

    void updateMetaCache();

private:

    QStringList stateNames(const std::vector<int> &stateIndexes) const;

    std::vector<int> historyStates(int stateIdx) const;

    void exitInterpreter();

    void returnDoneEvent(QScxmlExecutableContent::ContainerId doneData);

    bool nameMatch(const StateTable::Array &patterns, QScxmlEvent *event) const;

    void selectTransitions(OrderedSet &enabledTransitions,

                           const std::vector<int> &configInDocumentOrder,

                           QScxmlEvent *event) const;

    void removeConflictingTransitions(OrderedSet *enabledTransitions) const;

    void getProperAncestors(std::vector<int> *ancestors, int state1, int state2) const;

    void microstep(const OrderedSet &enabledTransitions);

    void exitStates(const OrderedSet &enabledTransitions);

    void computeExitSet(const OrderedSet &enabledTransitions, OrderedSet &statesToExit) const;

    void executeTransitionContent(const OrderedSet &enabledTransitions);

    void enterStates(const OrderedSet &enabledTransitions);

    void computeEntrySet(const OrderedSet &enabledTransitions,

                         OrderedSet *statesToEnter,

                         OrderedSet *statesForDefaultEntry,

                         HistoryContent *defaultHistoryContent) const;

    void addDescendantStatesToEnter(int stateIndex,

                                    OrderedSet *statesToEnter,

                                    OrderedSet *statesForDefaultEntry,

                                    HistoryContent *defaultHistoryContent) const;

    void addAncestorStatesToEnter(int stateIndex,

                                  int ancestorIndex,

                                  OrderedSet *statesToEnter,

                                  OrderedSet *statesForDefaultEntry,

                                  HistoryContent *defaultHistoryContent) const;

    std::vector<int> getChildStates(const StateTable::State &state) const;

    bool hasDescendant(const OrderedSet &statesToEnter, int childIdx) const;

    bool allDescendants(const OrderedSet &statesToEnter, int childdx) const;

    bool isDescendant(int state1, int state2) const;

    bool allInFinalStates(const std::vector<int> &states) const;

    bool someInFinalStates(const std::vector<int> &states) const;

    bool isInFinalState(int stateIndex) const;

    int getTransitionDomain(int transitionIndex) const;

    int findLCCA(OrderedSet &&states) const;

    void getEffectiveTargetStates(OrderedSet *targets, int transitionIndex) const;

public: // types & data fields:

    QString m_sessionId;

    bool m_isInvoked;

    void isInitializedChanged()

        emit q_func()->initializedChanged(m_isInitialized.value());

    Q_OBJECT_BINDABLE_PROPERTY_WITH_ARGS(QScxmlStateMachinePrivate,

                                         bool, m_isInitialized, false,

                                         &QScxmlStateMachinePrivate::isInitializedChanged);

    void initialValuesChanged()

        emit q_func()->initialValuesChanged(m_initialValues.value());

    Q_OBJECT_BINDABLE_PROPERTY(QScxmlStateMachinePrivate, QVariantMap, m_initialValues,

                               &QScxmlStateMachinePrivate::initialValuesChanged);

    void loaderChanged()

        emit q_func()->loaderChanged(m_loader.value());

    Q_OBJECT_BINDABLE_PROPERTY(QScxmlStateMachinePrivate, QScxmlCompiler::Loader*, m_loader,

                               &QScxmlStateMachinePrivate::loaderChanged);

    void setDataModel(QScxmlDataModel* loader)

        q_func()->setDataModel(loader);

    Q_OBJECT_COMPAT_PROPERTY_WITH_ARGS(QScxmlStateMachinePrivate, QScxmlDataModel*, m_dataModel,

                                       &QScxmlStateMachinePrivate::setDataModel, nullptr);

    void setTableData(QScxmlTableData* tableData)

        q_func()->setTableData(tableData);

    Q_OBJECT_COMPAT_PROPERTY_WITH_ARGS(QScxmlStateMachinePrivate, QScxmlTableData*, m_tableData,

                                       &QScxmlStateMachinePrivate::setTableData, nullptr);

    bool m_isProcessingEvents;

    QScxmlCompilerPrivate::DefaultLoader m_defaultLoader;

    QScxmlExecutionEngine *m_executionEngine;

    const StateTable *m_stateTable;

    QScxmlStateMachine *m_parentStateMachine;

    QScxmlInternal::EventLoopHook m_eventLoopHook;

    typedef std::vector<std::pair<int, QScxmlEvent *>> DelayedQueue;

    DelayedQueue m_delayedEvents;

    const QMetaObject *m_metaObject;

    QScxmlInternal::ScxmlEventRouter m_router;

private:

    QScopedPointer<ParserData> m_parserData; // used when created by StateMachine::fromFile.

    typedef QHash<int, QList<int>> HistoryValues;

    struct InvokedService {

        int invokingState;

        QScxmlInvokableService *service;

        QString serviceName;

};

    // TODO: move the stuff below to a struct that can be reset

    HistoryValues m_historyValue;

    OrderedSet m_configuration;

    Queue m_internalQueue;

    Queue m_externalQueue;

    QSet<int> m_statesToInvoke;

    std::vector<InvokedService> m_invokedServices;

    QList<QScxmlInvokableService*> invokedServicesActualCalculation() const

        QList<QScxmlInvokableService *> result;

        for (size_t i = 0, ei = m_invokedServices.size(); i != ei; ++i) {

            if (auto service = m_invokedServices[i].service)

                result.append(service);

        return result;

    Q_OBJECT_COMPUTED_PROPERTY(QScxmlStateMachinePrivate, QList<QScxmlInvokableService*>,

                               m_invokedServicesComputedProperty,

                               &QScxmlStateMachinePrivate::invokedServicesActualCalculation);

    std::vector<bool> m_isFirstStateEntry;

    std::vector<QScxmlInvokableServiceFactory *> m_cachedFactories;

    enum { Invalid = 0, Starting, Running, Paused, Finished } m_runningState = Invalid;

    bool isRunnable() const {

        switch (m_runningState) {

        case Starting:

        case Running:

        case Paused:

            return true;

        case Invalid:

        case Finished:

            return false;

        return false; // Dead code, but many dumb compilers cannot (or are unwilling to) detect that.

    bool isPaused() const { return m_runningState == Paused; }

    bool isFinished() const { return m_runningState == Finished; }

    QScxmlInternal::StateMachineInfoProxy *m_infoSignalProxy;

    QHash<int, int> m_stateIndexToSignalIndex;

    QHash<QString, int> m_stateNameToSignalIndex;

};

QT_END_NAMESPACE

#endif // QSCXMLSTATEMACHINE_P_H